SUBR_TAG.patch

   1 ---
   2
   3  source/interpret.c |   60 ++++++++++++++++++++++++++++++++++++++++++++++++++---
   4  source/interpret.h |    3 +-
   5  source/macro.c     |   25 +++++++++++++++-------
   6  3 files changed, 77 insertions(+), 11 deletions(-)
   7
   8 diff --quilt old/source/interpret.c new/source/interpret.c
   9 --- old/source/interpret.c
  10 +++ new/source/interpret.c
  11 @@ -184,11 +184,11 @@ static void disasmInternal(Inst *inst, i
  12  #endif /* #ifndef DEBUG_ASSEMBLY */
  13
  14  #ifdef DEBUG_STACK      /* for run-time instruction and stack trace */
  15  static void stackdump(int n, int extra);
  16  static void stackdumpInternal(int n, int extra);
  17 -#define STACKDUMP(n, x) stackdump(n, x)
  18 +#define STACKDUMP(n, x) stackdump(n, (x) + 10)
  19  #define DISASM_RT(i, n) disasm(NULL, i, n)
  20  #else /* #ifndef DEBUG_STACK */
  21  #define STACKDUMP(n, x)
  22  #define DISASM_RT(i, n)
  23  #endif /* #ifndef DEBUG_STACK */
  24 @@ -304,10 +304,11 @@ static int (*OpFns[N_OPS])() = {returnNo
  25              return execError(StackOverflowMsg, ""); \
  26          } \
  27      } while (0)
  28
  29  static const char *tagToStr(enum typeTags tag);
  30 +static const char *typeToStr(enum symTypes type);
  31
  32  /*
  33  ** Initialize macro language global variables.  Must be called before
  34  ** any macros are even parsed, because the parser uses action routine
  35  ** symbols to comprehend hyphenated names.
  36 @@ -425,10 +426,11 @@ int AddSym(Symbol *sym, char **msg)
  37  {
  38      if (ProgP >= &Prog[PROGRAM_SIZE]) {
  39         *msg = "macro too large";
  40         return 0;
  41      }
  42 +    sym->added = 1;
  43      ProgP->sym = sym;
  44      ProgP++;
  45      return 1;
  46  }
  47
  48 @@ -863,10 +865,11 @@ Symbol *InstallSymbol(const char *name,
  49      s = (Symbol *)malloc(sizeof(Symbol));
  50      s->name = (char *)malloc(strlen(name)+1); /* +1 for '\0' */
  51      strcpy(s->name, name);
  52      s->type = type;
  53      s->value = value;
  54 +    s->added = 0;
  55      if (type == LOCAL_SYM) {
  56         s->next = LocalSymList;
  57         LocalSymList = s;
  58      } else {
  59         s->next = GlobalSymList;
  60 @@ -880,13 +883,12 @@ Symbol *InstallSymbol(const char *name,
  61  ** list.
  62  */
  63  Symbol *PromoteToGlobal(Symbol *sym)
  64  {
  65      Symbol *s;
  66 -    static DataValue noValue = {NO_TAG, {0}};
  67
  68 -    if (sym->type != LOCAL_SYM)
  69 +    if (sym->type != LOCAL_SYM || sym->added)
  70         return sym;
  71
  72      /* Remove sym from the local symbol list */
  73      if (sym == LocalSymList)
  74         LocalSymList = sym->next;
  75 @@ -1384,10 +1386,15 @@ static int pushSymVal(void)
  76         char *errMsg;
  77         if (!(s->value.val.subr)(FocusWindow, NULL, 0,
  78                 &symVal, &errMsg)) {
  79             return execError(errMsg, s->name);
  80          }
  81 +    } else if (s->type == C_FUNCTION_SYM
  82 +            || s->type == MACRO_FUNCTION_SYM
  83 +            || s->type == ACTION_ROUTINE_SYM) {
  84 +        symVal.tag = SUBR_TAG;
  85 +        symVal.val.sym = s;
  86      } else
  87         return execError("reading non-variable: %s", s->name);
  88      if (symVal.tag == NO_TAG && !inTypeOfMode) {
  89         return execError("variable not set: %s", s->name);
  90      }
  91 @@ -2470,14 +2477,28 @@ static int callSubroutineFromSymbol(Symb
  92      int i;
  93      static DataValue noValue = {NO_TAG, {0}};
  94      Program *prog;
  95      char *errMsg;
  96      int haveNamedArgs = (nArgs < 0);
  97 +    DataValue *symValPtr = NULL;
  98
  99      if (haveNamedArgs)
 100        nArgs = -nArgs - 1;
 101
 102 +    if (sym->type == LOCAL_SYM) {
 103 +        symValPtr = &FP_GET_SYM_VAL(FrameP, sym);
 104 +    } else if (sym->type == GLOBAL_SYM) {
 105 +        symValPtr = &sym->value;
 106 +    }
 107 +    if (symValPtr) {
 108 +        if (symValPtr->tag == SUBR_TAG) {
 109 +            sym = symValPtr->val.sym;
 110 +        } else {
 111 +            return execError("%s is not a variable holding a subroutine pointer", sym->name);
 112 +        }
 113 +    }
 114 +
 115      /*
 116      ** If the subroutine is built-in, call the built-in routine
 117      */
 118      if (sym->type == C_FUNCTION_SYM) {
 119         DataValue result;
 120 @@ -3978,10 +3999,13 @@ static int typeOfOut(void)
 121              retVal.val.str.rep = PERM_ALLOC_STR("STRING");
 122              break;
 123          case ARRAY_TAG:
 124              retVal.val.str.rep = PERM_ALLOC_STR("ARRAY");
 125              break;
 126 +        case SUBR_TAG:
 127 +            retVal.val.str.rep = PERM_ALLOC_STR("SUBROUTINE");
 128 +            break;
 129      }
 130      retVal.val.str.len = strlen(retVal.val.str.rep);
 131
 132      if (PC->func == fetchRetVal) {
 133          PUSH(retVal);
 134 @@ -4129,16 +4153,43 @@ static const char *tagToStr(enum typeTag
 135              return "<integer>";
 136          case STRING_TAG:
 137              return "<string>";
 138          case ARRAY_TAG:
 139              return "<array>";
 140 +        case SUBR_TAG:
 141 +            return "<subroutine>";
 142          case NO_TAG:
 143          default:
 144              return "<no value>";
 145      }
 146  }
 147
 148 +static const char *typeToStr(enum symTypes type)
 149 +{
 150 +    switch (type) {
 151 +        case CONST_SYM:
 152 +            return "<const>";
 153 +        case GLOBAL_SYM:
 154 +            return "<global>";
 155 +        case LOCAL_SYM:
 156 +            return "<local>";
 157 +        case ARG_SYM:
 158 +            return "<arg>";
 159 +        case PROC_VALUE_SYM:
 160 +            return "<proc value>";
 161 +        case C_FUNCTION_SYM:
 162 +            return "<C function>";
 163 +        case MACRO_FUNCTION_SYM:
 164 +            return "<macro function>";
 165 +        case ACTION_ROUTINE_SYM:
 166 +            return "<action routine>";
 167 +    }
 168 +
 169 +    return "";
 170 +}
 171 +
 172 +
 173  #ifdef DEBUG_DISASSEMBLER   /* dumping values in disassembly or stack dump */
 174  static char *printdBuffer = NULL;
 175  static int printdPos = 0;
 176  static int printdSize = 0;
 177
 178 @@ -4253,10 +4304,13 @@ static void dumpVal(DataValue dv)
 179              }
 180              break;
 181          case ARRAY_TAG:
 182              printd("<array> %8p[%d]", dv.val.arrayPtr, ArraySize(&dv));
 183              break;
 184 +        case SUBR_TAG:
 185 +            printd("<subroutine> %s", dv.val.sym->name);
 186 +            break;
 187          case NO_TAG:
 188              if (!dv.val.inst) {
 189                  printd("<no value>");
 190              }
 191              else {
 192 diff --quilt old/source/interpret.h new/source/interpret.h
 193 --- old/source/interpret.h
 194 +++ new/source/interpret.h
 195 @@ -58,11 +58,11 @@ enum operations {OP_RETURN_NO_VAL, OP_RE
 196      OP_ARRAY_INDEX,
 197      OP_ARRAY_MULTI_ITER,
 198      OP_BEGIN_ARRAY_MULTI_ITER_ARRAY, OP_ARRAY_MULTI_ITER_ARRAY, OP_POP,
 199      N_OPS};
 200
 201 -enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG};
 202 +enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG, SUBR_TAG};
 203
 204  enum execReturnCodes {MACRO_TIME_LIMIT, MACRO_PREEMPT, MACRO_DONE, MACRO_ERROR};
 205
 206  #define ARRAY_DIM_SEP "\034"
 207
 208 @@ -110,10 +110,11 @@ typedef struct SparseArrayEntryTag {
 209  typedef struct SymbolRec {
 210      char *name;
 211      enum symTypes type;
 212      DataValue value;
 213      struct SymbolRec *next;     /* to link to another */
 214 +    int added;
 215  } Symbol;
 216
 217  typedef struct ProgramTag {
 218      Symbol *localSymList;
 219      Inst *code;
 220 diff --quilt old/source/macro.c new/source/macro.c
 221 --- old/source/macro.c
 222 +++ new/source/macro.c
 223 @@ -3842,31 +3842,39 @@ static int filenameDialogMS(WindowInfo*
 224   * call(fnname, arg, ...)
 225   */
 226  static int callMS(WindowInfo *window, DataValue *argList,
 227          int nArgs, DataValue *result, char **errMsg)
 228  {
 229 -    char stringStorage[TYPE_INT_STR_SIZE(int)];
 230      Symbol *sym;
 231 -    char *fnname;
 232
 233      if (nArgs < 1) {
 234          *errMsg = "subroutine %s called without arguments";
 235          return False;
 236      }
 237 -    if (!readStringArg(argList[0], &fnname, stringStorage, errMsg)) {
 238 -        return False;
 239 +    if (argList[0].tag == SUBR_TAG) {
 240 +        sym = argList[0].val.sym;
 241 +    } else {
 242 +        char stringStorage[TYPE_INT_STR_SIZE(int)];
 243 +        char *fnname;
 244 +
 245 +        if (!readStringArg(argList[0], &fnname, stringStorage, errMsg)) {
 246 +            return False;
 247 +        }
 248 +
 249 +        sym = LookupSymbol(fnname);
 250      }
 251 -    sym = LookupSymbol(fnname);
 252 +
 253      if (!sym) {
 254          *errMsg = "subroutine name invalid";
 255          return False;
 256      }
 257 +
 258      return OverlayRoutineFromSymbol(sym, nArgs, 1);
 259  }
 260
 261  /*
 262 - * define(func_name, func_body[, "override"])
 263 + * subr = define(func_name, func_body[, "override"])
 264   */
 265  static int defineMS(WindowInfo *window, DataValue *argList, int nArgs,
 266          DataValue *result, char **errMsg)
 267  {
 268      char stringStorage[3][TYPE_INT_STR_SIZE(int)];
 269 @@ -3876,11 +3884,10 @@ static int defineMS(WindowInfo *window,
 270      char *stoppedAt = NULL;
 271      char *namePtr;
 272      char *override = NULL;
 273      Program *prog;
 274      Symbol *sym;
 275 -    DataValue subrPtr;
 276
 277      if (nArgs < 2 || nArgs > 3) {
 278          return wrongNArgsErr(errMsg);
 279      }
 280      if (!readStringArg(argList[0], &name, stringStorage[0], errMsg)) {
 281 @@ -3944,15 +3951,19 @@ static int defineMS(WindowInfo *window,
 282              }
 283              FreeProgram(sym->value.val.prog);
 284              sym->value.val.prog = prog;
 285          }
 286      } else {
 287 +        DataValue subrPtr;
 288          subrPtr.val.prog = prog;
 289          subrPtr.tag = NO_TAG;
 290          sym = InstallSymbol(name, MACRO_FUNCTION_SYM, subrPtr);
 291      }
 292
 293 +    result->tag = SUBR_TAG;
 294 +    result->val.sym = sym;
 295 +
 296      return True;
 297  }
 298
 299  /*
 300   * set_window_title(format[, ("text"|"format")])