change-sym-types.patch

   1 ---
   2
   3  source/interpret.c |  120 +++++++++++++++++++++++++++++------------------------
   4  source/interpret.h |   20 ++++++--
   5  source/macro.c     |   39 ++++++++++-------
   6  source/parse.y     |   14 ++++--
   7  4 files changed, 114 insertions(+), 79 deletions(-)
   8
   9 diff --quilt old/source/interpret.c new/source/interpret.c
  10 --- old/source/interpret.c
  11 +++ new/source/interpret.c
  12 @@ -76,7 +76,7 @@ static const char CVSID[] = "$Id: interp
  13  #define NEEDS_BREAK 1
  14  #define NEEDS_CONTINUE 2
  15
  16 -#define N_ARGS_ARG_SYM -1      /* special arg number meaning $n_args value */
  17 +#define N_ARGS_ARG_VAR -1      /* special arg number meaning $n_args value */
  18
  19  enum opStatusCodes {STAT_OK=2, STAT_DONE, STAT_ERROR, STAT_PREEMPT};
  20
  21 @@ -228,26 +228,30 @@ void InitMacroGlobals(void)
  22
  23      /* Add action routines from NEdit menus and text widget */
  24      actions = GetMenuActions(&nActions);
  25 +    dv.tag = ACTION_SUBR_TAG;
  26      for (i=0; i<nActions; i++) {
  27         dv.val.xtproc = actions[i].proc;
  28 -       InstallSymbol(actions[i].string, ACTION_ROUTINE_SYM, dv);
  29 +        InstallSymbol(actions[i].string, GLOBAL_SCOPE, READONLY_ATTR, dv);
  30      }
  31      actions = TextGetActions(&nActions);
  32 +    dv.tag = ACTION_SUBR_TAG;
  33      for (i=0; i<nActions; i++) {
  34         dv.val.xtproc = actions[i].proc;
  35 -       InstallSymbol(actions[i].string, ACTION_ROUTINE_SYM, dv);
  36 +        InstallSymbol(actions[i].string, GLOBAL_SCOPE, READONLY_ATTR, dv);
  37      }
  38
  39      /* Add subroutine argument symbols ($1, $2, ..., $9) */
  40 +    dv.tag = ARG_VAR_TAG;
  41      for (i=0; i<9; i++) {
  42         argName[1] = '1' + i;
  43         dv.val.n = i;
  44 -       InstallSymbol(argName, ARG_SYM, dv);
  45 +        InstallSymbol(argName, GLOBAL_SCOPE, READONLY_ATTR, dv);
  46      }
  47
  48      /* Add special symbol $n_args */
  49 -    dv.val.n = N_ARGS_ARG_SYM;
  50 -    InstallSymbol("$n_args", ARG_SYM, dv);
  51 +    dv.tag = ARG_VAR_TAG;
  52 +    dv.val.n = N_ARGS_ARG_VAR;
  53 +    InstallSymbol("$n_args", GLOBAL_SCOPE, READONLY_ATTR, dv);
  54  }
  55
  56  /*
  57 @@ -830,8 +834,8 @@ static Symbol *lookupSymbol(Symbol *syml
  58  /*
  59  ** find a symbol in the symbol table
  60  **
  61 -** will create only LOCAL_SYM and GLOBAL_SYM (depending on first character)
  62 -** with a NO_TAG value
  63 +** will create only LOCAL_SCOPE and GLOBAL_SCOPE (depending on first character)
  64 +** with a NO_TAG value and NO_ATTR
  65  */
  66  Symbol *LookupSymbol(const char *name, int create)
  67  {
  68 @@ -855,8 +859,8 @@ Symbol *LookupSymbol(const char *name, i
  69
  70      if (create) {
  71          DataValue noValue = {NO_TAG, {0}};
  72 -        s = InstallSymbol(name, name[0] == '$' ? GLOBAL_SYM : LOCAL_SYM,
  73 -                noValue);
  74 +        s = InstallSymbol(name, name[0] == '$' ? GLOBAL_SCOPE : LOCAL_SCOPE,
  75 +                NO_ATTR, noValue);
  76      }
  77
  78      return s;
  79 @@ -865,16 +869,17 @@ Symbol *LookupSymbol(const char *name, i
  80  /*
  81  ** install symbol name in symbol table
  82  */
  83 -Symbol *InstallSymbol(const char *name, enum symTypes type, DataValue value)
  84 +Symbol *InstallSymbol(const char *name, enum symScope scope, unsigned attr,
  85 +        DataValue value)
  86  {
  87      Symbol *s;
  88
  89      s = XtNew(Symbol);
  90      s->name = LookupString(name, True);
  91 -    s->type = type;
  92 +    s->attr = attr;
  93      s->value = value;
  94      s->hash = hashName(s->name);
  95 -    if (type == LOCAL_SYM) {
  96 +    if (scope == LOCAL_SCOPE) {
  97          if (Interpreter) {
  98              s->next = LocalSymList;
  99              LocalSymList = s;
 100 @@ -1443,36 +1448,49 @@ static void addToGlobalSymTab(Symbol *sy
 101  static int pushSymVal(void)
 102  {
 103      Symbol *s;
 104 -    int nArgs, argNum;
 105 -    DataValue symVal;
 106 +    DataValue symVal = {NO_TAG, {0}};
 107
 108      DISASM_RT();
 109      STACKDUMP(0, 3);
 110
 111      GET_SYM(s, False);
 112
 113 -    if (s->type == LOCAL_SYM || s->type == GLOBAL_SYM) {
 114 +    switch (s->value.tag) {
 115 +    case INT_TAG:
 116 +    case STRING_TAG:
 117 +    case ARRAY_TAG:
 118          symVal = s->value;
 119 -    } else if (s->type == ARG_SYM) {
 120 -       nArgs = FP_GET_ARG_COUNT(FrameP);
 121 -       argNum = s->value.val.n;
 122 -       if (argNum >= nArgs) {
 123 -            EXEC_ERROR("referenced undefined argument: %s", s->name);
 124 -        }
 125 -       if (argNum == N_ARGS_ARG_SYM) {
 126 -            symVal.tag = INT_TAG;
 127 -            symVal.val.n = nArgs;
 128 -       }
 129 -        else {
 130 -            symVal = FP_GET_ARG_N(FrameP, argNum);
 131 +    case NO_TAG:
 132 +        break;
 133 +
 134 +    case ARG_VAR_TAG: {
 135 +            int nArgs = FP_GET_ARG_COUNT(FrameP);
 136 +            int argNum = s->value.val.n;
 137 +            if (argNum >= nArgs) {
 138 +                EXEC_ERROR("referenced undefined argument: %s", s->name);
 139 +            }
 140 +            if (argNum == N_ARGS_ARG_VAR) {
 141 +                symVal.tag = INT_TAG;
 142 +                symVal.val.n = nArgs;
 143 +            }
 144 +            else {
 145 +                symVal = FP_GET_ARG_N(FrameP, argNum);
 146 +            }
 147          }
 148 -    } else if (s->type == PROC_VALUE_SYM) {
 149 -        char *errMsg;
 150 -        if (!s->value.val.subr(FocusWindow, NULL, 0, &symVal, &errMsg)) {
 151 -            EXEC_ERROR(errMsg, s->name);
 152 +        break;
 153 +
 154 +    case BUILT_IN_VAR_TAG: {
 155 +            char *errMsg;
 156 +            if (!s->value.val.subr(FocusWindow, NULL, 0, &symVal, &errMsg)) {
 157 +                EXEC_ERROR(errMsg, s->name);
 158 +            }
 159          }
 160 -    } else
 161 +        break;
 162 +
 163 +    default:
 164          EXEC_ERROR("reading non-variable: %s", s->name);
 165 +    }
 166 +
 167      if (symVal.tag == NO_TAG && !inTypeOfMode) {
 168          EXEC_ERROR("variable not set: %s", s->name);
 169      }
 170 @@ -1604,7 +1622,7 @@ static int pushArraySymVal(void)
 171      GET_SYM(sym, True);
 172      GET_IMMED(initEmpty);
 173
 174 -    if (sym->type != LOCAL_SYM && sym->type != GLOBAL_SYM) {
 175 +    if (sym->attr & READONLY_ATTR) {
 176          EXEC_ERROR("assigning to non-lvalue array or non-array: %s", sym->name);
 177      }
 178      dataPtr = &sym->value;
 179 @@ -1911,16 +1929,8 @@ static int assign(void)
 180
 181      GET_SYM(sym, True);
 182
 183 -    if (sym->type != GLOBAL_SYM && sym->type != LOCAL_SYM) {
 184 -        if (sym->type == ARG_SYM) {
 185 -            EXEC_ERROR("assignment to function argument: %s", sym->name);
 186 -        }
 187 -        else if (sym->type == PROC_VALUE_SYM) {
 188 -            EXEC_ERROR("assignment to read-only variable: %s", sym->name);
 189 -        }
 190 -        else {
 191 -            EXEC_ERROR("assignment to non-variable: %s", sym->name);
 192 -        }
 193 +    if (sym->attr & READONLY_ATTR) {
 194 +        EXEC_ERROR("assignment to read-only variable: %s", sym->name);
 195      }
 196      dataPtr = &sym->value;
 197
 198 @@ -2638,7 +2648,7 @@ static int callSubroutineFromSymbol(Symb
 199      /*
 200      ** If the subroutine is built-in, call the built-in routine
 201      */
 202 -    if (sym->type == C_FUNCTION_SYM) {
 203 +    if (sym->value.tag == BUILT_IN_SUBR_TAG) {
 204         DataValue result;
 205          char *errMsg;
 206
 207 @@ -2663,7 +2673,7 @@ static int callSubroutineFromSymbol(Symb
 208      ** stack for local variables (and initialize them), on top of the argument
 209      ** values which are already there.
 210      */
 211 -    if (sym->type == MACRO_FUNCTION_SYM) {
 212 +    if (sym->value.tag == MACRO_SUBR_TAG) {
 213          prog = sym->value.val.prog;
 214          prog->refcount++;
 215          /* -nArgs means 'arguments are on stack' */
 216 @@ -2673,7 +2683,7 @@ static int callSubroutineFromSymbol(Symb
 217      /*
 218      ** Call an action routine
 219      */
 220 -    if (sym->type == ACTION_ROUTINE_SYM) {
 221 +    if (sym->value.tag == ACTION_SUBR_TAG) {
 222          String *argList;
 223         Cardinal numArgs = nArgs;
 224         XKeyEvent key_event;
 225 @@ -2717,7 +2727,7 @@ static int callSubroutineFromSymbol(Symb
 226      }
 227
 228      /* Calling a non subroutine symbol */
 229 -    EXEC_ERROR("%s is not a function or subroutine", sym->name);
 230 +    EXEC_ERROR("Calling non subroutine %s", sym->name);
 231  }
 232
 233  /*
 234 @@ -2880,9 +2890,9 @@ int OverlayRoutineFromProg(Program *prog
 235  {
 236      Symbol sym;
 237
 238 -    sym.type = MACRO_FUNCTION_SYM;
 239 +    sym.attr = NO_ATTR;
 240      sym.name = LookupString(prog->name, True);
 241 -    sym.value.tag      = NO_TAG;
 242 +    sym.value.tag      = MACRO_SUBR_TAG;
 243      sym.value.val.prog = prog;
 244      sym.next = NULL;
 245
 246 @@ -3593,14 +3603,14 @@ static int arrayIter(void)
 247
 248      POP(iterator);
 249
 250 -    if (keySym->type != LOCAL_SYM && keySym->type != GLOBAL_SYM) {
 251 +    if (keySym->attr & READONLY_ATTR) {
 252          EXEC_ERROR("can't assign to: %s", keySym->name);
 253      }
 254      keyValPtr = &keySym->value;
 255      keyValPtr->tag = NO_TAG;
 256
 257      if (withVal) {
 258 -        if (valSym->type != LOCAL_SYM && valSym->type != GLOBAL_SYM) {
 259 +        if (valSym->attr & READONLY_ATTR) {
 260              EXEC_ERROR("can't assign to: %s", valSym->name);
 261          }
 262          valPtr = &valSym->value;
 263 @@ -3751,7 +3761,7 @@ static int arrayIterArray(void)
 264      POP(iterator);
 265      PEEK_INT(nDims, 0);
 266
 267 -    if (keyArraySym->type != LOCAL_SYM && keyArraySym->type != GLOBAL_SYM) {
 268 +    if (keyArraySym->attr & READONLY_ATTR) {
 269          EXEC_ERROR("can't assign to: %s", keyArraySym->name);
 270      }
 271      keyArrayPtr = &keyArraySym->value;
 272 @@ -3759,7 +3769,7 @@ static int arrayIterArray(void)
 273      keyArrayPtr->val.arrayPtr = NULL;
 274
 275      if (withVal) {
 276 -        if (valSym->type != LOCAL_SYM && valSym->type != GLOBAL_SYM) {
 277 +        if (valSym->attr & READONLY_ATTR) {
 278              EXEC_ERROR("can't assign to: %s", valSym->name);
 279          }
 280          valPtr = &valSym->value;
 281 @@ -3937,6 +3947,8 @@ static int typeOfOut(void)
 282          case ARRAY_TAG:
 283              retVal.val.str.rep = PERM_ALLOC_STR("ARRAY");
 284              break;
 285 +        default:
 286 +            retVal.val.str.rep = PERM_ALLOC_STR("UNKNOWN");
 287      }
 288      retVal.val.str.len = strlen(retVal.val.str.rep);
 289
 290 diff --quilt old/source/interpret.h new/source/interpret.h
 291 --- old/source/interpret.h
 292 +++ new/source/interpret.h
 293 @@ -40,8 +40,10 @@
 294  #define LOOP_STACK_SIZE 256     /* (Approx.) Number of break/continue stmts
 295                                     allowed per program */
 296
 297 -enum symTypes {GLOBAL_SYM, LOCAL_SYM, ARG_SYM, PROC_VALUE_SYM,
 298 -       C_FUNCTION_SYM, MACRO_FUNCTION_SYM, ACTION_ROUTINE_SYM};
 299 +/* LOCAL_SYM  -> LOCAL_SCOPE */
 300 +/* GLOBAL_SYM -> GLOBAL_SCOPE */
 301 +enum symScope {LOCAL_SCOPE, GLOBAL_SCOPE};
 302 +enum symAttr {NO_ATTR = 0, READONLY_ATTR = 1 << 0};
 303
 304  enum operations {
 305  #define OP(name, fn) OP_##name,
 306 @@ -50,7 +52,14 @@ enum operations {
 307      N_OPS
 308  };
 309
 310 -enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG};
 311 +/* ARG_SYM            -> ARG_VAR_TAG */
 312 +/* MACRO_FUNCTION_SYM -> MACRO_SUBR_TAG */
 313 +/* C_FUNCTION_SYM     -> BUILT_IN_SUBR_TAG */
 314 +/* PROC_VALUE_SYM     -> BUILT_IN_VAR_TAG */
 315 +/* ACTION_ROUTINE_SYM -> ACTION_SUBR_TAG */
 316 +enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG, ARG_VAR_TAG,
 317 +        BUILT_IN_VAR_TAG, BUILT_IN_SUBR_TAG, MACRO_SUBR_TAG,
 318 +        ACTION_SUBR_TAG};
 319
 320  enum execReturnCodes {MACRO_TIME_LIMIT, MACRO_PREEMPT, MACRO_DONE, MACRO_ERROR};
 321
 322 @@ -105,7 +114,7 @@ typedef struct SparseArrayEntryTag {
 323  /* symbol table entry */
 324  typedef struct SymbolRec {
 325      const char *name;
 326 -    enum symTypes type;
 327 +    unsigned attr;
 328      DataValue value;
 329      unsigned int hash;
 330      struct SymbolRec *next;     /* to link to another */
 331 @@ -161,7 +170,8 @@ int AddBranchOffset(Inst *to, char **msg
 332  int SetBranchOffset(Inst *from, Inst *to, char **msg);
 333  Inst *GetPC(void);
 334  Symbol *LookupSymbol(const char *name, int create);
 335 -Symbol *InstallSymbol(const char *name, enum symTypes type, DataValue value);
 336 +Symbol *InstallSymbol(const char *name, enum symScope scope, unsigned attr,
 337 +        DataValue value);
 338  const char *LookupString(const char *str, int create);
 339  Inst *SwapCode(Inst *start, Inst *boundary, Inst *end);
 340  int StartLoopAddrList(char **msg);
 341 diff --quilt old/source/macro.c new/source/macro.c
 342 --- old/source/macro.c
 343 +++ new/source/macro.c
 344 @@ -671,14 +671,15 @@ static char EscapeChars[] = "\\\"\n\t\b\
 345  /*
 346  ** Installs a set of built-in macro subroutines as symbols of given type.
 347  */
 348 -void RegisterMacroSubroutineSet(const BuiltInSubrName *set, enum symTypes type)
 349 +void RegisterMacroSubroutineSet(const BuiltInSubrName *set, enum typeTags tag)
 350  {
 351      static DataValue subrPtr = {NO_TAG, {0}};
 352      unsigned i;
 353
 354 +    subrPtr.tag = tag;
 355      for (i = 0; set[i].name; i++) {
 356          subrPtr.val.subr = set[i].macroSubr;
 357 -        InstallSymbol(set[i].name, type, subrPtr);
 358 +        InstallSymbol(set[i].name, GLOBAL_SCOPE, READONLY_ATTR, subrPtr);
 359      }
 360  }
 361
 362 @@ -686,7 +687,7 @@ void RegisterMacroSubroutineSet(const Bu
 363  ** Installs a set of built-in macro secondary return values as symbols of
 364  ** given type.
 365  */
 366 -void RegisterGlobalReturnValuesSet(ReturnGlobalName *set, enum symTypes type)
 367 +void RegisterGlobalReturnValuesSet(ReturnGlobalName *set)
 368  {
 369      int n, i, oldn;
 370      Symbol **newRetGlobals;
 371 @@ -710,7 +711,8 @@ void RegisterGlobalReturnValuesSet(Retur
 372      /* now assign the (new) symbols at the newly allocated end of the table
 373         and store the indices in set */
 374      for (i = 0, n = oldn; set[i].name; i++, n++) {
 375 -        ReturnGlobals[n] = InstallSymbol(set[i].name, type, noValue);
 376 +        ReturnGlobals[n] = InstallSymbol(set[i].name, GLOBAL_SCOPE,
 377 +                READONLY_ATTR, noValue);
 378          *set[i].pIndex = n;
 379      }
 380      /* add the sentinel */
 381 @@ -725,10 +727,10 @@ void RegisterMacroSubroutines(void)
 382  {
 383      /* Install symbols for built-in routines and variables, with pointers
 384         to the appropriate c routines to do the work */
 385 -    RegisterMacroSubroutineSet(MacroSubrs, C_FUNCTION_SYM);
 386 -    RegisterMacroSubroutineSet(SpecialVars, PROC_VALUE_SYM);
 387 +    RegisterMacroSubroutineSet(MacroSubrs, BUILT_IN_SUBR_TAG);
 388 +    RegisterMacroSubroutineSet(SpecialVars, BUILT_IN_VAR_TAG);
 389      /* Define global variables used for return values */
 390 -    RegisterGlobalReturnValuesSet(ReturnGlobalNames, GLOBAL_SYM);
 391 +    RegisterGlobalReturnValuesSet(ReturnGlobalNames);
 392  }
 393
 394  #define MAX_LEARN_MSG_LEN ((2 * MAX_ACCEL_LEN) + 60)
 395 @@ -3908,20 +3910,25 @@ static int defineMS(WindowInfo *window,
 396              FreeProgram(prog);
 397              *errMsg = "Try to override existing function.";
 398              return False;
 399 -        } else {
 400 -            if (sym->type != MACRO_FUNCTION_SYM) {
 401 +        }
 402 +        else if (sym->attr & READONLY_ATTR) {
 403 +            FreeProgram(prog);
 404 +            *errMsg = "Try to override read only symbol.";
 405 +            return False;
 406 +        }
 407 +        else if (sym->value.tag != MACRO_SUBR_TAG) {
 408                  FreeProgram(prog);
 409                  *errMsg = "Try to override a non macro function.";
 410                  return False;
 411 -            }
 412 -            FreeProgram(sym->value.val.prog);
 413 -            sym->value.val.prog = prog;
 414          }
 415 -    } else {
 416 +        FreeProgram(sym->value.val.prog);
 417 +        sym->value.val.prog = prog;
 418 +    }
 419 +    else {
 420          DataValue subrPtr;
 421 -        subrPtr.tag = NO_TAG;
 422 +        subrPtr.tag = MACRO_SUBR_TAG;
 423          subrPtr.val.prog = prog;
 424 -        sym = InstallSymbol(name, MACRO_FUNCTION_SYM, subrPtr);
 425 +        sym = InstallSymbol(name, GLOBAL_SCOPE, NO_ATTR, subrPtr);
 426      }
 427
 428      return True;
 429 @@ -7314,7 +7321,7 @@ Boolean MacroApplyHook(WindowInfo *docum
 430      Boolean succ = False;
 431
 432      hookSymbol = LookupSymbol(hook, False);
 433 -    if (NULL != hookSymbol && MACRO_FUNCTION_SYM == hookSymbol->type) {
 434 +    if (NULL != hookSymbol && MACRO_SUBR_TAG == hookSymbol->value.tag) {
 435          Program *hookProg = hookSymbol->value.val.prog;
 436          RestartData *restartData;
 437          DataValue dummyResultDV;
 438 diff --quilt old/source/parse.y new/source/parse.y
 439 --- old/source/parse.y
 440 +++ new/source/parse.y
 441 @@ -207,16 +207,22 @@ define:     definekw blank definesym bla
 442                  prog = FinishCreatingProgram($3);
 443                  sym = LookupSymbol(prog->name, False);
 444                  if (sym) {
 445 -                    if (sym->type != MACRO_FUNCTION_SYM) {
 446 +                    if (sym->attr & READONLY_ATTR) {
 447                          FreeProgram(prog);
 448 -                        yyerror("try to override built-in subroutine"); YYERROR;
 449 +                        yyerror("try to re-define read-only symbol");
 450 +                        YYERROR;
 451 +                    }
 452 +                    else if (sym->value.tag != MACRO_SUBR_TAG) {
 453 +                        FreeProgram(prog);
 454 +                        yyerror("try to override built-in subroutine");
 455 +                        YYERROR;
 456                      }
 457                      FreeProgram(sym->value.val.prog);
 458                  }
 459                  else {
 460                      DataValue subrPtr;
 461 -                    subrPtr.tag = NO_TAG;
 462 -                    sym = InstallSymbol(prog->name, MACRO_FUNCTION_SYM,
 463 +                    subrPtr.tag = MACRO_SUBR_TAG;
 464 +                    sym = InstallSymbol(prog->name, GLOBAL_SCOPE, NO_ATTR,
 465                              subrPtr);
 466                  }
 467                  sym->value.val.prog = prog;