array-next-num-index.patch

   1 Subject: Helper syntax for arrays with numerical indexes
   2
   3 Working with arrays which have only numerical indexes is a little
   4 cumbersome.  Especially to append/push an element to the end of the array.
   5
   6   arr[@]
   7
   8 gives an index which is one greater than all used numerical indexes in the
   9 array arr.  If none numerical index is used, 0 is returned.
  10
  11   arr[@] = expr
  12
  13 assigns expr to the array at position arr[@].
  14
  15 ---
  16
  17  source/interpret.c |   91 +++++++++++++++++++++++++++++++++++++++++++++++++++++
  18  source/ops.h       |    2 +
  19  source/parse.y     |    6 +++
  20  3 files changed, 99 insertions(+)
  21
  22 diff --quilt old/source/interpret.c new/source/interpret.c
  23 --- old/source/interpret.c
  24 +++ new/source/interpret.c
  25 @@ -3230,6 +3230,27 @@ SparseArrayEntry *arrayIterateNext(Spars
  26      return(nextPos);
  27  }
  28
  29 +static int arrayMaxNumIdx(DataValue *theArray)
  30 +{
  31 +    int maxKey = -1;
  32 +    SparseArrayEntry *iter;
  33 +
  34 +    iter = arrayIterateFirst(theArray);
  35 +    while (iter) {
  36 +        int thisKey;
  37 +
  38 +        if (StringToNum(iter->key, &thisKey)) {
  39 +            /* the rbTree is sorted, but "10" < "2" */
  40 +            if (thisKey > maxKey)
  41 +                maxKey = thisKey;
  42 +        }
  43 +
  44 +        iter = arrayIterateNext(iter);
  45 +    }
  46 +
  47 +    return maxKey;
  48 +}
  49 +
  50  /*
  51  ** evaluate an array element and push the result onto the stack
  52  **
  53 @@ -3883,6 +3904,76 @@ static int typeOfOut(void)
  54  }
  55
  56  /*
  57 +** assign to the next numerical index array element of a referenced
  58 +** array on the stack
  59 +**
  60 +** Before: Prog->  next, ...
  61 +**         TheStack-> rhs, ArraySym, next, ...
  62 +** After:  Prog->  next, ... (unchanged)
  63 +**         TheStack-> next, ...
  64 +*/
  65 +static int arrayAssignNext(void)
  66 +{
  67 +    char *keyString = NULL;
  68 +    DataValue srcValue, dstArray;
  69 +    int errNum;
  70 +
  71 +    DISASM_RT(PC-1, 1);
  72 +    STACKDUMP(2, 3);
  73 +
  74 +    POP(srcValue);
  75 +    POP(dstArray);
  76 +
  77 +    if (dstArray.tag != ARRAY_TAG && dstArray.tag != NO_TAG) {
  78 +        return execError("cannot assign array element of non-array", NULL);
  79 +    }
  80 +
  81 +    if (srcValue.tag == ARRAY_TAG) {
  82 +        DataValue arrayCopyValue;
  83 +
  84 +        errNum = ArrayCopy(&arrayCopyValue, &srcValue);
  85 +        srcValue = arrayCopyValue;
  86 +        if (errNum != STAT_OK) {
  87 +            return errNum;
  88 +        }
  89 +    }
  90 +
  91 +    keyString = AllocStringOfNumber(arrayMaxNumIdx(&dstArray) + 1);
  92 +
  93 +    if (!ArrayInsert(&dstArray, keyString, &srcValue)) {
  94 +        return execError("array member allocation failure", NULL);
  95 +    }
  96 +
  97 +    return STAT_OK;
  98 +}
  99 +
 100 +/*
 101 +** return the free numeric index that is greater than all others
 102 +**
 103 +** Before: Prog->  next, ...
 104 +**         TheStack-> ArraySym, next, ...
 105 +** After:  Prog->  next, ... (unchanged)
 106 +**         TheStack-> numIdx, next, ...
 107 +*/
 108 +static int arrayNextNumIdx(void)
 109 +{
 110 +    DataValue srcArray;
 111 +    SparseArrayEntry *iter;
 112 +
 113 +    DISASM_RT(PC-1, 1);
 114 +    STACKDUMP(1, 3);
 115 +
 116 +    POP(srcArray);
 117 +    if (srcArray.tag != ARRAY_TAG) {
 118 +        return execError("operator [@] on non-array", NULL);
 119 +    }
 120 +
 121 +    PUSH_INT(arrayMaxNumIdx(&srcArray) + 1);
 122 +
 123 +    return STAT_OK;
 124 +}
 125 +
 126 +/*
 127  ** checks errno after operations which can set it.  If an error occured,
 128  ** creates appropriate error messages and returns false
 129  */
 130 diff --quilt old/source/parse.y new/source/parse.y
 131 --- old/source/parse.y
 132 +++ new/source/parse.y
 133 @@ -397,6 +397,9 @@ simpstmt:   /* simple variable assignmen
 134                  ADD_OP($1);
 135                  ADD_OP(OP_ARRAY_ASSIGN); ADD_IMMED(1);
 136              }
 137 +            | initarraylv '[' '@' ']' '=' blank expr {
 138 +                ADD_OP(OP_ARRAY_ASSIGN_NEXT);
 139 +            }
 140              | funccall
 141              | lvlistexpr
 142              ;
 143 @@ -709,6 +712,9 @@ numexpr:      '(' blank expr blank ')'
 144              | numexpr dot field {
 145                  ADD_OP(OP_ARRAY_REF); ADD_IMMED(1);
 146              }
 147 +            | numexpr '[' '@' ']' {
 148 +                ADD_OP(OP_ARRAY_NEXT_NUM_IDX);
 149 +            }
 150              | '-' blank numexpr %prec UNARY_MINUS { ADD_OP(OP_NEGATE); }
 151              | NOT blank numexpr                   { ADD_OP(OP_NOT); }
 152              | numexpr '+' blank numexpr           { ADD_OP(OP_ADD); }
 153 diff --quilt old/source/ops.h new/source/ops.h
 154 --- old/source/ops.h
 155 +++ new/source/ops.h
 156 @@ -39,6 +39,7 @@ OP(BRANCH_FALSE,           branchFalse)
 157  OP(BRANCH_NEVER,           branchNever)    /* off */ /*  */
 158  OP(ARRAY_REF,              arrayRef)         /* N */ /* pop(kN..k1,a), push(a[k1..kN]) */
 159  OP(ARRAY_ASSIGN,           arrayAssign)      /* N */ /* pop(v,kN..k1,a), a[k1..kN]=v */
 160 +OP(ARRAY_ASSIGN_NEXT,      arrayAssignNext)          /* pop(v, a), a[a.nextidx] = v */
 161  OP(BEGIN_ARRAY_ITER,       beginArrayIter)  /* it */ /* pop(a), it=a.begin */
 162  OP(ARRAY_ITER,             arrayIter) /*w,k[,v],it,pc*/ /* it?(k.v=it.k,(w?v.v=it.v:),it++):PC=pc */
 163  OP(BEGIN_ARRAY_ITER_ARRAY, beginArrayIterArray) /*it*/ /*  */
 164 @@ -47,6 +48,7 @@ OP(IN_ARRAY,               inArray)
 165  OP(ARRAY_DELETE,           deleteArrayElement) /*N*/ /* N>0 ? (pop(kN..k1,a), del(a[k])) : (pop(a), delall(a)) */
 166  OP(PUSH_ARRAY_SYM,         pushArraySymVal)  /*s,i*/ /* if i: s.v=ary()), push(s.v) */
 167  OP(ARRAY_REF_ASSIGN_SETUP, arrayRefAndAssignSetup) /*op,N*/ /* pop(v,kN..a), a[k1..kN] op= v */
 168 +OP(ARRAY_NEXT_NUM_IDX,     arrayNextNumIdx)          /* pop(a), push(a.nextidx) */
 169  OP(PUSH_ARG,               pushArgVal)               /* pop(num), push($num) */
 170  OP(PUSH_ARG_COUNT,         pushArgCount)             /* push($n_args) */
 171  OP(PUSH_ARG_ARRAY,         pushArgArray)             /* push($args) */