jim-package.c

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