switch statement

[nedit-bw.git] / callMacroFnByName2.diff

From: Tony Balinski <ajbj@free.fr>
Subject: 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 |   91 ++++++++++++++++++++++++++++++++++++++++++++---------
 source/interpret.h |    4 ++
 source/macro.c     |   28 ++++++++++++++++
 3 files changed, 109 insertions(+), 14 deletions(-)

diff --quilt old/source/interpret.c new/source/interpret.c
--- old/source/interpret.c
+++ new/source/interpret.c
@@ -89,6 +89,7 @@ static int returnValOrNone(int valOnStac
 static int branchIf(Boolean trueOrFalse);
 static int namedArg1orN(Boolean isFirst);
 
+static int callSubroutineFromSymbol(Symbol *sym, int nArgs);
 static int concatenateNwithSep(int nVals, const char *sep, char **result,
         int leaveParams);
 static int makeArrayKeyFromArgs(int nArgs, char **keyString, int leaveParams);
@@ -2440,7 +2441,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)
@@ -2448,30 +2451,21 @@ 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}};
     DataValue argArray = noValue;
     Program *prog;
     char *errMsg;
-    int haveNamedArgs;
-
-    sym = PC->sym;
-    PC++;
-    nArgs = PC->value;
-    PC++;
+    int haveNamedArgs = (nArgs < 0);
 
-    haveNamedArgs = (nArgs < 0);
     if (haveNamedArgs) {
         nArgs = -nArgs - 1;
         POP(argArray);
     }
 
-    DISASM_RT(PC-3, 3);
-    STACKDUMP(nArgs + haveNamedArgs, 3);
-
     /*
     ** If the subroutine is built-in, call the built-in routine
     */
@@ -2568,6 +2562,75 @@ 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 = prog->name;
+    sym.value.tag      = NO_TAG;
+    sym.value.val.prog = 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
@@ -171,6 +171,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
@@ -416,6 +416,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[] = {
@@ -475,6 +477,7 @@ static const BuiltInSubrName MacroSubrs[
     { "get_style_by_name", getStyleByNameMS },
     { "get_style_at_pos", getStyleAtPosMS },
     { "filename_dialog", filenameDialogMS },
+    { "call", callMS },
     { NULL, NULL } /* sentinel */
 };
 
@@ -3493,6 +3496,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)