add cast to XtCalloc() call

[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 |   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
@@ -87,10 +87,11 @@ static void restoreContext(RestartData *
 #undef OP
 static int returnValOrNone(int valOnStack);
 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);
 static void freeSymbolTable(Symbol *symTab);
 static int errCheck(const char *s);
@@ -2435,37 +2436,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) {
@@ -2590,10 +2585,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
@@ -168,10 +168,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
@@ -414,10 +414,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 },
@@ -473,10 +475,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 },
@@ -3495,10 +3498,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;