release/src/router/usbmodeswitch/jim/jim-package.c

   1 #include <unistd.h>
   2 #include <string.h>
   3
   4 #include "jim.h"
   5 #include "jimautoconf.h"
   6 #include "jim-subcmd.h"
   7
   8 /* -----------------------------------------------------------------------------
   9  * Packages handling
  10  * ---------------------------------------------------------------------------*/
  11
  12 int Jim_PackageProvide(Jim_Interp *interp, const char *name, const char *ver, int flags)
  13 {
  14     /* If the package was already provided returns an error. */
  15     Jim_HashEntry *he = Jim_FindHashEntry(&interp->packages, name);
  16
  17     /* An empty result means the automatic entry. This can be replaced */
  18     if (he && *(const char *)he->u.val) {
  19         if (flags & JIM_ERRMSG) {
  20             Jim_SetResultFormatted(interp, "package \"%s\" was already provided", name);
  21         }
  22         return JIM_ERR;
  23     }
  24     if (he) {
  25         Jim_DeleteHashEntry(&interp->packages, name);
  26     }
  27     Jim_AddHashEntry(&interp->packages, name, (char *)ver);
  28     return JIM_OK;
  29 }
  30
  31 static char *JimFindPackage(Jim_Interp *interp, char **prefixes, int prefixc, const char *pkgName)
  32 {
  33     int i;
  34     char *buf = Jim_Alloc(JIM_PATH_LEN);
  35
  36     for (i = 0; i < prefixc; i++) {
  37         if (prefixes[i] == NULL)
  38             continue;
  39
  40         /* Loadable modules are tried first */
  41 #ifdef jim_ext_load
  42         snprintf(buf, JIM_PATH_LEN, "%s/%s.so", prefixes[i], pkgName);
  43         if (access(buf, R_OK) == 0) {
  44             return buf;
  45         }
  46 #endif
  47         if (strcmp(prefixes[i], ".") == 0) {
  48             snprintf(buf, JIM_PATH_LEN, "%s.tcl", pkgName);
  49         }
  50         else {
  51             snprintf(buf, JIM_PATH_LEN, "%s/%s.tcl", prefixes[i], pkgName);
  52         }
  53
  54         if (access(buf, R_OK) == 0) {
  55             return buf;
  56         }
  57     }
  58     Jim_Free(buf);
  59     return NULL;
  60 }
  61
  62 /* Search for a suitable package under every dir specified by JIM_LIBPATH,
  63  * and load it if possible. If a suitable package was loaded with success
  64  * JIM_OK is returned, otherwise JIM_ERR is returned. */
  65 static int JimLoadPackage(Jim_Interp *interp, const char *name, int flags)
  66 {
  67     Jim_Obj *libPathObjPtr;
  68     char **prefixes, *path;
  69     int prefixc, i, retCode = JIM_ERR;
  70
  71     libPathObjPtr = Jim_GetGlobalVariableStr(interp, JIM_LIBPATH, JIM_NONE);
  72     if (libPathObjPtr == NULL) {
  73         prefixc = 0;
  74         libPathObjPtr = NULL;
  75     }
  76     else {
  77         Jim_IncrRefCount(libPathObjPtr);
  78         prefixc = Jim_ListLength(interp, libPathObjPtr);
  79     }
  80
  81     prefixes = Jim_Alloc(sizeof(char *) * prefixc);
  82     for (i = 0; i < prefixc; i++) {
  83         Jim_Obj *prefixObjPtr;
  84
  85         if (Jim_ListIndex(interp, libPathObjPtr, i, &prefixObjPtr, JIM_NONE) != JIM_OK) {
  86             prefixes[i] = NULL;
  87             continue;
  88         }
  89         prefixes[i] = Jim_StrDup(Jim_String(prefixObjPtr));
  90     }
  91
  92     /* Scan every directory for the the first match */
  93     path = JimFindPackage(interp, prefixes, prefixc, name);
  94     if (path != NULL) {
  95         char *p = strrchr(path, '.');
  96
  97         /* Note: Even if the file fails to load, we consider the package loaded.
  98          *       This prevents issues with recursion.
  99          *       Use a dummy version of "" to signify this case.
 100          */
 101         Jim_PackageProvide(interp, name, "", 0);
 102
 103         /* Try to load/source it */
 104         if (p && strcmp(p, ".tcl") == 0) {
 105             retCode = Jim_EvalFileGlobal(interp, path);
 106         }
 107 #ifdef jim_ext_load
 108         else {
 109             retCode = Jim_LoadLibrary(interp, path);
 110         }
 111 #endif
 112         if (retCode != JIM_OK) {
 113             /* Upon failure, remove the dummy entry */
 114             Jim_DeleteHashEntry(&interp->packages, name);
 115         }
 116         Jim_Free(path);
 117     }
 118     for (i = 0; i < prefixc; i++)
 119         Jim_Free(prefixes[i]);
 120     Jim_Free(prefixes);
 121     if (libPathObjPtr)
 122         Jim_DecrRefCount(interp, libPathObjPtr);
 123     return retCode;
 124 }
 125
 126 int Jim_PackageRequire(Jim_Interp *interp, const char *name, int flags)
 127 {
 128     Jim_HashEntry *he;
 129
 130     /* Start with an empty error string */
 131     Jim_SetResultString(interp, "", 0);
 132
 133     he = Jim_FindHashEntry(&interp->packages, name);
 134     if (he == NULL) {
 135         /* Try to load the package. */
 136         int retcode = JimLoadPackage(interp, name, flags);
 137         if (retcode != JIM_OK) {
 138             if (flags & JIM_ERRMSG) {
 139                 int len;
 140
 141                 Jim_GetString(Jim_GetResult(interp), &len);
 142                 Jim_SetResultFormatted(interp, "%#s%sCan't load package %s",
 143                     Jim_GetResult(interp), len ? "\n" : "", name);
 144             }
 145             return retcode;
 146         }
 147
 148         /* In case the package did no 'package provide' */
 149         Jim_PackageProvide(interp, name, "1.0", 0);
 150
 151         /* Now it must exist */
 152         he = Jim_FindHashEntry(&interp->packages, name);
 153     }
 154
 155     Jim_SetResultString(interp, he->u.val, -1);
 156     return JIM_OK;
 157 }
 158
 159 /*
 160  *----------------------------------------------------------------------
 161  *
 162  * package provide name ?version?
 163  *
 164  *      This procedure is invoked to declare that a particular version
 165  *      of a particular package is now present in an interpreter.  There
 166  *      must not be any other version of this package already
 167  *      provided in the interpreter.
 168  *
 169  * Results:
 170  *      Returns JIM_OK and sets the package version (or 1.0 if not specified).
 171  *
 172  *----------------------------------------------------------------------
 173  */
 174 static int package_cmd_provide(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 175 {
 176     const char *version = "1.0";
 177
 178     if (argc == 2) {
 179         version = Jim_String(argv[1]);
 180     }
 181     return Jim_PackageProvide(interp, Jim_String(argv[0]), version, JIM_ERRMSG);
 182 }
 183
 184 /*
 185  *----------------------------------------------------------------------
 186  *
 187  * package require name ?version?
 188  *
 189  *      This procedure is load a given package.
 190  *      Note that the version is ignored.
 191  *
 192  * Results:
 193  *      Returns JIM_OK and sets the package version.
 194  *
 195  *----------------------------------------------------------------------
 196  */
 197 static int package_cmd_require(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 198 {
 199     /* package require failing is important enough to add to the stack */
 200     interp->addStackTrace++;
 201
 202     return Jim_PackageRequire(interp, Jim_String(argv[0]), JIM_ERRMSG);
 203 }
 204
 205 /*
 206  *----------------------------------------------------------------------
 207  *
 208  * package list
 209  *
 210  *      Returns a list of known packages
 211  *
 212  * Results:
 213  *      Returns JIM_OK and sets a list of known packages.
 214  *
 215  *----------------------------------------------------------------------
 216  */
 217 static int package_cmd_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 218 {
 219     Jim_HashTableIterator *htiter;
 220     Jim_HashEntry *he;
 221     Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0);
 222
 223     htiter = Jim_GetHashTableIterator(&interp->packages);
 224     while ((he = Jim_NextHashEntry(htiter)) != NULL) {
 225         Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, he->key, -1));
 226     }
 227     Jim_FreeHashTableIterator(htiter);
 228
 229     Jim_SetResult(interp, listObjPtr);
 230
 231     return JIM_OK;
 232 }
 233
 234 static const jim_subcmd_type package_command_table[] = {
 235     {.cmd = "provide",
 236             .args = "name ?version?",
 237             .function = package_cmd_provide,
 238             .minargs = 1,
 239             .maxargs = 2,
 240         .description = "Indicates that the current script provides the given package"},
 241     {.cmd = "require",
 242             .args = "name ?version?",
 243             .function = package_cmd_require,
 244             .minargs = 1,
 245             .maxargs = 2,
 246         .description = "Loads the given package by looking in standard places"},
 247     {.cmd = "list",
 248             .function = package_cmd_list,
 249             .minargs = 0,
 250             .maxargs = 0,
 251         .description = "Lists all known packages"},
 252     {0}
 253 };
 254
 255 int Jim_packageInit(Jim_Interp *interp)
 256 {
 257     Jim_CreateCommand(interp, "package", Jim_SubCmdProc, (void *)package_command_table, NULL);
 258     return JIM_OK;
 259 }