jim-namespace.c

   1 /*
   2  * Support for namespaces in jim
   3  *
   4  * (c) 2011 Steve Bennett <steveb@workware.net.au>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above
  13  *    copyright notice, this list of conditions and the following
  14  *    disclaimer in the documentation and/or other materials
  15  *    provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  21  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  28  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and documentation
  31  * are those of the authors and should not be interpreted as representing
  32  * official policies, either expressed or implied, of the Jim Tcl Project.
  33  *
  34  * Based on code originally from Tcl 6.7:
  35  *
  36  * Copyright 1987-1991 Regents of the University of California
  37  * Permission to use, copy, modify, and distribute this
  38  * software and its documentation for any purpose and without
  39  * fee is hereby granted, provided that the above copyright
  40  * notice appear in all copies.  The University of California
  41  * makes no representations about the suitability of this
  42  * software for any purpose.  It is provided "as is" without
  43  * express or implied warranty.
  44  */
  45
  46 #include <limits.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <stdio.h>
  50 #include <assert.h>
  51
  52 #include "jim.h"
  53 #include "jimautoconf.h"
  54 #include "jim-subcmd.h"
  55
  56 /* -----------------------------------------------------------------------------
  57  * Namespace support
  58  * ---------------------------------------------------------------------------*/
  59
  60 /**
  61  * nsObj is a canonical namespace name (.e.g. "" for root, "abc" for ::abc)
  62  *
  63  * The given name is appended to the namespace name to produce a complete canonical name.
  64  *
  65  * e.g. "" "abc"         => abc
  66  *      "" "::abc"       => abc
  67  *      "" "abc::def"    => abc::def
  68  *      "abc" "def"      => abc::def
  69  *      "abc" "::def"    => def
  70  *
  71  */
  72 Jim_Obj *JimCanonicalNamespace(Jim_Interp *interp, Jim_Obj *nsObj, Jim_Obj *nameObj)
  73 {
  74     Jim_Obj *objPtr;
  75     const char *name = Jim_String(nameObj);
  76     assert(nameObj->refCount != 0);
  77     assert(nsObj->refCount != 0);
  78     if (name[0] == ':' && name[1] == ':') {
  79         /* Absolute namespace */
  80         while (*++name == ':') {
  81         }
  82         return Jim_NewStringObj(interp, name, -1);
  83     }
  84     if (Jim_Length(nsObj) == 0) {
  85         /* Relative to the global namespace */
  86         return nameObj;
  87     }
  88     /* Relative to non-global namespace */
  89     objPtr = Jim_DuplicateObj(interp, nsObj);
  90     Jim_AppendString(interp, objPtr, "::", 2);
  91     Jim_AppendObj(interp, objPtr, nameObj);
  92     return objPtr;
  93 }
  94
  95 int Jim_CreateNamespaceVariable(Jim_Interp *interp, Jim_Obj *varNameObj, Jim_Obj *targetNameObj)
  96 {
  97     int rc;
  98     Jim_IncrRefCount(varNameObj);
  99     Jim_IncrRefCount(targetNameObj);
 100
 101     /* push non-namespace vars if in namespace eval? */
 102     rc  = Jim_SetVariableLink(interp, varNameObj, targetNameObj, interp->topFramePtr);
 103     if (rc == JIM_ERR) {
 104         /* This is the only reason the link can fail */
 105         Jim_SetResultFormatted(interp, "can't define \"%#s\": name refers to an element in an array", varNameObj);
 106     }
 107
 108     Jim_DecrRefCount(interp, varNameObj);
 109     Jim_DecrRefCount(interp, targetNameObj);
 110
 111     return rc;
 112 }
 113
 114 /**
 115  * Returns the parent of the given namespace.
 116  *
 117  * ::bob::tom => ::bob
 118  * bob::tom   => bob
 119  * ::bob      => ::
 120  * bob        => ""
 121  * ::         => ""
 122  * ""         => ""
 123  */
 124 Jim_Obj *Jim_NamespaceQualifiers(Jim_Interp *interp, Jim_Obj *ns)
 125 {
 126     const char *name = Jim_String(ns);
 127     const char *pt = strrchr(name, ':');
 128     if (pt && pt != name && pt[-1] == ':') {
 129         return Jim_NewStringObj(interp, name, pt - name - 1);
 130     }
 131     else {
 132         return interp->emptyObj;
 133     }
 134 }
 135
 136 Jim_Obj *Jim_NamespaceTail(Jim_Interp *interp, Jim_Obj *ns)
 137 {
 138     const char *name = Jim_String(ns);
 139     const char *pt = strrchr(name, ':');
 140     if (pt && pt != name && pt[-1] == ':') {
 141         return Jim_NewStringObj(interp, pt + 1, -1);
 142     }
 143     else {
 144         return ns;
 145     }
 146 }
 147
 148 static Jim_Obj *JimNamespaceCurrent(Jim_Interp *interp)
 149 {
 150     Jim_Obj *objPtr = Jim_NewStringObj(interp, "::", 2);
 151     Jim_AppendObj(interp, objPtr, interp->framePtr->nsObj);
 152     return objPtr;
 153 }
 154
 155 static int JimVariableCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 156 {
 157     int retcode = JIM_OK;
 158
 159     if (argc > 3) {
 160         Jim_WrongNumArgs(interp, 1, argv, "name ?value?");
 161         return JIM_ERR;
 162     }
 163     if (argc > 1) {
 164         Jim_Obj *targetNameObj;
 165         Jim_Obj *localNameObj;
 166
 167         targetNameObj = JimCanonicalNamespace(interp, interp->framePtr->nsObj, argv[1]);
 168
 169         localNameObj = Jim_NamespaceTail(interp, argv[1]);
 170         Jim_IncrRefCount(localNameObj);
 171         if (interp->framePtr->level != 0 || Jim_Length(interp->framePtr->nsObj) != 0) {
 172             retcode = Jim_CreateNamespaceVariable(interp, localNameObj, targetNameObj);
 173         }
 174
 175         /* Set the variable via the local name */
 176         if (retcode == JIM_OK && argc > 2) {
 177             retcode = Jim_SetVariable(interp, localNameObj, argv[2]);
 178         }
 179         Jim_DecrRefCount(interp, localNameObj);
 180     }
 181     return retcode;
 182 }
 183
 184 /* Used to invoke script-based helpers.
 185  * It would be ideal if ensembles were supported in the core
 186  */
 187 static int Jim_EvalEnsemble(Jim_Interp *interp, const char *basecmd, const char *subcmd, int argc, Jim_Obj *const *argv)
 188 {
 189     Jim_Obj *prefixObj = Jim_NewStringObj(interp, basecmd, -1);
 190
 191     Jim_AppendString(interp, prefixObj, " ", 1);
 192     Jim_AppendString(interp, prefixObj, subcmd, -1);
 193
 194     return Jim_EvalObjPrefix(interp, prefixObj, argc, argv);
 195 }
 196
 197 static int JimNamespaceCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 198 {
 199     Jim_Obj *nsObj;
 200     Jim_Obj *objPtr;
 201     int option;
 202     static const char * const options[] = {
 203         "eval", "current", "canonical", "qualifiers", "parent", "tail", "delete",
 204         "origin", "code", "inscope", "import", "export",
 205         "which", "upvar", NULL
 206     };
 207     enum
 208     {
 209         OPT_EVAL, OPT_CURRENT, OPT_CANONICAL, OPT_QUALIFIERS, OPT_PARENT, OPT_TAIL, OPT_DELETE,
 210         OPT_ORIGIN, OPT_CODE, OPT_INSCOPE, OPT_IMPORT, OPT_EXPORT,
 211         OPT_WHICH, OPT_UPVAR,
 212     };
 213
 214     if (argc < 2) {
 215         Jim_WrongNumArgs(interp, 1, argv, "subcommand ?arg ...?");
 216         return JIM_ERR;
 217     }
 218
 219     if (Jim_GetEnum(interp, argv[1], options, &option, "subcommand", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
 220         return JIM_ERR;
 221     }
 222
 223     switch (option) {
 224         case OPT_EVAL:
 225             if (argc < 4) {
 226                 Jim_WrongNumArgs(interp, 2, argv, "name arg ?arg...?");
 227                 return JIM_ERR;
 228             }
 229             if (argc == 4) {
 230                 objPtr = argv[3];
 231             }
 232             else {
 233                 objPtr = Jim_ConcatObj(interp, argc - 3, argv + 3);
 234             }
 235
 236             nsObj = JimCanonicalNamespace(interp, interp->framePtr->nsObj, argv[2]);
 237             return Jim_EvalNamespace(interp, objPtr, nsObj);
 238
 239         case OPT_CURRENT:
 240             if (argc != 2) {
 241                 Jim_WrongNumArgs(interp, 2, argv, "");
 242                 return JIM_ERR;
 243             }
 244             Jim_SetResult(interp, JimNamespaceCurrent(interp));
 245             return JIM_OK;
 246
 247         case OPT_CANONICAL:
 248             if (argc > 4) {
 249                 Jim_WrongNumArgs(interp, 2, argv, "?current? ?name?");
 250                 return JIM_ERR;
 251             }
 252             if (argc == 2) {
 253                 Jim_SetResult(interp, interp->framePtr->nsObj);
 254             }
 255             else if (argc == 3) {
 256                 Jim_SetResult(interp, JimCanonicalNamespace(interp, interp->framePtr->nsObj, argv[2]));
 257             }
 258             else {
 259                 Jim_SetResult(interp, JimCanonicalNamespace(interp, argv[2], argv[3]));
 260             }
 261             return JIM_OK;
 262
 263         case OPT_QUALIFIERS:
 264             if (argc != 3) {
 265                 Jim_WrongNumArgs(interp, 2, argv, "string");
 266                 return JIM_ERR;
 267             }
 268             Jim_SetResult(interp, Jim_NamespaceQualifiers(interp, argv[2]));
 269             return JIM_OK;
 270
 271         case OPT_EXPORT:
 272             return JIM_OK;
 273
 274         case OPT_TAIL:
 275             if (argc != 3) {
 276                 Jim_WrongNumArgs(interp, 2, argv, "string");
 277                 return JIM_ERR;
 278             }
 279             Jim_SetResult(interp, Jim_NamespaceTail(interp, argv[2]));
 280             return JIM_OK;
 281
 282         case OPT_PARENT:
 283             if (argc != 2 && argc != 3) {
 284                 Jim_WrongNumArgs(interp, 2, argv, "?name?");
 285                 return JIM_ERR;
 286             }
 287             else {
 288                 const char *name;
 289
 290                 if (argc == 3) {
 291                     objPtr = argv[2];
 292                 }
 293                 else {
 294                     objPtr = interp->framePtr->nsObj;
 295                 }
 296                 if (Jim_Length(objPtr) == 0 || Jim_CompareStringImmediate(interp, objPtr, "::")) {
 297                     return JIM_OK;
 298                 }
 299                 objPtr = Jim_NamespaceQualifiers(interp, objPtr);
 300
 301                 name = Jim_String(objPtr);
 302
 303                 if (name[0] != ':' || name[1] != ':') {
 304                     /* Make it fully scoped */
 305                     Jim_SetResultString(interp, "::", 2);
 306                     Jim_AppendObj(interp, Jim_GetResult(interp), objPtr);
 307                     Jim_IncrRefCount(objPtr);
 308                     Jim_DecrRefCount(interp, objPtr);
 309                 }
 310                 else {
 311                     Jim_SetResult(interp, objPtr);
 312                 }
 313             }
 314             return JIM_OK;
 315     }
 316
 317     /* Implemented as a Tcl helper proc.
 318      * Note that calling a proc will change the current namespace,
 319      * so helper procs must call [uplevel namespace canon] to get the callers
 320      * namespace.
 321      */
 322     return Jim_EvalEnsemble(interp, "namespace", options[option], argc - 2, argv + 2);
 323 }
 324
 325 int Jim_namespaceInit(Jim_Interp *interp)
 326 {
 327     if (Jim_PackageProvide(interp, "namespace", "1.0", JIM_ERRMSG))
 328         return JIM_ERR;
 329
 330     Jim_CreateCommand(interp, "namespace", JimNamespaceCmd, NULL, NULL);
 331     Jim_CreateCommand(interp, "variable", JimVariableCmd, NULL, NULL);
 332     return JIM_OK;
 333 }
 334