EXEC_ERROR.patch

   1 ---
   2
   3  source/interpret.c |  200 +++++++++++++++++++++++++++--------------------------
   4  1 file changed, 102 insertions(+), 98 deletions(-)
   5
   6 diff --quilt old/source/interpret.c new/source/interpret.c
   7 --- old/source/interpret.c
   8 +++ new/source/interpret.c
   9 @@ -1378,10 +1378,12 @@ static void addToGlobalSymTab(Symbol *sy
  10      GlobalSymTab[idx] = sym;
  11  }
  12
  13 +#define EXEC_ERROR(s1, s2) return execError(s1, s2)
  14 +
  15  #define GET_SYM(s) \
  16      do { \
  17          if (PC->type != SYM_INST) { \
  18 -            return execError("Unexpected instruction, expected <symbol>: %s", \
  19 +            EXEC_ERROR("Unexpected instruction, expected <symbol>: %s", \
  20                      instTypeToStr(PC->type)); \
  21          } \
  22          s = PC++->val.sym; \
  23 @@ -1390,7 +1392,7 @@ static void addToGlobalSymTab(Symbol *sy
  24  #define GET_IMMED(i) \
  25      do { \
  26          if (PC->type != IMMED_INST) { \
  27 -            return execError("Unexpected instruction, expected <immediate>: %s", \
  28 +            EXEC_ERROR("Unexpected instruction, expected <immediate>: %s", \
  29                      instTypeToStr(PC->type)); \
  30          } \
  31          i = PC++->val.immed; \
  32 @@ -1399,7 +1401,7 @@ static void addToGlobalSymTab(Symbol *sy
  33  #define GET_BRANCH(a) \
  34      do { \
  35          if (PC->type != BRANCH_INST) { \
  36 -            return execError("Unexpected instruction, expected <branch>: %s", \
  37 +            EXEC_ERROR("Unexpected instruction, expected <branch>: %s", \
  38                      instTypeToStr(PC->type)); \
  39          } \
  40          a = PC + PC->val.branch; \
  41 @@ -1440,7 +1442,7 @@ static void addToGlobalSymTab(Symbol *sy
  42  #define POP_CHECK(n) \
  43      do { \
  44          if (!OK_TO_POP(n)) { \
  45 -            return execError(StackUnderflowMsg, ""); \
  46 +            EXEC_ERROR(StackUnderflowMsg, ""); \
  47          } \
  48      } while (0)
  49
  50 @@ -1451,17 +1453,17 @@ static void addToGlobalSymTab(Symbol *sy
  51   #define PUSH_CHECK(n) \
  52      do { \
  53          if (!OK_TO_PUSH(n)) { \
  54 -            return execError(StackOverflowMsg, ""); \
  55 +            EXEC_ERROR(StackOverflowMsg, ""); \
  56          } \
  57      } while (0)
  58
  59  #define PEEK_CHECK(n) \
  60      do { \
  61          if (!OK_TO_POP((n) + 1)) { \
  62 -            return execError(StackUnderflowMsg, ""); \
  63 +            EXEC_ERROR(StackUnderflowMsg, ""); \
  64          } \
  65          if (!OK_TO_PUSH(-(n))) { \
  66 -            return execError(StackOverflowMsg, ""); \
  67 +            EXEC_ERROR(StackOverflowMsg, ""); \
  68          } \
  69      } while (0)
  70
  71 @@ -1490,11 +1492,11 @@ static void addToGlobalSymTab(Symbol *sy
  72              __int = dataVal.val.n; \
  73          } else if (dataVal.tag == STRING_TAG) { \
  74              if (!StringToNum(dataVal.val.str.rep, &__int)) {\
  75 -                return execError(StringToNumberMsg, dataVal.val.str.rep); \
  76 +                EXEC_ERROR(StringToNumberMsg, dataVal.val.str.rep); \
  77              } \
  78          } else { \
  79 -            return(execError("incompatible type in integer context: %s", \
  80 -                    tagToStr(dataVal.tag))); \
  81 +            EXEC_ERROR("incompatible type in integer context: %s", \
  82 +                    tagToStr(dataVal.tag)); \
  83          } \
  84          number = __int; \
  85      } while (0)
  86 @@ -1507,8 +1509,8 @@ static void addToGlobalSymTab(Symbol *sy
  87          } else if (dataVal.tag == INT_TAG) { \
  88              __str = AllocStringOfNumber(dataVal.val.n); \
  89          } else { \
  90 -            return(execError("incompatible type in string context: %s", \
  91 -                    tagToStr(dataVal.tag))); \
  92 +            EXEC_ERROR("incompatible type in string context: %s", \
  93 +                    tagToStr(dataVal.tag)); \
  94          } \
  95          string = __str; \
  96      } while (0)
  97 @@ -1605,7 +1607,7 @@ OP_FUNCTION(pushSymVal)
  98         nArgs = FRAME_GET_ARG_COUNT();
  99         argNum = s->value.val.n;
 100         if (argNum >= nArgs) {
 101 -           return execError("referenced undefined argument: %s",  s->name);
 102 +            EXEC_ERROR("referenced undefined argument: %s", s->name);
 103          }
 104         if (argNum == N_ARGS_ARG_SYM) {
 105              symVal.tag = INT_TAG;
 106 @@ -1618,7 +1620,7 @@ OP_FUNCTION(pushSymVal)
 107         char *errMsg;
 108         if (!(s->value.val.subr)(FocusWindow, NULL, 0,
 109                 &symVal, &errMsg)) {
 110 -           return execError(errMsg, s->name);
 111 +            EXEC_ERROR(errMsg, s->name);
 112          }
 113      } else if (s->type == C_FUNCTION_SYM
 114              || s->type == MACRO_FUNCTION_SYM
 115 @@ -1626,9 +1628,9 @@ OP_FUNCTION(pushSymVal)
 116          symVal.tag = SUBR_TAG;
 117          symVal.val.sym = s;
 118      } else
 119 -       return execError("reading non-variable: %s", s->name);
 120 +        EXEC_ERROR("reading non-variable: %s", s->name);
 121      if (symVal.tag == NO_TAG && !inTypeOfMode) {
 122 -       return execError("variable not set: %s", s->name);
 123 +        EXEC_ERROR("variable not set: %s", s->name);
 124      }
 125
 126      PUSH(symVal);
 127 @@ -1668,8 +1670,8 @@ OP_FUNCTION(pushArgVal)
 128      --argNum;
 129      nArgs = FRAME_GET_ARG_COUNT();
 130      if (argNum >= nArgs || argNum < 0) {
 131 -        return execError("referenced undefined argument: $args[%s]",
 132 -                         longAsStr(argNum + 1));
 133 +        EXEC_ERROR("referenced undefined argument: $args[%s]",
 134 +                longAsStr(argNum + 1));
 135      }
 136      PUSH(FRAME_GET_ARG_N(argNum));
 137      return STAT_OK;
 138 @@ -1708,7 +1710,7 @@ OP_FUNCTION(pushArgArray)
 139              argVal = FRAME_GET_ARG_N(argNum);
 140              if (!ArrayInsert(argArray, AllocStringOfNumber(argNum + 1),
 141                               &argVal)) {
 142 -                return(execError("argument array insertion failure", NULL));
 143 +                EXEC_ERROR("argument array insertion failure", NULL);
 144              }
 145          }
 146      }
 147 @@ -1744,7 +1746,7 @@ OP_FUNCTION(pushArraySymVal)
 148         dataPtr = &sym->value;
 149      }
 150      else {
 151 -       return execError("assigning to non-lvalue array or non-array: %s", sym->name);
 152 +        EXEC_ERROR("assigning to non-lvalue array or non-array: %s", sym->name);
 153      }
 154
 155      if (initEmpty && dataPtr->tag == NO_TAG) {
 156 @@ -1753,7 +1755,7 @@ OP_FUNCTION(pushArraySymVal)
 157      }
 158
 159      if (dataPtr->tag == NO_TAG && !inTypeOfMode) {
 160 -        return execError("variable not set: %s", sym->name);
 161 +        EXEC_ERROR("variable not set: %s", sym->name);
 162      }
 163
 164      PUSH(*dataPtr);
 165 @@ -1846,7 +1848,7 @@ OP_FUNCTION(anonArrayNextVal)
 166
 167      sprintf(numString, "%d", nextIndex);
 168      if (!ArrayInsert(&anonArray, AllocStringCpy(numString), &exprVal)) {
 169 -        return(execError("array insertion failure", NULL));
 170 +        EXEC_ERROR("array insertion failure", NULL);
 171      }
 172
 173      /* we need to increment the index for next time */
 174 @@ -1898,7 +1900,7 @@ OP_FUNCTION(anonArrayIndexVal)
 175      }
 176
 177      if (!ArrayInsert(&anonArray, keyString, &exprVal)) {
 178 -        return(execError("array insertion failure", NULL));
 179 +        EXEC_ERROR("array insertion failure", NULL);
 180      }
 181
 182      /* push the default next index value first, then the array */
 183 @@ -1989,7 +1991,7 @@ static int namedArg1orN(Boolean isFirst)
 184      /* if our index is numeric (or can be converted to a number) we must
 185         change the next index value */
 186      if (nDim == 1 && StringToNum(keyString, &index)) {
 187 -        return execError("named argument name must not be numeric", NULL);
 188 +        EXEC_ERROR("named argument name must not be numeric", NULL);
 189      }
 190
 191      if (isFirst) {
 192 @@ -2003,7 +2005,7 @@ static int namedArg1orN(Boolean isFirst)
 193      }
 194
 195      if (!ArrayInsert(&argsArray, keyString, &exprVal)) {
 196 -        return(execError("named argument insertion failure", NULL));
 197 +        EXEC_ERROR("named argument insertion failure", NULL);
 198      }
 199
 200      /* and (re)push the array */
 201 @@ -2051,13 +2053,13 @@ OP_FUNCTION(assign)
 202
 203      if (sym->type != GLOBAL_SYM && sym->type != LOCAL_SYM) {
 204          if (sym->type == ARG_SYM) {
 205 -            return execError("assignment to function argument: %s",  sym->name);
 206 +            EXEC_ERROR("assignment to function argument: %s", sym->name);
 207          }
 208          else if (sym->type == PROC_VALUE_SYM) {
 209 -            return execError("assignment to read-only variable: %s", sym->name);
 210 +            EXEC_ERROR("assignment to read-only variable: %s", sym->name);
 211          }
 212          else {
 213 -            return execError("assignment to non-variable: %s", sym->name);
 214 +            EXEC_ERROR("assignment to non-variable: %s", sym->name);
 215          }
 216      }
 217
 218 @@ -2208,13 +2210,13 @@ OP_FUNCTION(add)
 219                      rightIter = arrayIterateNext(rightIter);
 220                  }
 221                  if (!insertResult) {
 222 -                    return(execError("array insertion failure", NULL));
 223 +                    EXEC_ERROR("array insertion failure", NULL);
 224                  }
 225              }
 226              PUSH(resultArray);
 227          }
 228          else {
 229 -            return(execError("can't mix math with arrays and non-arrays", NULL));
 230 +            EXEC_ERROR("can't mix math with arrays and non-arrays", NULL);
 231          }
 232      }
 233      else {
 234 @@ -2222,7 +2224,7 @@ OP_FUNCTION(add)
 235          POP_INT(n1);
 236          PUSH_INT(n1 + n2);
 237      }
 238 -    return(STAT_OK);
 239 +    return STAT_OK;
 240  }
 241
 242  /*
 243 @@ -2274,13 +2276,13 @@ OP_FUNCTION(subtract)
 244                      leftIter = arrayIterateNext(leftIter);
 245                  }
 246                  if (!insertResult) {
 247 -                    return(execError("array insertion failure", NULL));
 248 +                    EXEC_ERROR("array insertion failure", NULL);
 249                  }
 250              }
 251              PUSH(resultArray);
 252          }
 253          else {
 254 -            return(execError("can't mix math with arrays and non-arrays", NULL));
 255 +            EXEC_ERROR("can't mix math with arrays and non-arrays", NULL);
 256          }
 257      }
 258      else {
 259 @@ -2288,7 +2290,7 @@ OP_FUNCTION(subtract)
 260          POP_INT(n1);
 261          PUSH_INT(n1 - n2);
 262      }
 263 -    return(STAT_OK);
 264 +    return STAT_OK;
 265  }
 266
 267  /*
 268 @@ -2315,7 +2317,7 @@ OP_FUNCTION(divide)
 269      POP_INT(n2);
 270      POP_INT(n1);
 271      if (n2 == 0) {
 272 -       return execError("division by zero", "");
 273 +        EXEC_ERROR("division by zero", "");
 274      }
 275      PUSH_INT(n1 / n2);
 276      return STAT_OK;
 277 @@ -2331,7 +2333,7 @@ OP_FUNCTION(modulo)
 278      POP_INT(n2);
 279      POP_INT(n1);
 280      if (n2 == 0) {
 281 -       return execError("modulo by zero", "");
 282 +        EXEC_ERROR("modulo by zero", "");
 283      }
 284      PUSH_INT(n1 % n2);
 285      return STAT_OK;
 286 @@ -2412,11 +2414,11 @@ OP_FUNCTION(eq)
 287          }
 288      }
 289      else {
 290 -        return(execError("incompatible types to compare", NULL));
 291 +        EXEC_ERROR("incompatible types to compare", NULL);
 292      }
 293      v1.tag = INT_TAG;
 294      PUSH(v1);
 295 -    return(STAT_OK);
 296 +    return STAT_OK;
 297  }
 298
 299  /* negated eq() call */
 300 @@ -2469,13 +2471,13 @@ OP_FUNCTION(bitAnd)
 301                      rightIter = arrayIterateNext(rightIter);
 302                  }
 303                  if (!insertResult) {
 304 -                    return(execError("array insertion failure", NULL));
 305 +                    EXEC_ERROR("array insertion failure", NULL);
 306                  }
 307              }
 308              PUSH(resultArray);
 309          }
 310          else {
 311 -            return(execError("can't mix math with arrays and non-arrays", NULL));
 312 +            EXEC_ERROR("can't mix math with arrays and non-arrays", NULL);
 313          }
 314      }
 315      else {
 316 @@ -2483,7 +2485,7 @@ OP_FUNCTION(bitAnd)
 317          POP_INT(n1);
 318          PUSH_INT(n1 & n2);
 319      }
 320 -    return(STAT_OK);
 321 +    return STAT_OK;
 322  }
 323
 324  /*
 325 @@ -2540,13 +2542,13 @@ OP_FUNCTION(bitOr)
 326                      rightIter = arrayIterateNext(rightIter);
 327                  }
 328                  if (!insertResult) {
 329 -                    return(execError("array insertion failure", NULL));
 330 +                    EXEC_ERROR("array insertion failure", NULL);
 331                  }
 332              }
 333              PUSH(resultArray);
 334          }
 335          else {
 336 -            return(execError("can't mix math with arrays and non-arrays", NULL));
 337 +            EXEC_ERROR("can't mix math with arrays and non-arrays", NULL);
 338          }
 339      }
 340      else {
 341 @@ -2554,7 +2556,7 @@ OP_FUNCTION(bitOr)
 342          POP_INT(n1);
 343          PUSH_INT(n1 | n2);
 344      }
 345 -    return(STAT_OK);
 346 +    return STAT_OK;
 347  }
 348
 349  OP_FUNCTION(and)
 350 @@ -2711,7 +2713,7 @@ OP_FUNCTION(concat)
 351
 352      len = concatenateNwithSep(nExpr, "", &out, False);
 353      if (len < 0) {
 354 -        return(execError("can only concatenate with string or integer", NULL));
 355 +        EXEC_ERROR("can only concatenate with string or integer", NULL);
 356      }
 357      PUSH_STRING(out, len);
 358      return STAT_OK;
 359 @@ -2768,7 +2770,8 @@ static int callSubroutineFromSymbol(Symb
 360          if (symValPtr->tag == SUBR_TAG) {
 361              sym = symValPtr->val.sym;
 362          } else {
 363 -            return execError("%s is not a variable holding a subroutine pointer", sym->name);
 364 +            EXEC_ERROR("%s is not a variable holding a subroutine pointer",
 365 +                    sym->name);
 366          }
 367      }
 368
 369 @@ -2787,7 +2790,7 @@ static int callSubroutineFromSymbol(Symb
 370         PreemptRequest = False;
 371         if (!sym->value.val.subr(FocusWindow, StackP,
 372                 nArgs, &result, &errMsg))
 373 -           return execError(errMsg, sym->name);
 374 +            EXEC_ERROR(errMsg, sym->name);
 375          PUSH_RET_VAL(result);
 376         return PreemptRequest ? STAT_PREEMPT : STAT_OK;
 377      }
 378 @@ -2822,8 +2825,7 @@ static int callSubroutineFromSymbol(Symb
 379         Window win;
 380
 381          if (haveNamedArgs) {
 382 -            return execError(
 383 -                    "%s action routine called with named argument array",
 384 +            EXEC_ERROR("%s action routine called with named argument array",
 385                      sym->name);
 386          }
 387
 388 @@ -2859,7 +2861,7 @@ static int callSubroutineFromSymbol(Symb
 389      }
 390
 391      /* Calling a non subroutine symbol */
 392 -    return execError("%s is not a function or subroutine", sym->name);
 393 +    EXEC_ERROR("%s is not a function or subroutine", sym->name);
 394  }
 395
 396  /*
 397 @@ -2915,7 +2917,7 @@ OP_FUNCTION(callSubroutineStackedN)
 398
 399      if (nArgs >= 0) {
 400          /* should never happen */
 401 -        return execError("array argument call to %s erroneous", sym->name);
 402 +        EXEC_ERROR("array argument call to %s erroneous", sym->name);
 403      }
 404
 405      return callSubroutineFromSymbol(sym, nArgs);
 406 @@ -3024,7 +3026,7 @@ OP_FUNCTION(unpackArrayToArgs)
 407      POP(argArray);
 408
 409      if (argArray.tag != ARRAY_TAG) {
 410 -        return execError("argument array call made with non-array value", NULL);
 411 +        EXEC_ERROR("argument array call made with non-array value", NULL);
 412      }
 413
 414      if (haveNamedArgs) {
 415 @@ -3059,7 +3061,7 @@ OP_FUNCTION(unpackArrayToArgs)
 416          }
 417          else {
 418              if (!ArrayInsert(&dvArray, iter->key, &dvEntry)) {
 419 -                return(execError("array copy failed", NULL));
 420 +                EXEC_ERROR("array copy failed", NULL);
 421              }
 422          }
 423
 424 @@ -3078,7 +3080,7 @@ OP_FUNCTION(unpackArrayToArgs)
 425  */
 426  OP_FUNCTION(fetchRetVal)
 427  {
 428 -    return execError("internal error: frv", NULL);
 429 +    EXEC_ERROR("internal error: frv", NULL);
 430  }
 431
 432  /* see comments for returnValOrNone() */
 433 @@ -3218,17 +3220,17 @@ int ArrayCopy(DataValue *dstArray, DataV
 434                  return(errNum);
 435              }
 436              if (!ArrayInsert(dstArray, srcIter->key, &tmpArray)) {
 437 -                return(execError("array copy failed", NULL));
 438 +                EXEC_ERROR("array copy failed", NULL);
 439              }
 440          }
 441          else {
 442              if (!ArrayInsert(dstArray, srcIter->key, &srcIter->value)) {
 443 -                return(execError("array copy failed", NULL));
 444 +                EXEC_ERROR("array copy failed", NULL);
 445              }
 446          }
 447          srcIter = arrayIterateNext(srcIter);
 448      }
 449 -    return(STAT_OK);
 450 +    return STAT_OK;
 451  }
 452
 453  /*
 454 @@ -3245,9 +3247,9 @@ static int makeArrayKeyFromArgs(int nArg
 455
 456      len = concatenateNwithSep(nArgs, ARRAY_DIM_SEP, keyString, leaveParams);
 457      if (len < 0) {
 458 -      return(execError("can only index array with string or int.", NULL));
 459 +        EXEC_ERROR("can only index array with string or int.", NULL);
 460      }
 461 -    return(STAT_OK);
 462 +    return STAT_OK;
 463  }
 464
 465  /*
 466 @@ -3567,23 +3569,24 @@ OP_FUNCTION(arrayRef)
 467          POP(srcArray);
 468          if (srcArray.tag == ARRAY_TAG) {
 469              if (!ArrayGet(&srcArray, keyString, &valueItem)) {
 470 -                return(execError("referenced array value not in array: %s", keyString));
 471 +                EXEC_ERROR("referenced array value not in array: %s",
 472 +                        keyString);
 473              }
 474              PUSH(valueItem);
 475 -            return(STAT_OK);
 476 +            return STAT_OK;
 477          }
 478          else {
 479 -            return(execError("operator [] on non-array", NULL));
 480 +            EXEC_ERROR("operator [] on non-array", NULL);
 481          }
 482      }
 483      else {
 484          POP(srcArray);
 485          if (srcArray.tag == ARRAY_TAG) {
 486              PUSH_INT(ArraySize(&srcArray));
 487 -            return(STAT_OK);
 488 +            return STAT_OK;
 489          }
 490          else {
 491 -            return(execError("operator [] on non-array", NULL));
 492 +            EXEC_ERROR("operator [] on non-array", NULL);
 493          }
 494      }
 495  }
 496 @@ -3620,7 +3623,7 @@ OP_FUNCTION(arrayAssign)
 497          POP(dstArray);
 498
 499          if (dstArray.tag != ARRAY_TAG && dstArray.tag != NO_TAG) {
 500 -            return(execError("cannot assign array element of non-array", NULL));
 501 +            EXEC_ERROR("cannot assign array element of non-array", NULL);
 502          }
 503          if (srcValue.tag == ARRAY_TAG) {
 504              DataValue arrayCopyValue;
 505 @@ -3632,13 +3635,13 @@ OP_FUNCTION(arrayAssign)
 506              }
 507          }
 508          if (ArrayInsert(&dstArray, keyString, &srcValue)) {
 509 -            return(STAT_OK);
 510 +            return STAT_OK;
 511          }
 512          else {
 513 -            return(execError("array member allocation failure", NULL));
 514 +            EXEC_ERROR("array member allocation failure", NULL);
 515          }
 516      }
 517 -    return(execError("empty operator []", NULL));
 518 +    EXEC_ERROR("empty operator []", NULL);
 519  }
 520
 521  /*
 522 @@ -3676,20 +3679,21 @@ OP_FUNCTION(arrayRefAndAssignSetup)
 523          PEEK(srcArray, nDim);
 524          if (srcArray.tag == ARRAY_TAG) {
 525              if (!ArrayGet(&srcArray, keyString, &valueItem)) {
 526 -                return(execError("referenced array value not in array: %s", keyString));
 527 +                EXEC_ERROR("referenced array value not in array: %s",
 528 +                        keyString);
 529              }
 530              PUSH(valueItem);
 531              if (binaryOp) {
 532                  PUSH(moveExpr);
 533              }
 534 -            return(STAT_OK);
 535 +            return STAT_OK;
 536          }
 537          else {
 538 -            return(execError("operator [] on non-array", NULL));
 539 +            EXEC_ERROR("operator [] on non-array", NULL);
 540          }
 541      }
 542      else {
 543 -        return(execError("array[] not an lvalue", NULL));
 544 +        EXEC_ERROR("array[] not an lvalue", NULL);
 545      }
 546  }
 547
 548 @@ -3722,16 +3726,16 @@ OP_FUNCTION(beginArrayIter)
 549          iteratorValPtr = &FRAME_GET_SYM_VAL(iterator);
 550      }
 551      else {
 552 -        return(execError("bad temporary iterator: %s",  iterator->name));
 553 +        EXEC_ERROR("bad temporary iterator: %s", iterator->name);
 554      }
 555
 556      iteratorValPtr->tag = INT_TAG;
 557      if (arrayVal.tag != ARRAY_TAG) {
 558 -        return(execError("can't iterate non-array", NULL));
 559 +        EXEC_ERROR("can't iterate non-array", NULL);
 560      }
 561
 562      iteratorValPtr->val.arrayPtr = arrayIterateFirst(&arrayVal);
 563 -    return(STAT_OK);
 564 +    return STAT_OK;
 565  }
 566
 567  /*
 568 @@ -3788,7 +3792,7 @@ OP_FUNCTION(arrayIter)
 569          keyValPtr = &(keySym->value);
 570      }
 571      else {
 572 -        return(execError("can't assign to: %s",  keySym->name));
 573 +        EXEC_ERROR("can't assign to: %s", keySym->name);
 574      }
 575      keyValPtr->tag = NO_TAG;
 576
 577 @@ -3800,7 +3804,7 @@ OP_FUNCTION(arrayIter)
 578              valPtr = &(valSym->value);
 579          }
 580          else {
 581 -            return(execError("can't assign to: %s",  valSym->name));
 582 +            EXEC_ERROR("can't assign to: %s", valSym->name);
 583          }
 584          valPtr->tag = NO_TAG;
 585      }
 586 @@ -3809,7 +3813,7 @@ OP_FUNCTION(arrayIter)
 587          iteratorValPtr = &FRAME_GET_SYM_VAL(iterator);
 588      }
 589      else {
 590 -        return(execError("bad temporary iterator: %s",  iterator->name));
 591 +        EXEC_ERROR("bad temporary iterator: %s", iterator->name);
 592      }
 593
 594      thisEntry = iteratorValPtr->val.arrayPtr;
 595 @@ -3830,7 +3834,7 @@ OP_FUNCTION(arrayIter)
 596      else {
 597          JUMP(branchAddr);
 598      }
 599 -    return(STAT_OK);
 600 +    return STAT_OK;
 601  }
 602
 603  /*
 604 @@ -3858,21 +3862,21 @@ OP_FUNCTION(beginArrayMultiIterArray)
 605          iteratorValPtr = &FRAME_GET_SYM_VAL(iterator);
 606      }
 607      else {
 608 -        return(execError("bad temporary iterator: %s",  iterator->name));
 609 +        EXEC_ERROR("bad temporary iterator: %s", iterator->name);
 610      }
 611
 612      if (nDims < 0) {
 613 -        return(execError("bad multi dimension", NULL));
 614 +        EXEC_ERROR("bad multi dimension", NULL);
 615      }
 616
 617      iteratorValPtr->tag = INT_TAG;
 618      if (arrayVal.tag != ARRAY_TAG) {
 619 -        return(execError("can't iterate non-array", NULL));
 620 +        EXEC_ERROR("can't iterate non-array", NULL);
 621      }
 622
 623      iteratorValPtr->val.arrayPtr = arrayIterateFirst(&arrayVal);
 624
 625 -    return(STAT_OK);
 626 +    return STAT_OK;
 627  }
 628
 629  static int countDim(const char *key)
 630 @@ -3968,7 +3972,7 @@ OP_FUNCTION(arrayMultiIterArray)
 631          keyArrayPtr = &(keyArraySym->value);
 632      }
 633      else {
 634 -        return(execError("can't assign to: %s",  keyArraySym->name));
 635 +        EXEC_ERROR("can't assign to: %s", keyArraySym->name);
 636      }
 637      keyArrayPtr->tag = ARRAY_TAG;
 638      keyArrayPtr->val.arrayPtr = NULL;
 639 @@ -3981,7 +3985,7 @@ OP_FUNCTION(arrayMultiIterArray)
 640              valPtr = &valSym->value;
 641          }
 642          else {
 643 -            return(execError("can't assign to: %s",  valSym->name));
 644 +            EXEC_ERROR("can't assign to: %s", valSym->name);
 645          }
 646          valPtr->tag = NO_TAG;
 647      }
 648 @@ -3990,7 +3994,7 @@ OP_FUNCTION(arrayMultiIterArray)
 649          iteratorValPtr = &FRAME_GET_SYM_VAL(iterator);
 650      }
 651      else {
 652 -        return(execError("bad temporary iterator: %s",  iterator->name));
 653 +        EXEC_ERROR("bad temporary iterator: %s", iterator->name);
 654      }
 655
 656      thisEntry = iteratorValPtr->val.arrayPtr;
 657 @@ -4011,7 +4015,7 @@ OP_FUNCTION(arrayMultiIterArray)
 658
 659          /* set keys */
 660          if (!splitKeyIntoArray(thisEntry->key, keyArrayPtr)) {
 661 -            return(execError("can't split key: %s",  thisEntry->key));
 662 +            EXEC_ERROR("can't split key: %s", thisEntry->key);
 663          }
 664
 665          if (withVal) {
 666 @@ -4055,7 +4059,7 @@ OP_FUNCTION(inArray)
 667
 668      POP(theArray);
 669      if (theArray.tag != ARRAY_TAG) {
 670 -        return(execError("operator in on non-array", NULL));
 671 +        EXEC_ERROR("operator in on non-array", NULL);
 672      }
 673      PEEK(leftArray, 0);
 674      if (leftArray.tag == ARRAY_TAG) {
 675 @@ -4076,7 +4080,7 @@ OP_FUNCTION(inArray)
 676          }
 677      }
 678      PUSH_INT(inResult);
 679 -    return(STAT_OK);
 680 +    return STAT_OK;
 681  }
 682
 683  /*
 684 @@ -4119,15 +4123,15 @@ OP_FUNCTION(deleteArrayElement)
 685          }
 686      }
 687      else {
 688 -        return(execError("attempt to delete from non-array", NULL));
 689 +        EXEC_ERROR("attempt to delete from non-array", NULL);
 690      }
 691 -    return(STAT_OK);
 692 +    return STAT_OK;
 693  }
 694
 695  OP_FUNCTION(typeOfIn)
 696  {
 697      if (inTypeOfMode) {
 698 -        return(execError("I'm already in typeof-mode", NULL));
 699 +        EXEC_ERROR("I'm already in typeof-mode", NULL);
 700      }
 701
 702      inTypeOfMode = 1;
 703 @@ -4141,7 +4145,7 @@ OP_FUNCTION(typeOfOut)
 704      DataValue retVal;
 705
 706      if (!inTypeOfMode) {
 707 -        return(execError("I'm not in typeof-mode", NULL));
 708 +        EXEC_ERROR("I'm not in typeof-mode", NULL);
 709      }
 710
 711      inTypeOfMode = 0;
 712 @@ -4195,7 +4199,7 @@ OP_FUNCTION(arrayAssignNext)
 713      POP(dstArray);
 714
 715      if (dstArray.tag != ARRAY_TAG && dstArray.tag != NO_TAG) {
 716 -        return execError("cannot assign array element of non-array", NULL);
 717 +        EXEC_ERROR("cannot assign array element of non-array", NULL);
 718      }
 719
 720      if (srcValue.tag == ARRAY_TAG) {
 721 @@ -4211,7 +4215,7 @@ OP_FUNCTION(arrayAssignNext)
 722      keyString = AllocStringOfNumber(arrayMaxNumIdx(&dstArray) + 1);
 723
 724      if (!ArrayInsert(&dstArray, keyString, &srcValue)) {
 725 -        return execError("array member allocation failure", NULL);
 726 +        EXEC_ERROR("array member allocation failure", NULL);
 727      }
 728
 729      return STAT_OK;
 730 @@ -4235,7 +4239,7 @@ OP_FUNCTION(arrayNextNumIdx)
 731
 732      POP(srcArray);
 733      if (srcArray.tag != ARRAY_TAG) {
 734 -        return execError("operator [@] on non-array", NULL);
 735 +        EXEC_ERROR("operator [@] on non-array", NULL);
 736      }
 737
 738      PUSH_INT(arrayMaxNumIdx(&srcArray) + 1);
 739 @@ -4250,9 +4254,9 @@ OP_FUNCTION(arrayNextNumIdx)
 740  static int errCheck(const char *s)
 741  {
 742      if (errno == EDOM)
 743 -       return execError("%s argument out of domain", s);
 744 +        EXEC_ERROR("%s argument out of domain", s);
 745      else if (errno == ERANGE)
 746 -       return execError("%s result out of range", s);
 747 +        EXEC_ERROR("%s result out of range", s);
 748      else
 749          return STAT_OK;
 750  }