jim-package.c

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