core-typeof-syntax: push up

[nedit-bw.git] / extend-if-key-in-array-syntax.patch

---

 doc/help.etx       |   11 ++---------
 source/interpret.c |   41 ++++++++++++++++++++++++++++++++++++++++-
 source/interpret.h |    1 +
 source/parse.y     |   12 ++++++++++--
 4 files changed, 53 insertions(+), 12 deletions(-)

diff --quilt old/source/interpret.c new/source/interpret.c
--- old/source/interpret.c
+++ new/source/interpret.c
@@ -143,10 +143,11 @@ static int anonArrayIndexVal(void);
 static int anonArrayClose(void);
 static int namedArg1(void);
 static int namedArgN(void);
 static int namedArg1orN(Boolean isFirst);
 static int swapTop2(void);
+static int arrayIndex(void);
 static int makeArrayKeyFromArgs(int nArgs, char **keyString, int leaveParams);
 static void freeSymbolTable(Symbol *symTab);
 static int errCheck(const char *s);
 static int execError(const char *s1, const char *s2);
 static rbTreeNode *arrayEmptyAllocator(void);
@@ -241,10 +242,11 @@ static int (*OpFns[N_OPS])() = {returnNo
     anonArrayOpen, anonArraySkip, anonArrayNextVal, anonArrayIndexVal,
     anonArrayClose, namedArg1, namedArgN, swapTop2,
     callSubroutineStackedN,
     unpackArrayToArgs,
     typeOfIn, typeOfOut,
+    arrayIndex,
     };
 
 /* Stack-> symN-sym0(FP), nArgs, oldFP, retPC, argArray, argN-arg1, next, ... */
 #define FP_ARG_COUNT_INDEX (-1)
 #define FP_FUNCTION_NAME   (-2) /* !! */
@@ -1764,10 +1766,45 @@ static int assign(void)
     }
     return STAT_OK;
 }
 
 /*
+**
+** Before: Prog->  [nDim], next, ...
+**         TheStack-> [indnDim, ... ind1], next, ...
+** After:  Prog->  nDim, [next], ...
+**         TheStack-> kayValue, next, ...
+*/
+static int arrayIndex(void)
+{
+    int errNum;
+    char *keyString = NULL;
+    DataValue keyData;
+    int nDim;
+
+    nDim = PC->value;
+    PC++;
+
+    DISASM_RT(PC-2, 2);
+    STACKDUMP(nDim+3, 3);
+
+    /* the next nDim stack entries form the index */
+    errNum = makeArrayKeyFromArgs(nDim, &keyString, False);
+    if (errNum != STAT_OK) {
+        return errNum;
+    }
+
+    keyData.tag = STRING_TAG;
+    keyData.val.str.rep = keyString;
+    keyData.val.str.len = strlen(keyString);
+
+    PUSH(keyData)
+
+    return STAT_OK;
+}
+
+/*
 ** copy the top value of the stack
 ** Before: TheStack-> value, next, ...
 ** After:  TheStack-> value, value, next, ...
 */
 static int dupStack(void)
@@ -3777,10 +3814,11 @@ static void disasmInternal(Inst *inst, i
         "SWAP_TOP2",                    /* swapTop2: cf namedArgN */
         "SUBR_CALL_STACKED_N",          /* callSubroutineStackedN */
         "UNPACKTOARGS",                 /* unpackArrayToArgs */
         "TYPEOF_IN",                    /* typeOfIn */
         "TYPEOF_OUT",                   /* typeOfOut */
+        "ARRAY_INDEX",                  /* arrayIndex */
     };
     int i, j;
     static size_t opLen;
     
     if (!opLen) {
@@ -3846,11 +3884,12 @@ static void disasmInternal(Inst *inst, i
                 else if (j == OP_ARRAY_REF ||
                          j == OP_ARRAY_DELETE ||
                          j == OP_ARRAY_ASSIGN ||
                          j == OP_ANONARRAY_INDEX_VAL ||
                          j == OP_NAMED_ARG1 ||
-                         j == OP_NAMED_ARGN) {
+                         j == OP_NAMED_ARGN ||
+                         j == OP_ARRAY_INDEX) {
                     printd(" nDim=%d", inst[i+1].value);
                     ++i;
                 }
                 else if (j == OP_ARRAY_REF_ASSIGN_SETUP) {
                     printd(" binOp=%s nDim=%d",
diff --quilt old/source/interpret.h new/source/interpret.h
--- old/source/interpret.h
+++ new/source/interpret.h
@@ -53,10 +53,11 @@ enum operations {OP_RETURN_NO_VAL, OP_RE
     OP_ANONARRAY_INDEX_VAL, OP_ANONARRAY_CLOSE,
     OP_NAMED_ARG1, OP_NAMED_ARGN, OP_SWAP_TOP2,
     OP_SUBR_CALL_STACKED_N,
     OP_UNPACKTOARGS,
     OP_TYPEOF_IN, OP_TYPEOF_OUT,
+    OP_ARRAY_INDEX,
     N_OPS};
 
 enum typeTags {NO_TAG, INT_TAG, STRING_TAG, ARRAY_TAG};
 
 enum execReturnCodes {MACRO_TIME_LIMIT, MACRO_PREEMPT, MACRO_DONE, MACRO_ERROR};
diff --quilt old/source/parse.y new/source/parse.y
--- old/source/parse.y
+++ new/source/parse.y
@@ -467,18 +467,26 @@ numexpr:      '(' blank expr blank ')'
             }
             | SYMBOL incrdecr %prec INCR {
                 ADD_OP(OP_PUSH_SYM); ADD_SYM($1); ADD_OP(OP_DUP);
                 ADD_OP($2); ADD_OP(OP_ASSIGN); ADD_SYM($1);
             }
-            | numexpr IN blank numexpr {
+            | keyinexpr IN blank numexpr {
                 ADD_OP(OP_IN_ARRAY);
             }
-            | numexpr NOT IN blank numexpr %prec IN {
+            | keyinexpr NOT IN blank numexpr %prec IN {
                 ADD_OP(OP_IN_ARRAY);
                 ADD_OP(OP_NOT);
             }
             ;
+keyinexpr: numexpr
+           | blank '[' arglist ']' blank {
+                /* build the index from arglist and push to stack */
+                ADD_OP(OP_ARRAY_INDEX);
+                ADD_IMMED($3);
+           }
+           ;
+
 while:  WHILE blank {
             $$ = GetPC(); StartLoopAddrList();
         }
         ;
 do:     DO blank {
diff --quilt old/doc/help.etx new/doc/help.etx
--- old/doc/help.etx
+++ new/doc/help.etx
@@ -2329,22 +2329,15 @@ Macro Language
   $sub_sep as the separator.
 
   You can also check for the existence of multi-dimensional array by
   looking for $sub_sep in the key.
 
-  Last, you need $sub_sep if you want to use the 'in' keyword.
+  If you want to use the 'in' keyword, use this syntax:
 
-      if ((1,2) in myArray)
+      if ([1,2] in myArray)
       {..}
 
-  doesn't work, but
-
-      if (("1" $sub_sep "2") in myArray)
-      {..}
-
-  does work.
-
   Note that if an array contains a value that is itself an array, you can
   apply the index operator more than once. For example
 
       subarray["a"] = "value"
       mainarray[1] = subarray