diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/tclExecute.c | 961 |
1 files changed, 416 insertions, 545 deletions
diff --git a/generic/tclExecute.c b/generic/tclExecute.c index 2a340f0..86f8e54 100644 --- a/generic/tclExecute.c +++ b/generic/tclExecute.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclExecute.c,v 1.71 2002/06/18 13:22:21 msofer Exp $ + * RCS: @(#) $Id: tclExecute.c,v 1.72 2002/06/18 22:02:48 msofer Exp $ */ #include "tclInt.h" @@ -128,13 +128,62 @@ long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS] = { 0, 0, 0, 0, 0 }; #define IS_INF(v) (((v) > DBL_MAX) || ((v) < -DBL_MAX)) /* - * Macro to adjust the program counter and restart the instruction execution - * loop after each instruction is executed. + * The new macro for ending an instruction; note that a + * reasonable C-optimiser will resolve all branches + * at compile time. (result) is always a constant; the macro + * NEXT_INST_F handles constant (nCleanup), NEXT_INST_V is + * resolved at runtime for variable (nCleanup). + * + * ARGUMENTS: + * pcAdjustment: how much to increment pc + * nCleanup: how many objects to remove from the stack + * result: 0 indicates no object should be pushed on the + * stack; otherwise, push objResultPtr. If (result < 0), + * objResultPtr already has the correct reference count. */ -#define ADJUST_PC(instBytes) \ - pc += (instBytes); \ - continue +#define NEXT_INST_F(pcAdjustment, nCleanup, result) \ + if (nCleanup == 0) {\ + if (result != 0) {\ + if ((result) > 0) {\ + PUSH_OBJECT(objResultPtr);\ + } else {\ + stackPtr[++stackTop] = objResultPtr;\ + }\ + } \ + pc += (pcAdjustment);\ + goto startFirstIter;\ + } else if (result != 0) {\ + if ((result) > 0) {\ + Tcl_IncrRefCount(objResultPtr);\ + }\ + pc += (pcAdjustment);\ + switch (nCleanup) {\ + case 1: goto cleanup1_pushObjResultPtr;\ + case 2: goto cleanup2_pushObjResultPtr;\ + default: panic("ERROR: bad usage of macro NEXT_INST_F");\ + }\ + } else {\ + pc += (pcAdjustment);\ + switch (nCleanup) {\ + case 1: goto cleanup1;\ + case 2: goto cleanup2;\ + default: panic("ERROR: bad usage of macro NEXT_INST_F");\ + }\ + } + +#define NEXT_INST_V(pcAdjustment, nCleanup, result) \ + pc += (pcAdjustment);\ + if (result) {\ + if ((result) > 0) {\ + Tcl_IncrRefCount(objResultPtr);\ + }\ + cleanup = (nCleanup);\ + goto cleanupV_pushObjResultPtr;\ + } else {\ + panic("ERROR: bad usage of macro NEXT_INST_V");\ + } + /* * Macros used to cache often-referenced Tcl evaluation stack information @@ -151,6 +200,7 @@ long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS] = { 0, 0, 0, 0, 0 }; #define DECACHE_STACK_INFO() \ eePtr->stackTop = stackTop + /* * Macros used to access items on the Tcl evaluation stack. PUSH_OBJECT * increments the object's ref count since it makes the stack have another @@ -1013,6 +1063,8 @@ TclExecuteByteCode(interp, codePtr) #ifndef TCL_WIDE_INT_IS_LONG Tcl_WideInt w; #endif + int cleanup; + Tcl_Obj *objResultPtr; /* * This procedure uses a stack to hold information about catch commands. @@ -1059,11 +1111,47 @@ TclExecuteByteCode(interp, codePtr) } /* - * Loop executing instructions until a "done" instruction, a TCL_RETURN, - * or some error. + * Loop executing instructions until a "done" instruction, a + * TCL_RETURN, or some error. */ + goto startFirstIter; for (;;) { + /* + * Targets for standard instruction endings; unrolled + * for speed in the most frequent cases (instructions that + * consume up to two stack elements). + */ + + cleanupV_pushObjResultPtr: + switch (cleanup) { + default: + cleanup -= 2; + while (cleanup--) { + valuePtr = POP_OBJECT(); + TclDecrRefCount(valuePtr); + } + case 2: + cleanup2_pushObjResultPtr: + valuePtr = POP_OBJECT(); + TclDecrRefCount(valuePtr); + case 1: + cleanup1_pushObjResultPtr: + valuePtr = stackPtr[stackTop]; + TclDecrRefCount(valuePtr); + } + stackPtr[stackTop] = objResultPtr; + goto startFirstIter; + + cleanup2: + valuePtr = POP_OBJECT(); + TclDecrRefCount(valuePtr); + cleanup1: + valuePtr = POP_OBJECT(); + TclDecrRefCount(valuePtr); + + startFirstIter: + #ifdef TCL_COMPILE_DEBUG ValidatePcAndStackTop(codePtr, pc, stackTop, initStackTop); if (traceInstructions) { @@ -1102,44 +1190,35 @@ TclExecuteByteCode(interp, codePtr) goto checkForCatch; case INST_PUSH1: -#ifdef TCL_COMPILE_DEBUG - valuePtr = codePtr->objArrayPtr[TclGetUInt1AtPtr(pc+1)]; - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("%u => ", TclGetInt1AtPtr(pc+1)), valuePtr); -#else - PUSH_OBJECT(codePtr->objArrayPtr[TclGetUInt1AtPtr(pc+1)]); -#endif /* TCL_COMPILE_DEBUG */ - ADJUST_PC(2); + objResultPtr = codePtr->objArrayPtr[TclGetUInt1AtPtr(pc+1)]; + TRACE_WITH_OBJ(("%u => ", TclGetInt1AtPtr(pc+1)), objResultPtr); + NEXT_INST_F(2, 0, 1); case INST_PUSH4: - valuePtr = codePtr->objArrayPtr[TclGetUInt4AtPtr(pc+1)]; - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("%u => ", TclGetUInt4AtPtr(pc+1)), valuePtr); - ADJUST_PC(5); + objResultPtr = codePtr->objArrayPtr[TclGetUInt4AtPtr(pc+1)]; + TRACE_WITH_OBJ(("%u => ", TclGetUInt4AtPtr(pc+1)), objResultPtr); + NEXT_INST_F(5, 0, 1); case INST_POP: + TRACE_WITH_OBJ(("=> discarding "), stackPtr[stackTop]); valuePtr = POP_OBJECT(); - TRACE_WITH_OBJ(("=> discarding "), valuePtr); - TclDecrRefCount(valuePtr); /* finished with pop'ed object. */ - ADJUST_PC(1); + TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 0, 0); case INST_DUP: - valuePtr = stackPtr[stackTop]; - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("=> "), valuePtr); - ADJUST_PC(1); + objResultPtr = stackPtr[stackTop]; + TRACE_WITH_OBJ(("=> "), objResultPtr); + NEXT_INST_F(1, 0, 1); case INST_OVER: opnd = TclGetUInt4AtPtr( pc+1 ); - valuePtr = stackPtr[ stackTop - opnd ]; - PUSH_OBJECT( valuePtr ); - TRACE_WITH_OBJ(("=> "), valuePtr); - ADJUST_PC( 5 ); + objResultPtr = stackPtr[ stackTop - opnd ]; + TRACE_WITH_OBJ(("=> "), objResultPtr); + NEXT_INST_F(5, 0, 1); case INST_CONCAT1: opnd = TclGetUInt1AtPtr(pc+1); { - Tcl_Obj *concatObjPtr; int totalLen = 0; /* @@ -1160,11 +1239,11 @@ TclExecuteByteCode(interp, codePtr) * strings of the opnd stack objects. Also pop the objects. */ - TclNewObj(concatObjPtr); + TclNewObj(objResultPtr); if (totalLen > 0) { char *p = (char *) ckalloc((unsigned) (totalLen + 1)); - concatObjPtr->bytes = p; - concatObjPtr->length = totalLen; + objResultPtr->bytes = p; + objResultPtr->length = totalLen; for (i = (stackTop - (opnd-1)); i <= stackTop; i++) { valuePtr = stackPtr[i]; bytes = Tcl_GetStringFromObj(valuePtr, &length); @@ -1173,19 +1252,12 @@ TclExecuteByteCode(interp, codePtr) (size_t) length); p += length; } - TclDecrRefCount(valuePtr); } *p = '\0'; - } else { - for (i = (stackTop - (opnd-1)); i <= stackTop; i++) { - TclDecrRefCount(stackPtr[i]); - } } - stackTop -= opnd; - PUSH_OBJECT(concatObjPtr); - TRACE_WITH_OBJ(("%u => ", opnd), concatObjPtr); - ADJUST_PC(2); + TRACE_WITH_OBJ(("%u => ", opnd), objResultPtr); + NEXT_INST_V(2, opnd, 1); } case INST_INVOKE_STK4: @@ -1257,7 +1329,7 @@ TclExecuteByteCode(interp, codePtr) if (cmdPtr != NULL && cmdPtr->flags & CMD_HAS_EXEC_TRACES) { bytes = GetSrcInfoForPc(pc, codePtr, &length); } - } + } /* * A reference to part of the stack vector itself @@ -1287,16 +1359,6 @@ TclExecuteByteCode(interp, codePtr) */ Tcl_Release((ClientData) preservedStack); - - /* - * Pop the objc top stack elements and decrement their ref - * counts. - */ - - for (i = 0; i < objc; i++) { - valuePtr = POP_OBJECT(); - TclDecrRefCount(valuePtr); - } if (result == TCL_OK) { /* @@ -1306,12 +1368,11 @@ TclExecuteByteCode(interp, codePtr) TRACE_WITH_OBJ(("%u => ...after \"%.20s\", result=", objc, cmdNameBuf), Tcl_GetObjResult(interp)); - if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); - } - PUSH_OBJECT(Tcl_GetObjResult(interp)); - ADJUST_PC(pcAdjustment); + + objResultPtr = Tcl_GetObjResult(interp); + NEXT_INST_V(pcAdjustment, opnd, 1); } else { + cleanup = opnd; goto processExceptionReturn; } } @@ -1323,7 +1384,7 @@ TclExecuteByteCode(interp, codePtr) * checkForCatch! DO NOT OPTIMISE! */ - objPtr = POP_OBJECT(); + objPtr = stackPtr[stackTop]; DECACHE_STACK_INFO(); result = TclCompEvalObj(interp, objPtr); CACHE_STACK_INFO(); @@ -1331,17 +1392,18 @@ TclExecuteByteCode(interp, codePtr) /* * Normal return; push the eval's object result. */ - PUSH_OBJECT(Tcl_GetObjResult(interp)); + + objResultPtr = Tcl_GetObjResult(interp); TRACE_WITH_OBJ(("\"%.30s\" => ", O2S(objPtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(objPtr); - ADJUST_PC(1); + NEXT_INST_F(1, 1, 1); } else { + cleanup = 1; goto processExceptionReturn; } case INST_EXPR_STK: - objPtr = POP_OBJECT(); + objPtr = stackPtr[stackTop]; Tcl_ResetResult(interp); DECACHE_STACK_INFO(); result = Tcl_ExprObj(interp, objPtr, &valuePtr); @@ -1349,82 +1411,74 @@ TclExecuteByteCode(interp, codePtr) if (result != TCL_OK) { TRACE_WITH_OBJ(("\"%.30s\" => ERROR: ", O2S(objPtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(objPtr); goto checkForCatch; } - stackPtr[++stackTop] = valuePtr; /* already has right refct */ + objResultPtr = valuePtr; TRACE_WITH_OBJ(("\"%.30s\" => ", O2S(objPtr)), valuePtr); - TclDecrRefCount(objPtr); - ADJUST_PC(1); + NEXT_INST_F(1, 1, -1); /* already has right refct */ case INST_LOAD_SCALAR1: opnd = TclGetUInt1AtPtr(pc+1); DECACHE_STACK_INFO(); - valuePtr = TclGetIndexedScalar(interp, opnd, TCL_LEAVE_ERR_MSG); + objResultPtr = TclGetIndexedScalar(interp, opnd, TCL_LEAVE_ERR_MSG); CACHE_STACK_INFO(); - if (valuePtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u => ERROR: ", opnd), Tcl_GetObjResult(interp)); result = TCL_ERROR; goto checkForCatch; } - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("%u => ", opnd), valuePtr); - ADJUST_PC(2); + TRACE_WITH_OBJ(("%u => ", opnd), objResultPtr); + NEXT_INST_F(2, 0, 1); case INST_LOAD_SCALAR4: opnd = TclGetUInt4AtPtr(pc+1); DECACHE_STACK_INFO(); - valuePtr = TclGetIndexedScalar(interp, opnd, TCL_LEAVE_ERR_MSG); + objResultPtr = TclGetIndexedScalar(interp, opnd, TCL_LEAVE_ERR_MSG); CACHE_STACK_INFO(); - if (valuePtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u => ERROR: ", opnd), Tcl_GetObjResult(interp)); result = TCL_ERROR; goto checkForCatch; } - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("%u => ", opnd), valuePtr); - ADJUST_PC(5); + TRACE_WITH_OBJ(("%u => ", opnd), objResultPtr); + NEXT_INST_F(5, 0, 1); case INST_LOAD_ARRAY_STK: - elemPtr = POP_OBJECT(); + elemPtr = stackPtr[stackTop]; /* element name */ + objPtr = stackPtr[stackTop-1]; /* array name */ goto doLoadStk; case INST_LOAD_STK: case INST_LOAD_SCALAR_STK: elemPtr = NULL; + objPtr = stackPtr[stackTop]; /* variable name */ doLoadStk: - objPtr = POP_OBJECT(); /* scalar / variable name */ DECACHE_STACK_INFO(); - valuePtr = Tcl_ObjGetVar2(interp, objPtr, elemPtr, TCL_LEAVE_ERR_MSG); + objResultPtr = Tcl_ObjGetVar2(interp, objPtr, elemPtr, TCL_LEAVE_ERR_MSG); CACHE_STACK_INFO(); - if (valuePtr == NULL) { + if (objResultPtr == NULL) { if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" => ERROR: ", O2S(objPtr), O2S(elemPtr)), - Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); - + Tcl_GetObjResult(interp)); } else { TRACE_WITH_OBJ(("\"%.30s\" => ERROR: ", O2S(objPtr)), Tcl_GetObjResult(interp)); } - TclDecrRefCount(objPtr); result = TCL_ERROR; goto checkForCatch; } - PUSH_OBJECT(valuePtr); if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" => ", - O2S(objPtr), O2S(elemPtr)), valuePtr); - TclDecrRefCount(elemPtr); + O2S(objPtr), O2S(elemPtr)), objResultPtr); + NEXT_INST_F(1, 2, 1); } else { - TRACE_WITH_OBJ(("\"%.30s\" => ", O2S(objPtr)), valuePtr); + TRACE_WITH_OBJ(("\"%.30s\" => ", O2S(objPtr)), objResultPtr); + NEXT_INST_F(1, 1, 1); } - TclDecrRefCount(objPtr); - ADJUST_PC(1); case INST_LOAD_ARRAY4: opnd = TclGetUInt4AtPtr(pc+1); @@ -1436,24 +1490,21 @@ TclExecuteByteCode(interp, codePtr) pcAdjustment = 2; doLoadArray: - elemPtr = POP_OBJECT(); + elemPtr = stackPtr[stackTop]; DECACHE_STACK_INFO(); - valuePtr = TclGetElementOfIndexedArray(interp, opnd, + objResultPtr = TclGetElementOfIndexedArray(interp, opnd, elemPtr, TCL_LEAVE_ERR_MSG); CACHE_STACK_INFO(); - if (valuePtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u \"%.30s\" => ERROR: ", opnd, O2S(elemPtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); result = TCL_ERROR; goto checkForCatch; } - PUSH_OBJECT(valuePtr); TRACE_WITH_OBJ(("%u \"%.30s\" => ", - opnd, O2S(elemPtr)),valuePtr); - TclDecrRefCount(elemPtr); - ADJUST_PC(pcAdjustment); + opnd, O2S(elemPtr)), objResultPtr); + NEXT_INST_F(pcAdjustment, 1, 1); case INST_LAPPEND_SCALAR4: opnd = TclGetUInt4AtPtr(pc+1); @@ -1491,101 +1542,93 @@ TclExecuteByteCode(interp, codePtr) storeFlags = TCL_LEAVE_ERR_MSG; doStoreScalar: - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; DECACHE_STACK_INFO(); - value2Ptr = TclSetIndexedScalar(interp, opnd, valuePtr, + objResultPtr = TclSetIndexedScalar(interp, opnd, valuePtr, storeFlags); CACHE_STACK_INFO(); - if (value2Ptr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u <- \"%.30s\" => ERROR: ", opnd, O2S(valuePtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(valuePtr); result = TCL_ERROR; goto checkForCatch; } TRACE_WITH_OBJ(("%u <- \"%.30s\" => ", - opnd, O2S(valuePtr)), value2Ptr); - TclDecrRefCount(valuePtr); + opnd, O2S(valuePtr)), objResultPtr); + if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); + NEXT_INST_F((pcAdjustment+1), 1, 0); } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(pcAdjustment); + NEXT_INST_F(pcAdjustment, 1, 1); case INST_LAPPEND_STK: - valuePtr = POP_OBJECT(); /* value to append */ + valuePtr = stackPtr[stackTop]; /* value to append */ elemPtr = NULL; storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_TRACE_READS); goto doStoreStk; case INST_LAPPEND_ARRAY_STK: - valuePtr = POP_OBJECT(); /* value to append */ - elemPtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; /* value to append */ + elemPtr = stackPtr[stackTop - 1]; storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_TRACE_READS); goto doStoreStk; case INST_APPEND_STK: - valuePtr = POP_OBJECT(); /* value to append */ + valuePtr = stackPtr[stackTop]; /* value to append */ elemPtr = NULL; storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE); goto doStoreStk; case INST_APPEND_ARRAY_STK: - valuePtr = POP_OBJECT(); /* value to append */ - elemPtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; /* value to append */ + elemPtr = stackPtr[stackTop - 1]; storeFlags = (TCL_LEAVE_ERR_MSG | TCL_APPEND_VALUE); goto doStoreStk; case INST_STORE_ARRAY_STK: - valuePtr = POP_OBJECT(); - elemPtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; + elemPtr = stackPtr[stackTop - 1]; storeFlags = TCL_LEAVE_ERR_MSG; goto doStoreStk; case INST_STORE_STK: case INST_STORE_SCALAR_STK: - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; elemPtr = NULL; storeFlags = TCL_LEAVE_ERR_MSG; doStoreStk: - objPtr = POP_OBJECT(); /* scalar or array variable name */ + objPtr = stackPtr[stackTop - 1 - (elemPtr != NULL)]; /* variable name */ DECACHE_STACK_INFO(); - value2Ptr = Tcl_ObjSetVar2(interp, objPtr, elemPtr, valuePtr, + objResultPtr = Tcl_ObjSetVar2(interp, objPtr, elemPtr, valuePtr, storeFlags); CACHE_STACK_INFO(); - if (value2Ptr == NULL) { + if (objResultPtr == NULL) { if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" <- \"%.30s\" => ERROR: ", O2S(objPtr), O2S(elemPtr), O2S(valuePtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); } else { TRACE_WITH_OBJ(("\"%.30s\" <- \"%.30s\" => ERROR: ", O2S(objPtr), O2S(valuePtr)), Tcl_GetObjResult(interp)); } - TclDecrRefCount(objPtr); - TclDecrRefCount(valuePtr); result = TCL_ERROR; goto checkForCatch; } if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" <- \"%.30s\" => ", - O2S(objPtr), O2S(elemPtr), O2S(valuePtr)), - value2Ptr); - TclDecrRefCount(elemPtr); + O2S(objPtr), O2S(elemPtr), O2S(objResultPtr)), + objResultPtr); + NEXT_INST_V(1, 3, 1); } else { TRACE_WITH_OBJ(("\"%.30s\" <- \"%.30s\" => ", - O2S(objPtr), O2S(valuePtr)), value2Ptr); - } - TclDecrRefCount(objPtr); - TclDecrRefCount(valuePtr); - if (*(pc+1) == INST_POP) { - ADJUST_PC(2); + O2S(objPtr), O2S(valuePtr)), objResultPtr); + if (*(pc+1) == INST_POP) { + NEXT_INST_F(2, 2, 0); + } + NEXT_INST_F(1, 2, 1); } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(1); case INST_LAPPEND_ARRAY4: opnd = TclGetUInt4AtPtr(pc+1); @@ -1623,30 +1666,26 @@ TclExecuteByteCode(interp, codePtr) storeFlags = TCL_LEAVE_ERR_MSG; doStoreArray: - valuePtr = POP_OBJECT(); - elemPtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; + elemPtr = stackPtr[stackTop - 1]; DECACHE_STACK_INFO(); - value2Ptr = TclSetElementOfIndexedArray(interp, opnd, + objResultPtr = TclSetElementOfIndexedArray(interp, opnd, elemPtr, valuePtr, storeFlags); CACHE_STACK_INFO(); - if (value2Ptr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u \"%.30s\" <- \"%.30s\" => ERROR: ", opnd, O2S(elemPtr), O2S(valuePtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); - TclDecrRefCount(valuePtr); result = TCL_ERROR; goto checkForCatch; } TRACE_WITH_OBJ(("%u \"%.30s\" <- \"%.30s\" => ", - opnd, O2S(elemPtr), O2S(valuePtr)), value2Ptr); - TclDecrRefCount(elemPtr); - TclDecrRefCount(valuePtr); + opnd, O2S(elemPtr), O2S(valuePtr)), objResultPtr); + if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); + NEXT_INST_F((pcAdjustment+1), 2, 0); } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(pcAdjustment); + NEXT_INST_F(pcAdjustment, 2, 1); case INST_LIST: /* @@ -1655,18 +1694,17 @@ TclExecuteByteCode(interp, codePtr) */ opnd = TclGetUInt4AtPtr(pc+1); - valuePtr = Tcl_NewListObj(opnd, &(stackPtr[stackTop - (opnd-1)])); - for (i = 0; i < opnd; i++) { - objPtr = POP_OBJECT(); - TclDecrRefCount(objPtr); - } - PUSH_OBJECT(valuePtr); - TRACE_WITH_OBJ(("%u => ", opnd), valuePtr); - ADJUST_PC(5); + objResultPtr = Tcl_NewListObj(opnd, &(stackPtr[stackTop - (opnd-1)])); + TRACE_WITH_OBJ(("%u => ", opnd), objResultPtr); + NEXT_INST_V(5, opnd, 1); case INST_INCR_SCALAR1: + case INST_INCR_ARRAY1: + case INST_INCR_ARRAY_STK: + case INST_INCR_SCALAR_STK: + case INST_INCR_STK: opnd = TclGetUInt1AtPtr(pc+1); - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; if (valuePtr->typePtr == &tclIntType) { i = valuePtr->internalRep.longValue; #ifndef TCL_WIDE_INT_IS_LONG @@ -1678,199 +1716,128 @@ TclExecuteByteCode(interp, codePtr) if (result != TCL_OK) { TRACE_WITH_OBJ(("%u (by %s) => ERROR converting increment amount to int: ", opnd, O2S(valuePtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(valuePtr); goto checkForCatch; } FORCE_LONG(valuePtr, i, w); } + stackTop--; TclDecrRefCount(valuePtr); - pcAdjustment = 2; - goto doIncrScalarImm; + switch (*pc) { + case INST_INCR_SCALAR1: + pcAdjustment = 2; + goto doIncrScalar; + case INST_INCR_ARRAY1: + pcAdjustment = 2; + goto doIncrArray; + default: + pcAdjustment = 1; + goto doIncrStk; + } case INST_INCR_SCALAR1_IMM: opnd = TclGetUInt1AtPtr(pc+1); i = TclGetInt1AtPtr(pc+2); pcAdjustment = 3; - doIncrScalarImm: + doIncrScalar: DECACHE_STACK_INFO(); - value2Ptr = TclIncrIndexedScalar(interp, opnd, i); + objResultPtr = TclIncrIndexedScalar(interp, opnd, i); CACHE_STACK_INFO(); - if (value2Ptr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%u %ld => ERROR: ", opnd, i), Tcl_GetObjResult(interp)); result = TCL_ERROR; goto checkForCatch; } - TRACE_WITH_OBJ(("%u %ld => ", opnd, i), value2Ptr); + TRACE_WITH_OBJ(("%u %ld => ", opnd, i), objResultPtr); + if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); + NEXT_INST_F((pcAdjustment+1), 0, 0); } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(pcAdjustment); + NEXT_INST_F(pcAdjustment, 0, 1); - case INST_INCR_ARRAY_STK: - valuePtr = POP_OBJECT(); - elemPtr = POP_OBJECT(); - goto doIncrStkGetIncr; - - case INST_INCR_SCALAR_STK: - case INST_INCR_STK: - valuePtr = POP_OBJECT(); - elemPtr = NULL; + case INST_INCR_ARRAY1_IMM: + opnd = TclGetUInt1AtPtr(pc+1); + i = TclGetInt1AtPtr(pc+2); + pcAdjustment = 3; - doIncrStkGetIncr: - if (valuePtr->typePtr == &tclIntType) { - i = valuePtr->internalRep.longValue; -#ifndef TCL_WIDE_INT_IS_LONG - } else if (valuePtr->typePtr == &tclWideIntType) { - i = Tcl_WideAsLong(valuePtr->internalRep.wideValue); -#endif /* TCL_WIDE_INT_IS_LONG */ - } else { - REQUIRE_WIDE_OR_INT(result, valuePtr, i, w); - if (result != TCL_OK) { - objPtr = POP_OBJECT(); /* scalar name */ - if (elemPtr != NULL) { - TRACE_WITH_OBJ(("\"%.30s(%.30s)\" (by %s) => ERROR converting increment amount to int: ", - O2S(objPtr), O2S(elemPtr), O2S(valuePtr)), - Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); - } else { - TRACE_WITH_OBJ(("\"%.30s\" (by %s) => ERROR converting increment amount to int: ", - O2S(objPtr), O2S(valuePtr)), - Tcl_GetObjResult(interp)); - } - TclDecrRefCount(objPtr); - TclDecrRefCount(valuePtr); - goto checkForCatch; - } - FORCE_LONG(valuePtr, i, w); + doIncrArray: + elemPtr = stackPtr[stackTop]; + DECACHE_STACK_INFO(); + objResultPtr = TclIncrElementOfIndexedArray(interp, opnd, + elemPtr, i); + CACHE_STACK_INFO(); + if (objResultPtr == NULL) { + TRACE_WITH_OBJ(("%u \"%.30s\" (by %ld) => ERROR: ", + opnd, O2S(elemPtr), i), + Tcl_GetObjResult(interp)); + result = TCL_ERROR; + goto checkForCatch; } - TclDecrRefCount(valuePtr); - pcAdjustment = 1; - goto doIncrStk; + TRACE_WITH_OBJ(("%u \"%.30s\" (by %ld) => ", + opnd, O2S(elemPtr), i), objResultPtr); + if (*(pc+pcAdjustment) == INST_POP) { + NEXT_INST_F((pcAdjustment+1), 1, 0); + } + NEXT_INST_F(pcAdjustment, 1, 1); + case INST_INCR_ARRAY_STK_IMM: - elemPtr = POP_OBJECT(); - goto doIncrStkImm; - case INST_INCR_SCALAR_STK_IMM: case INST_INCR_STK_IMM: - elemPtr = NULL; - - doIncrStkImm: i = TclGetInt1AtPtr(pc+1); pcAdjustment = 2; doIncrStk: - objPtr = POP_OBJECT(); /* variable name */ + if ((*pc == INST_INCR_ARRAY_STK_IMM) + || (*pc == INST_INCR_ARRAY_STK)) { + elemPtr = stackPtr[stackTop]; + objPtr = stackPtr[stackTop - 1]; + } else { + elemPtr = NULL; + objPtr = stackPtr[stackTop]; + } DECACHE_STACK_INFO(); - value2Ptr = TclIncrVar2(interp, objPtr, elemPtr, i, + objResultPtr = TclIncrVar2(interp, objPtr, elemPtr, i, TCL_LEAVE_ERR_MSG); CACHE_STACK_INFO(); - if (value2Ptr == NULL) { + if (objResultPtr == NULL) { if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" (by %ld) => ERROR: ", O2S(objPtr), O2S(elemPtr), i), Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); } else { TRACE_WITH_OBJ(("\"%.30s\" %ld => ERROR: ", O2S(objPtr), i), Tcl_GetObjResult(interp)); } result = TCL_ERROR; - TclDecrRefCount(objPtr); goto checkForCatch; } if (elemPtr != NULL) { TRACE_WITH_OBJ(("\"%.30s(%.30s)\" (by %ld) => ", - O2S(objPtr), O2S(elemPtr), i), value2Ptr); - TclDecrRefCount(elemPtr); + O2S(objPtr), O2S(elemPtr), i), objResultPtr); + NEXT_INST_F(pcAdjustment, 2, 1); } else { TRACE_WITH_OBJ(("\"%.30s\" %ld => ", O2S(objPtr), i), - value2Ptr); - } - TclDecrRefCount(objPtr); - if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); + objResultPtr); + NEXT_INST_F(pcAdjustment, 1, 1); } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(pcAdjustment); - case INST_INCR_ARRAY1: - opnd = TclGetUInt1AtPtr(pc+1); - valuePtr = POP_OBJECT(); - if (valuePtr->typePtr == &tclIntType) { - i = valuePtr->internalRep.longValue; -#ifndef TCL_WIDE_INT_IS_LONG - } else if (valuePtr->typePtr == &tclWideIntType) { - i = Tcl_WideAsLong(valuePtr->internalRep.wideValue); -#endif /* TCL_WIDE_INT_IS_LONG */ - } else { - REQUIRE_WIDE_OR_INT(result, valuePtr, i, w); - if (result != TCL_OK) { - elemPtr = POP_OBJECT(); - TRACE_WITH_OBJ(("%u \"%.30s\" (by %s) => ERROR converting increment amount to int: ", - opnd, O2S(elemPtr), O2S(valuePtr)), - Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); - TclDecrRefCount(valuePtr); - goto checkForCatch; - } - FORCE_LONG(valuePtr, i, w); - } - TclDecrRefCount(valuePtr); - pcAdjustment = 2; - goto doIncrArrayImm; - - case INST_INCR_ARRAY1_IMM: - opnd = TclGetUInt1AtPtr(pc+1); - i = TclGetInt1AtPtr(pc+2); - pcAdjustment = 3; - - doIncrArrayImm: - elemPtr = POP_OBJECT(); - DECACHE_STACK_INFO(); - value2Ptr = TclIncrElementOfIndexedArray(interp, opnd, - elemPtr, i); - CACHE_STACK_INFO(); - if (value2Ptr == NULL) { - TRACE_WITH_OBJ(("%u \"%.30s\" (by %ld) => ERROR: ", - opnd, O2S(elemPtr), i), - Tcl_GetObjResult(interp)); - TclDecrRefCount(elemPtr); - result = TCL_ERROR; - goto checkForCatch; - } - TRACE_WITH_OBJ(("%u \"%.30s\" (by %ld) => ", - opnd, O2S(elemPtr), i), value2Ptr); - TclDecrRefCount(elemPtr); - if (*(pc+pcAdjustment) == INST_POP) { - ADJUST_PC(pcAdjustment+1); - } - PUSH_OBJECT(value2Ptr); - ADJUST_PC(pcAdjustment); - /* * END INCR INSTRUCTIONS */ case INST_JUMP1: -#ifdef TCL_COMPILE_DEBUG opnd = TclGetInt1AtPtr(pc+1); TRACE(("%d => new pc %u\n", opnd, (unsigned int)(pc + opnd - codePtr->codeStart))); - pc += opnd; -#else - pc += TclGetInt1AtPtr(pc+1); -#endif /* TCL_COMPILE_DEBUG */ - continue; + NEXT_INST_F(opnd, 0, 0); case INST_JUMP4: opnd = TclGetInt4AtPtr(pc+1); TRACE(("%d => new pc %u\n", opnd, (unsigned int)(pc + opnd - codePtr->codeStart))); - ADJUST_PC(opnd); + NEXT_INST_F(opnd, 0, 0); case INST_JUMP_FALSE4: opnd = 5; /* TRUE */ @@ -1895,7 +1862,7 @@ TclExecuteByteCode(interp, codePtr) { int b; - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; if (valuePtr->typePtr == &tclIntType) { b = (valuePtr->internalRep.longValue != 0); } else if (valuePtr->typePtr == &tclDoubleType) { @@ -1909,12 +1876,13 @@ TclExecuteByteCode(interp, codePtr) if (result != TCL_OK) { TRACE_WITH_OBJ(("%d => ERROR: ", opnd), Tcl_GetObjResult(interp)); - TclDecrRefCount(valuePtr); goto checkForCatch; } } +#ifndef TCL_COMPILE_DEBUG + NEXT_INST_F((b? opnd : pcAdjustment), 1, 0); +#else if (b) { -#ifdef TCL_COMPILE_DEBUG if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE1)) { TRACE(("%d => %.20s true, new pc %u\n", opnd, O2S(valuePtr), @@ -1922,11 +1890,8 @@ TclExecuteByteCode(interp, codePtr) } else { TRACE(("%d => %.20s true\n", pcAdjustment, O2S(valuePtr))); } -#endif - TclDecrRefCount(valuePtr); - ADJUST_PC(opnd); + NEXT_INST_F(opnd, 1, 0); } else { -#ifdef TCL_COMPILE_DEBUG if ((*pc == INST_JUMP_TRUE1) || (*pc == INST_JUMP_TRUE1)) { TRACE(("%d => %.20s false\n", opnd, O2S(valuePtr))); } else { @@ -1935,10 +1900,9 @@ TclExecuteByteCode(interp, codePtr) opnd, O2S(valuePtr), (unsigned int)(pc + opnd - codePtr->codeStart))); } -#endif - TclDecrRefCount(valuePtr); - ADJUST_PC(pcAdjustment); + NEXT_INST_F(pcAdjustment, 1, 0); } +#endif } case INST_LOR: @@ -1954,8 +1918,8 @@ TclExecuteByteCode(interp, codePtr) char *s; Tcl_ObjType *t1Ptr, *t2Ptr; - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1];; t1Ptr = valuePtr->typePtr; t2Ptr = value2Ptr->typePtr; @@ -1992,8 +1956,6 @@ TclExecuteByteCode(interp, codePtr) O2S(valuePtr), (t1Ptr? t1Ptr->name : "null"))); IllegalExprOperandType(interp, pc, valuePtr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } } @@ -2030,8 +1992,6 @@ TclExecuteByteCode(interp, codePtr) O2S(value2Ptr), (t2Ptr? t2Ptr->name : "null"))); IllegalExprOperandType(interp, pc, value2Ptr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } } @@ -2046,34 +2006,30 @@ TclExecuteByteCode(interp, codePtr) iResult = (i1 && i2); } if (Tcl_IsShared(valuePtr)) { - PUSH_OBJECT(Tcl_NewLongObj(iResult)); + objResultPtr = Tcl_NewLongObj(iResult); TRACE(("%.20s %.20s => %d\n", O2S(valuePtr), O2S(value2Ptr), iResult)); - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 2, 1); } else { /* reuse the valuePtr object */ TRACE(("%.20s %.20s => %d\n", O2S(valuePtr), O2S(value2Ptr), iResult)); Tcl_SetLongObj(valuePtr, iResult); - ++stackTop; /* valuePtr now on stk top has right r.c. */ + NEXT_INST_F(1, 1, 0); } - TclDecrRefCount(value2Ptr); } - ADJUST_PC(1); case INST_LIST_LENGTH: - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; result = Tcl_ListObjLength(interp, valuePtr, &length); if (result != TCL_OK) { TRACE_WITH_OBJ(("%.30s => ERROR: ", O2S(valuePtr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(valuePtr); goto checkForCatch; } - PUSH_OBJECT(Tcl_NewIntObj(length)); + objResultPtr = Tcl_NewIntObj(length); TRACE(("%.20s => %d\n", O2S(valuePtr), length)); - TclDecrRefCount(valuePtr); - ADJUST_PC(1); + NEXT_INST_F(1, 1, 1); case INST_LIST_INDEX: /*** lindex with objc == 3 ***/ @@ -2081,19 +2037,17 @@ TclExecuteByteCode(interp, codePtr) /* * Pop the two operands */ - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop- 1]; /* * Extract the desired list element */ - objPtr = TclLindexList(interp, valuePtr, value2Ptr); - if (objPtr == NULL) { + objResultPtr = TclLindexList(interp, valuePtr, value2Ptr); + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%.30s %.30s => ERROR: ", O2S(valuePtr), O2S(value2Ptr)), Tcl_GetObjResult(interp)); - TclDecrRefCount(value2Ptr); - TclDecrRefCount(valuePtr); result = TCL_ERROR; goto checkForCatch; } @@ -2101,13 +2055,9 @@ TclExecuteByteCode(interp, codePtr) /* * Stash the list element on the stack */ - PUSH_OBJECT(objPtr); TRACE(("%.20s %.20s => %s\n", - O2S(valuePtr), O2S(value2Ptr), O2S(objPtr))); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); - TclDecrRefCount(objPtr); - ADJUST_PC(1); + O2S(valuePtr), O2S(value2Ptr), O2S(objResultPtr))); + NEXT_INST_F(1, 2, -1); /* already has the correct refCount */ case INST_LIST_INDEX_MULTI: { @@ -2125,25 +2075,13 @@ TclExecuteByteCode(interp, codePtr) /* * Do the 'lindex' operation. */ - objPtr = TclLindexFlat(interp, stackPtr[stackTop - numIdx], + objResultPtr = TclLindexFlat(interp, stackPtr[stackTop - numIdx], numIdx, stackPtr + stackTop - numIdx + 1); - /* - * Clean up ref counts - */ - for (i=0 ; i<=numIdx ; i++) { - /* - * Watch out for multiple references in macros! - */ - - valuePtr = POP_OBJECT(); - TclDecrRefCount(valuePtr); - } - /* * Check for errors */ - if (objPtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%d => ERROR: ", opnd), Tcl_GetObjResult(interp)); result = TCL_ERROR; @@ -2153,11 +2091,9 @@ TclExecuteByteCode(interp, codePtr) /* * Set result */ - TRACE(("%d => %s\n", opnd, O2S(objPtr))); - PUSH_OBJECT(objPtr); - TclDecrRefCount(objPtr); + TRACE(("%d => %s\n", opnd, O2S(objResultPtr))); + NEXT_INST_V(5, opnd, -1); } - ADJUST_PC(5); case INST_LSET_FLAT: { @@ -2176,36 +2112,24 @@ TclExecuteByteCode(interp, codePtr) * object; the ref count will never go zero here. */ value2Ptr = POP_OBJECT(); - TclDecrRefCount(value2Ptr); + TclDecrRefCount(value2Ptr); /* This one should be done here */ /* * Get the new element value. */ - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; /* * Compute the new variable value */ - objPtr = TclLsetFlat(interp, value2Ptr, numIdx, - stackPtr + stackTop - numIdx + 1, valuePtr); - TclDecrRefCount(valuePtr); - - /* - * Clean up ref counts - */ - for (i=0 ; i<numIdx ; i++) { - /* - * Watch out for multiple references in macros! - */ + objResultPtr = TclLsetFlat(interp, value2Ptr, numIdx, + stackPtr + stackTop - numIdx, valuePtr); - valuePtr = POP_OBJECT(); - TclDecrRefCount(valuePtr); - } /* * Check for errors */ - if (objPtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("%d => ERROR: ", opnd), Tcl_GetObjResult(interp)); result = TCL_ERROR; @@ -2215,11 +2139,9 @@ TclExecuteByteCode(interp, codePtr) /* * Set result */ - TRACE(("%d => %s\n", opnd, O2S(objPtr))); - PUSH_OBJECT(objPtr); - TclDecrRefCount(objPtr); + TRACE(("%d => %s\n", opnd, O2S(objResultPtr))); + NEXT_INST_V(5, (numIdx+1), -1); } - ADJUST_PC(5); case INST_LSET_LIST: /* @@ -2229,26 +2151,24 @@ TclExecuteByteCode(interp, codePtr) * This is safe because the variable still references the * object; the ref count will never go zero here. */ - objPtr = POP_OBJECT(); - TclDecrRefCount(objPtr); + objPtr = POP_OBJECT(); + TclDecrRefCount(objPtr); /* This one should be done here */ /* * Get the new element value, and the index list */ - valuePtr = POP_OBJECT(); - value2Ptr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; + value2Ptr = stackPtr[stackTop - 1]; /* * Compute the new variable value */ - objPtr = TclLsetList(interp, objPtr, value2Ptr, valuePtr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); + objResultPtr = TclLsetList(interp, objPtr, value2Ptr, valuePtr); /* * Check for errors */ - if (objPtr == NULL) { + if (objResultPtr == NULL) { TRACE_WITH_OBJ(("\"%.30s\" => ERROR: ", O2S(value2Ptr)), Tcl_GetObjResult(interp)); result = TCL_ERROR; @@ -2258,10 +2178,8 @@ TclExecuteByteCode(interp, codePtr) /* * Set result */ - PUSH_OBJECT(objPtr); - TRACE(("=> %s\n", O2S(objPtr))); - TclDecrRefCount(objPtr); - ADJUST_PC(1); + TRACE(("=> %s\n", O2S(objResultPtr))); + NEXT_INST_F(1, 2, -1); case INST_STR_EQ: case INST_STR_NEQ: @@ -2271,8 +2189,8 @@ TclExecuteByteCode(interp, codePtr) */ int iResult; - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; if (valuePtr == value2Ptr) { /* @@ -2304,8 +2222,6 @@ TclExecuteByteCode(interp, codePtr) TRACE(("%.20s %.20s => %d\n", O2S(valuePtr), O2S(value2Ptr), iResult)); - TclDecrRefCount(value2Ptr); - TclDecrRefCount(valuePtr); /* * Peep-hole optimisation: if you're about to jump, do jump @@ -2315,16 +2231,16 @@ TclExecuteByteCode(interp, codePtr) pc++; switch (*pc) { case INST_JUMP_FALSE1: - iResult = !iResult; + NEXT_INST_F((iResult? 2 : TclGetInt1AtPtr(pc+1)), 2, 0); case INST_JUMP_TRUE1: - ADJUST_PC(iResult? TclGetInt1AtPtr(pc+1) : 2); + NEXT_INST_F((iResult? TclGetInt1AtPtr(pc+1) : 2), 2, 0); case INST_JUMP_FALSE4: - iResult = !iResult; + NEXT_INST_F((iResult? 5 : TclGetInt4AtPtr(pc+1)), 2, 0); case INST_JUMP_TRUE4: - ADJUST_PC(iResult? TclGetInt4AtPtr(pc+1) : 5); + NEXT_INST_F((iResult? TclGetInt4AtPtr(pc+1) : 5), 2, 0); } - PUSH_OBJECT(Tcl_NewIntObj(iResult)); - continue; + objResultPtr = Tcl_NewIntObj(iResult); + NEXT_INST_F(0, 2, 1); } case INST_STR_CMP: @@ -2335,8 +2251,8 @@ TclExecuteByteCode(interp, codePtr) CONST char *s1, *s2; int s1len, s2len, iResult; - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; /* * The comparison function should compare up to the @@ -2390,30 +2306,27 @@ TclExecuteByteCode(interp, codePtr) iResult = 1; } - PUSH_OBJECT(Tcl_NewIntObj(iResult)); + objResultPtr = Tcl_NewIntObj(iResult); TRACE(("%.20s %.20s => %d\n", O2S(valuePtr), O2S(value2Ptr), iResult)); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); + NEXT_INST_F(1, 2, 1); } - ADJUST_PC(1); case INST_STR_LEN: { int length1; - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; if (valuePtr->typePtr == &tclByteArrayType) { (void) Tcl_GetByteArrayFromObj(valuePtr, &length1); } else { length1 = Tcl_GetCharLength(valuePtr); } - PUSH_OBJECT(Tcl_NewIntObj(length1)); + objResultPtr = Tcl_NewIntObj(length1); TRACE(("%.20s => %d\n", O2S(valuePtr), length1)); - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 1, 1); } - ADJUST_PC(1); case INST_STR_INDEX: { @@ -2423,8 +2336,8 @@ TclExecuteByteCode(interp, codePtr) int index; bytes = NULL; /* lint */ - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; /* * If we have a ByteArray object, avoid indexing in the @@ -2445,14 +2358,12 @@ TclExecuteByteCode(interp, codePtr) result = TclGetIntForIndex(interp, value2Ptr, length - 1, &index); if (result != TCL_OK) { - TclDecrRefCount(value2Ptr); - TclDecrRefCount(valuePtr); goto checkForCatch; } if ((index >= 0) && (index < length)) { if (valuePtr->typePtr == &tclByteArrayType) { - objPtr = Tcl_NewByteArrayObj((unsigned char *) + objResultPtr = Tcl_NewByteArrayObj((unsigned char *) (&bytes[index]), 1); } else { char buf[TCL_UTF_MAX]; @@ -2466,27 +2377,24 @@ TclExecuteByteCode(interp, codePtr) * faster in practical use. */ length = Tcl_UniCharToUtf(ch, buf); - objPtr = Tcl_NewStringObj(buf, length); + objResultPtr = Tcl_NewStringObj(buf, length); } } else { - TclNewObj(objPtr); + TclNewObj(objResultPtr); } - PUSH_OBJECT(objPtr); TRACE(("%.20s %.20s => %s\n", - O2S(valuePtr), O2S(value2Ptr), O2S(objPtr))); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); + O2S(valuePtr), O2S(value2Ptr), O2S(objResultPtr))); + NEXT_INST_F(1, 2, 1); } - ADJUST_PC(1); case INST_STR_MATCH: { int nocase, match; nocase = TclGetInt1AtPtr(pc+1); - valuePtr = POP_OBJECT(); /* String */ - value2Ptr = POP_OBJECT(); /* Pattern */ + valuePtr = stackPtr[stackTop]; /* String */ + value2Ptr = stackPtr[stackTop - 1]; /* Pattern */ /* * Check that at least one of the objects @@ -2503,23 +2411,19 @@ TclExecuteByteCode(interp, codePtr) /* * Reuse value2Ptr object already on stack if possible. + * Adjustment is 2 due to the nocase byte */ TRACE(("%.20s %.20s => %d\n", O2S(valuePtr), O2S(value2Ptr), match)); - TclDecrRefCount(valuePtr); if (Tcl_IsShared(value2Ptr)) { - PUSH_OBJECT(Tcl_NewIntObj(match)); - TclDecrRefCount(value2Ptr); + objResultPtr = Tcl_NewIntObj(match); + NEXT_INST_F(2, 2, 1); } else { /* reuse the valuePtr object */ Tcl_SetIntObj(value2Ptr, match); - ++stackTop; /* valuePtr now on stk top has right r.c. */ + NEXT_INST_F(2, 1, 0); } } - /* - * Adjustment is 2 due to the nocase byte - */ - ADJUST_PC(2); case INST_EQ: case INST_NEQ: @@ -2541,8 +2445,8 @@ TclExecuteByteCode(interp, codePtr) double d2 = 0.0; /* Init. avoids compiler warning. */ long iResult = 0; /* Init. avoids compiler warning. */ - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; if (valuePtr == value2Ptr) { /* @@ -2735,8 +2639,6 @@ TclExecuteByteCode(interp, codePtr) foundResult: TRACE(("%.20s %.20s => %ld\n", O2S(valuePtr), O2S(value2Ptr), iResult)); - TclDecrRefCount(value2Ptr); - TclDecrRefCount(valuePtr); /* * Peep-hole optimisation: if you're about to jump, do jump @@ -2746,16 +2648,16 @@ TclExecuteByteCode(interp, codePtr) pc++; switch (*pc) { case INST_JUMP_FALSE1: - iResult = !iResult; + NEXT_INST_F((iResult? 2 : TclGetInt1AtPtr(pc+1)), 2, 0); case INST_JUMP_TRUE1: - ADJUST_PC(iResult? TclGetInt1AtPtr(pc+1) : 2); + NEXT_INST_F((iResult? TclGetInt1AtPtr(pc+1) : 2), 2, 0); case INST_JUMP_FALSE4: - iResult = !iResult; + NEXT_INST_F((iResult? 5 : TclGetInt4AtPtr(pc+1)), 2, 0); case INST_JUMP_TRUE4: - ADJUST_PC(iResult? TclGetInt4AtPtr(pc+1) : 5); + NEXT_INST_F((iResult? TclGetInt4AtPtr(pc+1) : 5), 2, 0); } - PUSH_OBJECT(Tcl_NewLongObj(iResult)); - continue; + objResultPtr = Tcl_NewIntObj(iResult); + NEXT_INST_F(0, 2, 1); } case INST_MOD: @@ -2776,8 +2678,8 @@ TclExecuteByteCode(interp, codePtr) int doWide = 0; #endif /* TCL_WIDE_INT_IS_LONG */ - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; if (valuePtr->typePtr == &tclIntType) { i = valuePtr->internalRep.longValue; #ifndef TCL_WIDE_INT_IS_LONG @@ -2792,8 +2694,6 @@ TclExecuteByteCode(interp, codePtr) (valuePtr->typePtr? valuePtr->typePtr->name : "null"))); IllegalExprOperandType(interp, pc, valuePtr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } } @@ -2811,8 +2711,6 @@ TclExecuteByteCode(interp, codePtr) (value2Ptr->typePtr? value2Ptr->typePtr->name : "null"))); IllegalExprOperandType(interp, pc, value2Ptr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } } @@ -2828,8 +2726,6 @@ TclExecuteByteCode(interp, codePtr) #ifdef TCL_WIDE_INT_IS_LONG if (i2 == 0) { TRACE(("%ld %ld => DIVIDE BY ZERO\n", i, i2)); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } #else /* !TCL_WIDE_INT_IS_LONG */ @@ -2839,8 +2735,6 @@ TclExecuteByteCode(interp, codePtr) } else { LLTRACE((LLD" "LLD" => DIVIDE BY ZERO\n", w, w2)); } - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } if (value2Ptr->typePtr == &tclIntType && i2 == 0) { @@ -2849,8 +2743,6 @@ TclExecuteByteCode(interp, codePtr) } else { LLTRACE((LLD" %ld => DIVIDE BY ZERO\n", w, i2)); } - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } #endif /* TCL_WIDE_INT_IS_LONG */ @@ -3011,16 +2903,16 @@ TclExecuteByteCode(interp, codePtr) if (Tcl_IsShared(valuePtr)) { #ifndef TCL_WIDE_INT_IS_LONG if (doWide) { - PUSH_OBJECT(Tcl_NewWideIntObj(wResult)); + objResultPtr = Tcl_NewWideIntObj(wResult); LLTRACE((LLD" "LLD" => "LLD"\n", w, w2, wResult)); } else { #endif /* TCL_WIDE_INT_IS_LONG */ - PUSH_OBJECT(Tcl_NewLongObj(iResult)); + objResultPtr = Tcl_NewLongObj(iResult); TRACE(("%ld %ld => %ld\n", i, i2, iResult)); #ifndef TCL_WIDE_INT_IS_LONG } #endif /* TCL_WIDE_INT_IS_LONG */ - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 2, 1); } else { /* reuse the valuePtr object */ #ifndef TCL_WIDE_INT_IS_LONG if (doWide) { @@ -3033,11 +2925,9 @@ TclExecuteByteCode(interp, codePtr) #ifndef TCL_WIDE_INT_IS_LONG } #endif /* TCL_WIDE_INT_IS_LONG */ - ++stackTop; /* valuePtr now on stk top has right r.c. */ + NEXT_INST_F(1, 1, 0); } - TclDecrRefCount(value2Ptr); } - ADJUST_PC(1); case INST_ADD: case INST_SUB: @@ -3061,8 +2951,8 @@ TclExecuteByteCode(interp, codePtr) int doWide = 0; /* 1 if doing wide arithmetic. */ #endif /* TCL_WIDE_INT_IS_LONG */ - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); + value2Ptr = stackPtr[stackTop]; + valuePtr = stackPtr[stackTop - 1]; t1Ptr = valuePtr->typePtr; t2Ptr = value2Ptr->typePtr; @@ -3095,8 +2985,6 @@ TclExecuteByteCode(interp, codePtr) (valuePtr->typePtr? valuePtr->typePtr->name : "null"))); IllegalExprOperandType(interp, pc, valuePtr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } t1Ptr = valuePtr->typePtr; @@ -3131,8 +3019,6 @@ TclExecuteByteCode(interp, codePtr) (value2Ptr->typePtr? value2Ptr->typePtr->name : "null"))); IllegalExprOperandType(interp, pc, value2Ptr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } t2Ptr = value2Ptr->typePtr; @@ -3167,8 +3053,6 @@ TclExecuteByteCode(interp, codePtr) case INST_DIV: if (d2 == 0.0) { TRACE(("%.6g %.6g => DIVIDE BY ZERO\n", d1, d2)); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } dResult = d1 / d2; @@ -3184,8 +3068,6 @@ TclExecuteByteCode(interp, codePtr) O2S(valuePtr), O2S(value2Ptr))); TclExprFloatError(interp, dResult); result = TCL_ERROR; - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto checkForCatch; } #ifndef TCL_WIDE_INT_IS_LONG @@ -3219,8 +3101,6 @@ TclExecuteByteCode(interp, codePtr) */ if (w2 == W0) { LLTRACE((LLD" "LLD" => DIVIDE BY ZERO\n", w, w2)); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } if (w2 < 0) { @@ -3259,8 +3139,6 @@ TclExecuteByteCode(interp, codePtr) */ if (i2 == 0) { TRACE(("%ld %ld => DIVIDE BY ZERO\n", i, i2)); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); goto divideByZero; } if (i2 < 0) { @@ -3283,18 +3161,18 @@ TclExecuteByteCode(interp, codePtr) if (Tcl_IsShared(valuePtr)) { if (doDouble) { - PUSH_OBJECT(Tcl_NewDoubleObj(dResult)); + objResultPtr = Tcl_NewDoubleObj(dResult); TRACE(("%.6g %.6g => %.6g\n", d1, d2, dResult)); #ifndef TCL_WIDE_INT_IS_LONG } else if (doWide) { - PUSH_OBJECT(Tcl_NewWideIntObj(wResult)); + objResultPtr = Tcl_NewWideIntObj(wResult); LLTRACE((LLD" "LLD" => "LLD"\n", w, w2, wResult)); #endif /* TCL_WIDE_INT_IS_LONG */ } else { - PUSH_OBJECT(Tcl_NewLongObj(iResult)); + objResultPtr = Tcl_NewLongObj(iResult); TRACE(("%ld %ld => %ld\n", i, i2, iResult)); } - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 2, 1); } else { /* reuse the valuePtr object */ if (doDouble) { /* NB: stack top is off by 1 */ TRACE(("%.6g %.6g => %.6g\n", d1, d2, dResult)); @@ -3308,11 +3186,9 @@ TclExecuteByteCode(interp, codePtr) TRACE(("%ld %ld => %ld\n", i, i2, iResult)); Tcl_SetLongObj(valuePtr, iResult); } - ++stackTop; /* valuePtr now on stk top has right r.c. */ + NEXT_INST_F(1, 1, 0); } - TclDecrRefCount(value2Ptr); } - ADJUST_PC(1); case INST_UPLUS: { @@ -3355,26 +3231,24 @@ TclExecuteByteCode(interp, codePtr) if (Tcl_IsShared(valuePtr)) { if (tPtr == &tclIntType) { i = valuePtr->internalRep.longValue; - objPtr = Tcl_NewLongObj(i); + objResultPtr = Tcl_NewLongObj(i); #ifndef TCL_WIDE_INT_IS_LONG } else if (tPtr == &tclWideIntType) { w = valuePtr->internalRep.wideValue; - objPtr = Tcl_NewWideIntObj(w); + objResultPtr = Tcl_NewWideIntObj(w); #endif /* TCL_WIDE_INT_IS_LONG */ } else { d = valuePtr->internalRep.doubleValue; - objPtr = Tcl_NewDoubleObj(d); + objResultPtr = Tcl_NewDoubleObj(d); } - Tcl_IncrRefCount(objPtr); - TclDecrRefCount(valuePtr); - valuePtr = objPtr; - stackPtr[stackTop] = valuePtr; + TRACE_WITH_OBJ(("%s => ", O2S(objResultPtr)), objResultPtr); + NEXT_INST_F(1, 1, 1); } else { Tcl_InvalidateStringRep(valuePtr); + TRACE_WITH_OBJ(("%s => ", O2S(valuePtr)), valuePtr); + NEXT_INST_F(1, 0, 0); } - TRACE_WITH_OBJ(("%s => ", O2S(valuePtr)), valuePtr); } - ADJUST_PC(1); case INST_UMINUS: case INST_LNOT: @@ -3392,7 +3266,7 @@ TclExecuteByteCode(interp, codePtr) int boolvar; Tcl_ObjType *tPtr; - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; tPtr = valuePtr->typePtr; if (!IS_INTEGER_TYPE(tPtr) && ((tPtr != &tclDoubleType) || (valuePtr->bytes != NULL))) { @@ -3416,7 +3290,6 @@ TclExecuteByteCode(interp, codePtr) TRACE(("\"%.20s\" => ILLEGAL TYPE %s\n", s, (tPtr? tPtr->name : "null"))); IllegalExprOperandType(interp, pc, valuePtr); - TclDecrRefCount(valuePtr); goto checkForCatch; } } @@ -3429,34 +3302,33 @@ TclExecuteByteCode(interp, codePtr) */ if ((tPtr == &tclIntType) || (tPtr == &tclBooleanType)) { i = valuePtr->internalRep.longValue; - objPtr = Tcl_NewLongObj( + objResultPtr = Tcl_NewLongObj( (*pc == INST_UMINUS)? -i : !i); - TRACE_WITH_OBJ(("%ld => ", i), objPtr); + TRACE_WITH_OBJ(("%ld => ", i), objResultPtr); #ifndef TCL_WIDE_INT_IS_LONG } else if (tPtr == &tclWideIntType) { w = valuePtr->internalRep.wideValue; if (*pc == INST_UMINUS) { - objPtr = Tcl_NewWideIntObj(-w); + objResultPtr = Tcl_NewWideIntObj(-w); } else { - objPtr = Tcl_NewLongObj(w == W0); + objResultPtr = Tcl_NewLongObj(w == W0); } - LLTRACE_WITH_OBJ((LLD" => ", w), objPtr); + LLTRACE_WITH_OBJ((LLD" => ", w), objResultPtr); #endif /* TCL_WIDE_INT_IS_LONG */ } else { d = valuePtr->internalRep.doubleValue; if (*pc == INST_UMINUS) { - objPtr = Tcl_NewDoubleObj(-d); + objResultPtr = Tcl_NewDoubleObj(-d); } else { /* * Should be able to use "!d", but apparently * some compilers can't handle it. */ - objPtr = Tcl_NewLongObj((d==0.0)? 1 : 0); + objResultPtr = Tcl_NewLongObj((d==0.0)? 1 : 0); } - TRACE_WITH_OBJ(("%.6g => ", d), objPtr); + TRACE_WITH_OBJ(("%.6g => ", d), objResultPtr); } - PUSH_OBJECT(objPtr); - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 1, 1); } else { /* * valuePtr is unshared. Modify it directly. @@ -3489,10 +3361,9 @@ TclExecuteByteCode(interp, codePtr) } TRACE_WITH_OBJ(("%.6g => ", d), valuePtr); } - ++stackTop; /* valuePtr now on stk top has right r.c. */ + NEXT_INST_F(1, 0, 0); } } - ADJUST_PC(1); case INST_BITNOT: { @@ -3505,7 +3376,7 @@ TclExecuteByteCode(interp, codePtr) Tcl_ObjType *tPtr; - valuePtr = POP_OBJECT(); + valuePtr = stackPtr[stackTop]; tPtr = valuePtr->typePtr; if (!IS_INTEGER_TYPE(tPtr)) { REQUIRE_WIDE_OR_INT(result, valuePtr, i, w); @@ -3513,7 +3384,6 @@ TclExecuteByteCode(interp, codePtr) TRACE(("\"%.20s\" => ILLEGAL TYPE %s\n", O2S(valuePtr), (tPtr? tPtr->name : "null"))); IllegalExprOperandType(interp, pc, valuePtr); - TclDecrRefCount(valuePtr); goto checkForCatch; } } @@ -3522,37 +3392,36 @@ TclExecuteByteCode(interp, codePtr) if (valuePtr->typePtr == &tclWideIntType) { w = valuePtr->internalRep.wideValue; if (Tcl_IsShared(valuePtr)) { - PUSH_OBJECT(Tcl_NewWideIntObj(~w)); + objResultPtr = Tcl_NewWideIntObj(~w); LLTRACE(("0x%llx => (%llu)\n", w, ~w)); - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 1, 1); } else { /* * valuePtr is unshared. Modify it directly. */ Tcl_SetWideIntObj(valuePtr, ~w); - ++stackTop; /*valuePtr now on stk top has right r.c.*/ LLTRACE(("0x%llx => (%llu)\n", w, ~w)); + NEXT_INST_F(1, 0, 0); } } else { #endif /* TCL_WIDE_INT_IS_LONG */ i = valuePtr->internalRep.longValue; if (Tcl_IsShared(valuePtr)) { - PUSH_OBJECT(Tcl_NewLongObj(~i)); + objResultPtr = Tcl_NewLongObj(~i); TRACE(("0x%lx => (%lu)\n", i, ~i)); - TclDecrRefCount(valuePtr); + NEXT_INST_F(1, 1, 1); } else { /* * valuePtr is unshared. Modify it directly. */ Tcl_SetLongObj(valuePtr, ~i); - ++stackTop; /*valuePtr now on stk top has right r.c.*/ TRACE(("0x%lx => (%lu)\n", i, ~i)); + NEXT_INST_F(1, 0, 0); } #ifndef TCL_WIDE_INT_IS_LONG } #endif /* TCL_WIDE_INT_IS_LONG */ } - ADJUST_PC(1); case INST_CALL_BUILTIN_FUNC1: opnd = TclGetUInt1AtPtr(pc+1); @@ -3577,7 +3446,7 @@ TclExecuteByteCode(interp, codePtr) } TRACE_WITH_OBJ(("%d => ", opnd), stackPtr[stackTop]); } - ADJUST_PC(2); + NEXT_INST_F(2, 0, 0); case INST_CALL_FUNC1: opnd = TclGetUInt1AtPtr(pc+1); @@ -3600,8 +3469,8 @@ TclExecuteByteCode(interp, codePtr) goto checkForCatch; } TRACE_WITH_OBJ(("%d => ", objc), stackPtr[stackTop]); - ADJUST_PC(2); } + NEXT_INST_F(2, 0, 0); case INST_TRY_CVT_TO_NUMERIC: { @@ -3615,7 +3484,7 @@ TclExecuteByteCode(interp, codePtr) double d; char *s; Tcl_ObjType *tPtr; - int converted, shared; + int converted, needNew; valuePtr = stackPtr[stackTop]; tPtr = valuePtr->typePtr; @@ -3653,66 +3522,68 @@ TclExecuteByteCode(interp, codePtr) * floating point error. */ + objResultPtr = valuePtr; + needNew = 0; if (IS_NUMERIC_TYPE(tPtr)) { - shared = 0; if (Tcl_IsShared(valuePtr)) { - shared = 1; if (valuePtr->bytes != NULL) { /* * We only need to make a copy of the object * when it already had a string rep */ + needNew = 1; if (tPtr == &tclIntType) { i = valuePtr->internalRep.longValue; - objPtr = Tcl_NewLongObj(i); + objResultPtr = Tcl_NewLongObj(i); #ifndef TCL_WIDE_INT_IS_LONG } else if (tPtr == &tclWideIntType) { w = valuePtr->internalRep.wideValue; - objPtr = Tcl_NewWideIntObj(w); + objResultPtr = Tcl_NewWideIntObj(w); #endif /* TCL_WIDE_INT_IS_LONG */ } else { d = valuePtr->internalRep.doubleValue; - objPtr = Tcl_NewDoubleObj(d); + objResultPtr = Tcl_NewDoubleObj(d); } - Tcl_IncrRefCount(objPtr); - TclDecrRefCount(valuePtr); - valuePtr = objPtr; - stackPtr[stackTop] = valuePtr; - tPtr = valuePtr->typePtr; + tPtr = objResultPtr->typePtr; } } else { Tcl_InvalidateStringRep(valuePtr); } if (tPtr == &tclDoubleType) { - d = valuePtr->internalRep.doubleValue; + d = objResultPtr->internalRep.doubleValue; if (IS_NAN(d) || IS_INF(d)) { TRACE(("\"%.20s\" => IEEE FLOATING PT ERROR\n", - O2S(valuePtr))); + O2S(objResultPtr))); TclExprFloatError(interp, d); result = TCL_ERROR; goto checkForCatch; } } - shared = shared; /* lint, shared not used. */ converted = converted; /* lint, converted not used. */ TRACE(("\"%.20s\" => numeric, %s, %s\n", O2S(valuePtr), (converted? "converted" : "not converted"), - (shared? "shared" : "not shared"))); + (needNew? "new Tcl_Obj" : "same Tcl_Obj"))); } else { TRACE(("\"%.20s\" => not numeric\n", O2S(valuePtr))); } + if (needNew) { + NEXT_INST_F(1, 1, 1); + } else { + NEXT_INST_F(1, 0, 0); + } } - ADJUST_PC(1); - + case INST_BREAK: Tcl_ResetResult(interp); result = TCL_BREAK; + cleanup = 0; goto processExceptionReturn; case INST_CONTINUE: Tcl_ResetResult(interp); result = TCL_CONTINUE; + cleanup = 0; goto processExceptionReturn; case INST_FOREACH_START4: @@ -3863,9 +3734,9 @@ TclExecuteByteCode(interp, codePtr) pc += 5; if (*pc == INST_JUMP_FALSE1) { - ADJUST_PC(continueLoop? 2 : TclGetInt1AtPtr(pc+1)); + NEXT_INST_F((continueLoop? 2 : TclGetInt1AtPtr(pc+1)), 0, 0); } else { - ADJUST_PC(continueLoop? 5 : TclGetInt4AtPtr(pc+1)); + NEXT_INST_F((continueLoop? 5 : TclGetInt4AtPtr(pc+1)), 0, 0); } } @@ -3878,23 +3749,23 @@ TclExecuteByteCode(interp, codePtr) catchStackPtr[++catchTop] = stackTop; TRACE(("%u => catchTop=%d, stackTop=%d\n", TclGetUInt4AtPtr(pc+1), catchTop, stackTop)); - ADJUST_PC(5); + NEXT_INST_F(5, 0, 0); case INST_END_CATCH: catchTop--; result = TCL_OK; TRACE(("=> catchTop=%d\n", catchTop)); - ADJUST_PC(1); - + NEXT_INST_F(1, 0, 0); + case INST_PUSH_RESULT: - PUSH_OBJECT(Tcl_GetObjResult(interp)); + objResultPtr = Tcl_GetObjResult(interp); TRACE_WITH_OBJ(("=> "), Tcl_GetObjResult(interp)); - ADJUST_PC(1); + NEXT_INST_F(1, 0, 1); case INST_PUSH_RETURN_CODE: - PUSH_OBJECT(Tcl_NewLongObj(result)); + objResultPtr = Tcl_NewLongObj(result); TRACE(("=> %u\n", result)); - ADJUST_PC(1); + NEXT_INST_F(1, 0, 1); default: panic("TclExecuteByteCode: unrecognized opCode %u", *pc); @@ -3926,24 +3797,24 @@ TclExecuteByteCode(interp, codePtr) if (rangePtr == NULL) { goto checkForCatch; } - switch (rangePtr->type) { - case CATCH_EXCEPTION_RANGE: - goto processCatch; - case LOOP_EXCEPTION_RANGE: - if (result == TCL_BREAK) { - pc = (codePtr->codeStart + rangePtr->breakOffset); - result = TCL_OK; - continue; - } else { - if (rangePtr->continueOffset == -1) { - goto checkForCatch; - } - pc = (codePtr->codeStart + rangePtr->continueOffset); - result = TCL_OK; - continue; - } - default: - panic("TclExecuteByteCode: bad ExceptionRange type\n"); + if (rangePtr->type == CATCH_EXCEPTION_RANGE) { + goto processCatch; + } + while (cleanup--) { + valuePtr = POP_OBJECT(); + TclDecrRefCount(valuePtr); + } + if (result == TCL_BREAK) { + result = TCL_OK; + pc = (codePtr->codeStart + rangePtr->breakOffset); + NEXT_INST_F(0, 0, 0); + } else { + if (rangePtr->continueOffset == -1) { + goto checkForCatch; + } + result = TCL_OK; + pc = (codePtr->codeStart + rangePtr->continueOffset); + NEXT_INST_F(0, 0, 0); } } @@ -4225,7 +4096,7 @@ TclExecuteByteCode(interp, codePtr) } #endif pc = (codePtr->codeStart + rangePtr->catchOffset); - continue; /* restart the execution loop at pc */ + NEXT_INST_F(0, 0, 0); /* restart the execution loop at pc */ } /* end of infinite loop dispatching on instructions */ /* |