extend-for-key-in-array-syntax: update to key=val syntax

[nedit-bw.git] / callMacroFnByName2.diff

    Provide a call() macro function which calls another function given its name

    The function invokes new code in interpret.c which calls the desired, named
    function with any remaining arguments to call(). In this way, the function
    is called using the same interpretation environment as call()'s invoker.

---

 source/interpret.c |   93 ++++++++++++++++++++++++++++++++++++++++++++---------
 source/interpret.h |    4 ++
 source/macro.c     |   28 +++++++++++++++
 3 files changed, 110 insertions(+), 15 deletions(-)

diff --quilt old/source/interpret.c new/source/interpret.c
--- old/source/interpret.c
+++ new/source/interpret.c
@@ -115,10 +115,11 @@ static int not(void);
 static int power(void);
 static int concatenateNwithSep(int nVals, const char *sep, char **result,
         int leaveParams);
 static int concat(void);
 static int assign(void);
+static int callSubroutineFromSymbol(Symbol *sym, int nArgs);
 static int callSubroutine(void);
 static int fetchRetVal(void);
 static int branch(void);
 static int branchTrue(void);
 static int branchFalse(void);
@@ -2334,37 +2335,31 @@ static int concat(void)
 **
 ** For a macro subroutine, the return address, frame pointer, number of
 ** arguments and space for local variables are added to the stack, and the
 ** PC is set to point to the new function. For a built-in routine, the
 ** arguments are popped off the stack, and the routine is just called.
-**
+*/
+/*
+** For callSubroutine:
 ** Before: Prog->  [subrSym], nArgs, next, ...
 **         TheStack-> argArray?, argN-arg1, next, ...
 ** After:  Prog->  next, ...            -- (built-in called subr)
 **         TheStack-> retVal?, next, ...
 **    or:  Prog->  (in called)next, ... -- (macro code called subr)
 **         TheStack-> symN-sym1(FP), nArgs, oldFP, retPC, argArray, argN-arg1, next, ...
 */
-static int callSubroutine(void)
+static int callSubroutineFromSymbol(Symbol *sym, int nArgs)
 {
-    Symbol *sym, *s;
-    int i, nArgs;
+    Symbol *s;
+    int i;
     static DataValue noValue = {NO_TAG, {0}};
     Program *prog;
     char *errMsg;
-    int haveNamedArgs;
-
-    sym = PC->sym;
-    PC++;
-    nArgs = PC->value;
-    PC++;
-
-    haveNamedArgs = (nArgs < 0);
-    nArgs = (haveNamedArgs) ? -nArgs - 1 : nArgs;
+    int haveNamedArgs = (nArgs < 0);
 
-    DISASM_RT(PC-3, 3);
-    STACKDUMP(nArgs + haveNamedArgs, 3);
+    if (haveNamedArgs)
+      nArgs = -nArgs - 1;
 
     /*
     ** If the subroutine is built-in, call the built-in routine
     */
     if (sym->type == C_FUNCTION_SYM) {
@@ -2487,10 +2482,78 @@ static int callSubroutine(void)
     /* Calling a non subroutine symbol */
     return execError("%s is not a function or subroutine", sym->name);
 }
 
 /*
+** Before: Prog->  [subrSym], nArgs, next, ...
+**         Stack-> argN-arg1, next, ...
+**
+** After:  Prog->  next, ...            -- (built-in called subr)
+**         Stack-> retVal?, next, ...
+**    or:  Prog->  (in called)next, ... -- (macro code called subr)
+**         Stack-> symN-sym1(FP), argArray, nArgs, oldFP, retPC, argN-arg1, next, ...
+*/
+static int callSubroutine(void)
+{
+    Symbol *sym;
+    int nArgs;
+    int n;
+
+    sym = PC++->sym;
+    nArgs = PC++->value;
+
+    DISASM_RT(PC-3, 3);
+    STACKDUMP(nArgs, 3);
+
+    return callSubroutineFromSymbol(sym, nArgs);
+}
+
+/*
+** Assumes a valid symbol. Invokes callSubroutineFromSymbol(), correcting nArgs
+** to match that routine's expectations. This allows a callMS() function to be
+** written in macro.c. If the caller has already "consumed" stack elements,
+** removeArgs must indicate how many.
+*/
+
+int OverlayRoutineFromSymbol(Symbol *sym, int nArgs, int removeArgs)
+{
+    DataValue *stackTop = StackP + nArgs - removeArgs;
+
+    if (removeArgs > 0) {
+        DataValue *from = StackP + removeArgs;
+        DataValue *to = StackP;
+        int n = nArgs - removeArgs;
+
+        nArgs = n;
+        while (n--) {
+            *to++ = *from++;
+        }
+    }
+
+    StackP = stackTop;
+    return callSubroutineFromSymbol(sym, nArgs);
+}
+
+/*
+** Assumes a valid prog. Wraps the program in a dummy symbol then calls
+** OverlayRoutineFromSymbol(). In this way a piece of compiled code can be
+** executed in the caller's context from a function in macro.c.
+*/
+
+int OverlayRoutineFromProg(Program *prog, int nArgs, int removeArgs)
+{
+    Symbol sym;
+
+    sym.type = MACRO_FUNCTION_SYM;
+    sym.name = "<overlaid function>";
+    sym.value.val.str.rep = (char *)prog;
+    sym.next = NULL;
+
+    return OverlayRoutineFromSymbol(&sym, nArgs, removeArgs);
+}
+
+/*
 ** This should never be executed, returnVal checks for the presence of this
 ** instruction at the PC to decide whether to push the function's return
 ** value, then skips over it without executing.
 */
 static int fetchRetVal(void)
diff --quilt old/source/interpret.h new/source/interpret.h
--- old/source/interpret.h
+++ new/source/interpret.h
@@ -163,10 +163,14 @@ void FillLoopAddrs(Inst *breakAddr, Inst
 int ExecuteMacro(WindowInfo *window, Program *prog, int nArgs, DataValue *args,
        DataValue *result, RestartData **continuation, char **msg);
 int ContinueMacro(RestartData *continuation, DataValue *result, char **msg);
 void RunMacroAsSubrCall(Program *prog);
 void PreemptMacro(void);
+
+int OverlayRoutineFromProg(Program *prog, int nArgs, int removeArgs);
+int OverlayRoutineFromSymbol(Symbol *sym, int nArgs, int removeArgs);
+
 char *AllocString(int length);
 char *AllocStringNCpy(const char *s, int length);
 char *AllocStringCpy(const char *s);
 char *AllocStringOfNumber(long val);
 int AllocNString(NString *string, int length);
diff --quilt old/source/macro.c new/source/macro.c
--- old/source/macro.c
+++ new/source/macro.c
@@ -403,10 +403,12 @@ static int getStyleByNameMS(WindowInfo *
         DataValue *result, char **errMsg);
 static int getStyleAtPosMS(WindowInfo *window, DataValue *argList, int nArgs,
         DataValue *result, char **errMsg);
 static int filenameDialogMS(WindowInfo* window, DataValue* argList, int nArgs,
         DataValue* result, char** errMsg);
+static int callMS(WindowInfo *window, DataValue *argList,
+        int nArgs, DataValue *result, char **errMsg);
 
 /* Built-in subroutines and variables for the macro language */
 static const BuiltInSubrName MacroSubrs[] = {
     { "length", lengthMS },
     { "get_range", getRangeMS },
@@ -462,10 +464,11 @@ static const BuiltInSubrName MacroSubrs[
     { "get_pattern_by_name", getPatternByNameMS },
     { "get_pattern_at_pos", getPatternAtPosMS },
     { "get_style_by_name", getStyleByNameMS },
     { "get_style_at_pos", getStyleAtPosMS },
     { "filename_dialog", filenameDialogMS },
+    { "call", callMS },
     { NULL, NULL } /* sentinel */
 };
 
 static const BuiltInSubrName SpecialVars[] = {
     { "$cursor", cursorMV },
@@ -3571,10 +3574,35 @@ static int filenameDialogMS(WindowInfo* 
     }
 
     return True;
 }
 
+/*
+ * call(fnname, arg, ...)
+ */
+static int callMS(WindowInfo *window, DataValue *argList,
+        int nArgs, DataValue *result, char **errMsg)
+{
+    char stringStorage[TYPE_INT_STR_SIZE(int)];
+    Symbol *sym;
+    char *fnname;
+
+    if (nArgs < 1) {
+        *errMsg = "subroutine %s called without arguments";
+        return False;
+    }
+    if (!readStringArg(argList[0], &fnname, stringStorage, errMsg)) {
+        return False;
+    }
+    sym = LookupSymbol(fnname);
+    if (!sym) {
+        *errMsg = "subroutine name invalid";
+        return False;
+    }
+    return OverlayRoutineFromSymbol(sym, nArgs, 1);
+}
+
 /* T Balinski */
 static int listDialogMS(WindowInfo *window, DataValue *argList, int nArgs,
       DataValue *result, char **errMsg)
 {
     macroCmdInfo *cmdData;