CVS rebase

[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
@@ -117,6 +117,7 @@ static int concatenateNwithSep(int nVals
         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);
@@ -2366,7 +2367,9 @@ static int concat(void)
 ** 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)
@@ -2374,25 +2377,17 @@ static int concat(void)
 **    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
@@ -2519,6 +2514,74 @@ static int callSubroutine(void)
 }
 
 /*
+** 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.
diff --quilt old/source/interpret.h new/source/interpret.h
--- old/source/interpret.h
+++ new/source/interpret.h
@@ -165,6 +165,10 @@ int ExecuteMacro(WindowInfo *window, Pro
 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);
diff --quilt old/source/macro.c new/source/macro.c
--- old/source/macro.c
+++ new/source/macro.c
@@ -405,6 +405,8 @@ static int getStyleAtPosMS(WindowInfo *w
         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[] = {
@@ -464,6 +466,7 @@ static const BuiltInSubrName MacroSubrs[
     { "get_style_by_name", getStyleByNameMS },
     { "get_style_at_pos", getStyleAtPosMS },
     { "filename_dialog", filenameDialogMS },
+    { "call", callMS },
     { NULL, NULL } /* sentinel */
 };
 
@@ -3566,6 +3569,31 @@ 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)