callMacroFnByName2.diff

   1 From: Tony Balinski <ajbj@free.fr>
   2 Subject: Provide a call() macro function which calls another function given its name
   3
   4 The function invokes new code in interpret.c which calls the desired, named
   5 function with any remaining arguments to call(). In this way, the function
   6 is called using the same interpretation environment as call()'s invoker.
   7
   8 ---
   9
  10  source/built-ins.h |    1
  11  source/interpret.c |   91 ++++++++++++++++++++++++++++++++++++++++++++---------
  12  source/interpret.h |    4 ++
  13  source/macro.c     |   25 ++++++++++++++
  14  4 files changed, 107 insertions(+), 14 deletions(-)
  15
  16 diff --quilt old/source/interpret.c new/source/interpret.c
  17 --- old/source/interpret.c
  18 +++ new/source/interpret.c
  19 @@ -89,6 +89,7 @@ static int returnValOrNone(int valOnStac
  20  static int branchIf(Boolean trueOrFalse);
  21  static int namedArg1orN(Boolean isFirst);
  22
  23 +static int callSubroutineFromSymbol(Symbol *sym, int nArgs);
  24  static int concatenateNwithSep(int nVals, const char *sep, char **result,
  25          int leaveParams);
  26  static int makeArrayKeyFromArgs(int nArgs, char **keyString, int leaveParams);
  27 @@ -2440,7 +2441,9 @@ static int concat(void)
  28  ** arguments and space for local variables are added to the stack, and the
  29  ** PC is set to point to the new function. For a built-in routine, the
  30  ** arguments are popped off the stack, and the routine is just called.
  31 -**
  32 +*/
  33 +/*
  34 +** For callSubroutine:
  35  ** Before: Prog->  [subrSym], nArgs, next, ...
  36  **         TheStack-> argArray?, argN-arg1, next, ...
  37  ** After:  Prog->  next, ...            -- (built-in called subr)
  38 @@ -2448,30 +2451,21 @@ static int concat(void)
  39  **    or:  Prog->  (in called)next, ... -- (macro code called subr)
  40  **         TheStack-> symN-sym1(FP), nArgs, oldFP, retPC, argArray, argN-arg1, next, ...
  41  */
  42 -static int callSubroutine(void)
  43 +static int callSubroutineFromSymbol(Symbol *sym, int nArgs)
  44  {
  45 -    Symbol *sym, *s;
  46 -    int i, nArgs;
  47 +    Symbol *s;
  48 +    int i;
  49      static DataValue noValue = {NO_TAG, {0}};
  50      DataValue argArray = noValue;
  51      Program *prog;
  52      char *errMsg;
  53 -    int haveNamedArgs;
  54 -
  55 -    sym = PC->sym;
  56 -    PC++;
  57 -    nArgs = PC->value;
  58 -    PC++;
  59 +    int haveNamedArgs = (nArgs < 0);
  60
  61 -    haveNamedArgs = (nArgs < 0);
  62      if (haveNamedArgs) {
  63          nArgs = -nArgs - 1;
  64          POP(argArray);
  65      }
  66
  67 -    DISASM_RT(PC-3, 3);
  68 -    STACKDUMP(nArgs + haveNamedArgs, 3);
  69 -
  70      /*
  71      ** If the subroutine is built-in, call the built-in routine
  72      */
  73 @@ -2568,6 +2562,75 @@ static int callSubroutine(void)
  74  }
  75
  76  /*
  77 +** Before: Prog->  [subrSym], nArgs, next, ...
  78 +**         Stack-> argN-arg1, next, ...
  79 +**
  80 +** After:  Prog->  next, ...            -- (built-in called subr)
  81 +**         Stack-> retVal?, next, ...
  82 +**    or:  Prog->  (in called)next, ... -- (macro code called subr)
  83 +**         Stack-> symN-sym1(FP), argArray, nArgs, oldFP, retPC, argN-arg1, next, ...
  84 +*/
  85 +static int callSubroutine(void)
  86 +{
  87 +    Symbol *sym;
  88 +    int nArgs;
  89 +    int n;
  90 +
  91 +    sym = PC++->sym;
  92 +    nArgs = PC++->value;
  93 +
  94 +    DISASM_RT(PC-3, 3);
  95 +    STACKDUMP(nArgs, 3);
  96 +
  97 +    return callSubroutineFromSymbol(sym, nArgs);
  98 +}
  99 +
 100 +/*
 101 +** Assumes a valid symbol. Invokes callSubroutineFromSymbol(), correcting nArgs
 102 +** to match that routine's expectations. This allows a callMS() function to be
 103 +** written in macro.c. If the caller has already "consumed" stack elements,
 104 +** removeArgs must indicate how many.
 105 +*/
 106 +
 107 +int OverlayRoutineFromSymbol(Symbol *sym, int nArgs, int removeArgs)
 108 +{
 109 +    DataValue *stackTop = StackP + nArgs - removeArgs;
 110 +
 111 +    if (removeArgs > 0) {
 112 +        DataValue *from = StackP + removeArgs;
 113 +        DataValue *to = StackP;
 114 +        int n = nArgs - removeArgs;
 115 +
 116 +        nArgs = n;
 117 +        while (n--) {
 118 +            *to++ = *from++;
 119 +        }
 120 +    }
 121 +
 122 +    StackP = stackTop;
 123 +    return callSubroutineFromSymbol(sym, nArgs);
 124 +}
 125 +
 126 +/*
 127 +** Assumes a valid prog. Wraps the program in a dummy symbol then calls
 128 +** OverlayRoutineFromSymbol(). In this way a piece of compiled code can be
 129 +** executed in the caller's context from a function in macro.c.
 130 +*/
 131 +
 132 +int OverlayRoutineFromProg(Program *prog, int nArgs, int removeArgs)
 133 +{
 134 +    Symbol sym;
 135 +
 136 +    sym.type = MACRO_FUNCTION_SYM;
 137 +    sym.name = prog->name;
 138 +    sym.value.tag      = NO_TAG;
 139 +    sym.value.val.prog = prog;
 140 +    sym.next = NULL;
 141 +
 142 +    return OverlayRoutineFromSymbol(&sym, nArgs, removeArgs);
 143 +}
 144 +
 145 +/*
 146  ** This should never be executed, returnVal checks for the presence of this
 147  ** instruction at the PC to decide whether to push the function's return
 148  ** value, then skips over it without executing.
 149 diff --quilt old/source/interpret.h new/source/interpret.h
 150 --- old/source/interpret.h
 151 +++ new/source/interpret.h
 152 @@ -171,6 +171,10 @@ int ExecuteMacro(WindowInfo *window, Pro
 153  int ContinueMacro(RestartData *continuation, DataValue *result, char **msg);
 154  void RunMacroAsSubrCall(Program *prog);
 155  void PreemptMacro(void);
 156 +
 157 +int OverlayRoutineFromProg(Program *prog, int nArgs, int removeArgs);
 158 +int OverlayRoutineFromSymbol(Symbol *sym, int nArgs, int removeArgs);
 159 +
 160  char *AllocString(int length);
 161  char *AllocStringNCpy(const char *s, int length);
 162  char *AllocStringCpy(const char *s);
 163 diff --quilt old/source/macro.c new/source/macro.c
 164 --- old/source/macro.c
 165 +++ new/source/macro.c
 166 @@ -3197,6 +3197,31 @@ static int filenameDialogMS(WindowInfo*
 167      return True;
 168  }
 169
 170 +/*
 171 + * call(fnname, arg, ...)
 172 + */
 173 +static int callMS(WindowInfo *window, DataValue *argList,
 174 +        int nArgs, DataValue *result, char **errMsg)
 175 +{
 176 +    char stringStorage[TYPE_INT_STR_SIZE(int)];
 177 +    Symbol *sym;
 178 +    char *fnname;
 179 +
 180 +    if (nArgs < 1) {
 181 +        *errMsg = "subroutine %s called without arguments";
 182 +        return False;
 183 +    }
 184 +    if (!readStringArg(argList[0], &fnname, stringStorage, errMsg)) {
 185 +        return False;
 186 +    }
 187 +    sym = LookupSymbol(fnname);
 188 +    if (!sym) {
 189 +        *errMsg = "subroutine name invalid";
 190 +        return False;
 191 +    }
 192 +    return OverlayRoutineFromSymbol(sym, nArgs, 1);
 193 +}
 194 +
 195  /* T Balinski */
 196  static int listDialogMS(WindowInfo *window, DataValue *argList, int nArgs,
 197        DataValue *result, char **errMsg)
 198 diff --quilt old/source/built-ins.h new/source/built-ins.h
 199 --- old/source/built-ins.h
 200 +++ new/source/built-ins.h
 201 @@ -58,6 +58,7 @@ MS(get_pattern_at_pos, getPatternAtPos)
 202  MS(get_style_by_name, getStyleByName)
 203  MS(get_style_at_pos, getStyleAtPos)
 204  MS(filename_dialog, filenameDialog)
 205 +MS(call, call)
 206
 207  MV(cursor, cursor)
 208  MV(line, line)