summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authordgp <dgp@users.sourceforge.net>2006-09-05 02:44:37 (GMT)
committerdgp <dgp@users.sourceforge.net>2006-09-05 02:44:37 (GMT)
commite1d50730905ad1a9ac8790a9f12e2a321f490b77 (patch)
tree87fcea3367aa6c711d1207e6821c436dadc707fc
parent000ee4180b53ec8878676aafcb4777947786def7 (diff)
downloadtcl-e1d50730905ad1a9ac8790a9f12e2a321f490b77.zip
tcl-e1d50730905ad1a9ac8790a9f12e2a321f490b77.tar.gz
tcl-e1d50730905ad1a9ac8790a9f12e2a321f490b77.tar.bz2
* generic/tclCompExpr.c: Removed much complexity that is
no longer needed.
-rw-r--r--ChangeLog3
-rw-r--r--generic/tclCompExpr.c380
2 files changed, 91 insertions, 292 deletions
diff --git a/ChangeLog b/ChangeLog
index 84bc188..b6c7d08 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,8 @@
2006-09-04 Don Porter <dgp@users.sourceforge.net>
+ * generic/tclCompExpr.c: Removed much complexity that is
+ no longer needed.
+
* tests/main.text (Tcl_Main-4.4): Test corrected to not be
timing sensitive to the Bug 1481986 fix. [Bug 1550858]
diff --git a/generic/tclCompExpr.c b/generic/tclCompExpr.c
index a4f2673..63d8be3 100644
--- a/generic/tclCompExpr.c
+++ b/generic/tclCompExpr.c
@@ -9,7 +9,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclCompExpr.c,v 1.33 2006/08/31 20:41:28 dgp Exp $
+ * RCS: @(#) $Id: tclCompExpr.c,v 1.34 2006/09/05 02:44:38 dgp Exp $
*/
#include "tclInt.h"
@@ -25,25 +25,6 @@ static int traceExprComp = 0;
#endif /* TCL_COMPILE_DEBUG */
/*
- * The ExprInfo structure describes the state of compiling an expression. A
- * pointer to an ExprInfo record is passed among the routines in this module.
- */
-
-typedef struct ExprInfo {
- Tcl_Interp *interp; /* Used for error reporting. */
- Tcl_Parse *parsePtr; /* Structure filled with information about the
- * parsed expression. */
- CONST char *expr; /* The expression that was originally passed
- * to TclCompileExpr. */
- CONST char *lastChar; /* Points just after last byte of expr. */
- int hasOperators; /* Set 1 if the expr has operators; 0 if expr
- * is only a primary. If 1 after compiling an
- * expr, a tryCvtToNumeric instruction is
- * emitted to convert the primary to a number
- * if possible. */
-} ExprInfo;
-
-/*
* Definitions of numeric codes representing each expression operator. The
* order of these must match the entries in the operatorTable below. Also the
* codes for the relational operators (OP_LESS, OP_GREATER, OP_LE, OP_GE,
@@ -136,19 +117,18 @@ static Tcl_HashTable opHashTable;
* Declarations for local procedures to this file:
*/
-static int CompileCondExpr(
- Tcl_Token *exprTokenPtr, ExprInfo *infoPtr,
- CompileEnv *envPtr, Tcl_Token **endPtrPtr);
-static int CompileLandOrLorExpr(
+static void CompileCondExpr(Tcl_Interp *interp,
+ Tcl_Token *exprTokenPtr, int *convertPtr,
+ CompileEnv *envPtr);
+static void CompileLandOrLorExpr(Tcl_Interp *interp,
Tcl_Token *exprTokenPtr, int opIndex,
- ExprInfo *infoPtr, CompileEnv *envPtr,
- Tcl_Token **endPtrPtr);
-static int CompileMathFuncCall(Tcl_Token *exprTokenPtr,
- CONST char *funcName, ExprInfo *infoPtr,
- CompileEnv *envPtr, Tcl_Token **endPtrPtr);
-static int CompileSubExpr(Tcl_Token *exprTokenPtr,
- ExprInfo *infoPtr, CompileEnv *envPtr);
-static void LogSyntaxError(ExprInfo *infoPtr);
+ CompileEnv *envPtr);
+static void CompileMathFuncCall(Tcl_Interp *interp,
+ Tcl_Token *exprTokenPtr, CONST char *funcName,
+ CompileEnv *envPtr);
+static void CompileSubExpr(Tcl_Interp *interp,
+ Tcl_Token *exprTokenPtr, int *convertPtr,
+ CompileEnv *envPtr);
/*
* Macro used to debug the execution of the expression compiler.
@@ -195,10 +175,8 @@ TclCompileExpr(
* first null character. */
CompileEnv *envPtr) /* Holds resulting instructions. */
{
- ExprInfo info;
Tcl_Parse parse;
- Tcl_HashEntry *hPtr;
- int new, i, code;
+ int needsNumConversion = 1;
/*
* If this is the first time we've been called, initialize the table of
@@ -211,9 +189,11 @@ TclCompileExpr(
if (!opTableInitialized) {
Tcl_MutexLock(&opMutex);
if (!opTableInitialized) {
+ int i;
Tcl_InitHashTable(&opHashTable, TCL_STRING_KEYS);
for (i = 0; operatorTable[i].name != NULL; i++) {
- hPtr = Tcl_CreateHashEntry(&opHashTable,
+ int new;
+ Tcl_HashEntry *hPtr = Tcl_CreateHashEntry(&opHashTable,
operatorTable[i].name, &new);
if (new) {
Tcl_SetHashValue(hPtr, (ClientData) i);
@@ -225,32 +205,15 @@ TclCompileExpr(
}
/*
- * Initialize the structure containing information abvout this expression
- * compilation.
- */
-
- info.interp = interp;
- info.parsePtr = &parse;
- info.expr = script;
- info.lastChar = (script + numBytes);
- info.hasOperators = 0;
-
- /*
* Parse the expression then compile it.
*/
- code = Tcl_ParseExpr(interp, script, numBytes, &parse);
- if (code != TCL_OK) {
- goto done;
- }
-
- code = CompileSubExpr(parse.tokenPtr, &info, envPtr);
- if (code != TCL_OK) {
- Tcl_FreeParse(&parse);
- goto done;
+ if (TCL_OK != Tcl_ParseExpr(interp, script, numBytes, &parse)) {
+ return TCL_ERROR;
}
+ CompileSubExpr(interp, parse.tokenPtr, &needsNumConversion, envPtr);
- if (!info.hasOperators) {
+ if (needsNumConversion) {
/*
* Attempt to convert the primary's object to an int or double. This
* is done in order to support Tcl's policy of interpreting operands
@@ -261,8 +224,7 @@ TclCompileExpr(
}
Tcl_FreeParse(&parse);
- done:
- return code;
+ return TCL_OK;
}
/*
@@ -304,9 +266,7 @@ TclFinalizeCompilation(void)
* subexpression at runtime.
*
* Results:
- * The return value is TCL_OK on a successful compilation and TCL_ERROR
- * on failure. If TCL_ERROR is returned, then the interpreter's result
- * contains an error message.
+ * None.
*
* Side effects:
* Adds instructions to envPtr to evaluate the subexpression.
@@ -314,101 +274,66 @@ TclFinalizeCompilation(void)
*----------------------------------------------------------------------
*/
-static int
+static void
CompileSubExpr(
+ Tcl_Interp *interp, /* Interp in which to compile expression */
Tcl_Token *exprTokenPtr, /* Points to TCL_TOKEN_SUB_EXPR token to
* compile. */
- ExprInfo *infoPtr, /* Describes the compilation state for the
- * expression being compiled. */
+ int *convertPtr, /* Writes 0 here if it is determined the
+ * final INST_TRY_CVT_TO_NUMERIC is
+ * not needed */
CompileEnv *envPtr) /* Holds resulting instructions. */
{
- Tcl_Interp *interp = infoPtr->interp;
- Tcl_Token *tokenPtr, *endPtr = NULL; /* silence gcc 4 warning */
- Tcl_Token *afterSubexprPtr;
- OperatorDesc *opDescPtr;
- Tcl_HashEntry *hPtr;
- CONST char *operator;
- Tcl_DString opBuf;
- int objIndex, opIndex, length, code;
- char buffer[TCL_UTF_MAX];
-
- if (exprTokenPtr->type != TCL_TOKEN_SUB_EXPR) {
- Tcl_Panic("CompileSubExpr: token type %d not TCL_TOKEN_SUB_EXPR",
- exprTokenPtr->type);
- }
- code = TCL_OK;
-
- /*
- * Switch on the type of the first token after the subexpression token.
- * After processing it, advance tokenPtr to point just after the
- * subexpression's last token.
- */
-
- tokenPtr = exprTokenPtr+1;
+ /* Switch on the type of the first token after the subexpression token. */
+ Tcl_Token *tokenPtr = exprTokenPtr+1;
TRACE(exprTokenPtr->start, exprTokenPtr->size,
tokenPtr->start, tokenPtr->size);
switch (tokenPtr->type) {
case TCL_TOKEN_WORD:
TclCompileTokens(interp, tokenPtr+1, tokenPtr->numComponents, envPtr);
- tokenPtr += (tokenPtr->numComponents + 1);
break;
case TCL_TOKEN_TEXT:
- if (tokenPtr->size > 0) {
- objIndex = TclRegisterNewLiteral(envPtr, tokenPtr->start,
- tokenPtr->size);
- } else {
- objIndex = TclRegisterNewLiteral(envPtr, "", 0);
- }
- TclEmitPush(objIndex, envPtr);
- tokenPtr += 1;
+ TclEmitPush(TclRegisterNewLiteral(envPtr,
+ tokenPtr->start, tokenPtr->size), envPtr);
break;
- case TCL_TOKEN_BS:
- length = Tcl_UtfBackslash(tokenPtr->start, NULL, buffer);
- if (length > 0) {
- objIndex = TclRegisterNewLiteral(envPtr, buffer, length);
- } else {
- objIndex = TclRegisterNewLiteral(envPtr, "", 0);
- }
- TclEmitPush(objIndex, envPtr);
- tokenPtr += 1;
+ case TCL_TOKEN_BS: {
+ char buffer[TCL_UTF_MAX];
+ int length = Tcl_UtfBackslash(tokenPtr->start, NULL, buffer);
+ TclEmitPush(TclRegisterNewLiteral(envPtr, buffer, length), envPtr);
break;
+ }
case TCL_TOKEN_COMMAND:
TclCompileScript(interp, tokenPtr->start+1, tokenPtr->size-2, envPtr);
- tokenPtr += 1;
break;
case TCL_TOKEN_VARIABLE:
TclCompileTokens(interp, tokenPtr, 1, envPtr);
- tokenPtr += (tokenPtr->numComponents + 1);
break;
case TCL_TOKEN_SUB_EXPR:
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr += (tokenPtr->numComponents + 1);
+ CompileSubExpr(interp, tokenPtr, convertPtr, envPtr);
break;
- case TCL_TOKEN_OPERATOR:
+ case TCL_TOKEN_OPERATOR: {
/*
* Look up the operator. If the operator isn't found, treat it as a
* math function.
*/
+ OperatorDesc *opDescPtr;
+ Tcl_HashEntry *hPtr;
+ CONST char *operator;
+ Tcl_DString opBuf;
+ int opIndex;
+
Tcl_DStringInit(&opBuf);
operator = Tcl_DStringAppend(&opBuf, tokenPtr->start, tokenPtr->size);
hPtr = Tcl_FindHashEntry(&opHashTable, operator);
if (hPtr == NULL) {
- code = CompileMathFuncCall(exprTokenPtr, operator, infoPtr, envPtr,
- &endPtr);
+ CompileMathFuncCall(interp, exprTokenPtr, operator, envPtr);
Tcl_DStringFree(&opBuf);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr = endPtr;
break;
}
Tcl_DStringFree(&opBuf);
@@ -422,21 +347,14 @@ CompileSubExpr(
if (opDescPtr->numOperands > 0) {
tokenPtr++;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
+ CompileSubExpr(interp, tokenPtr, convertPtr, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
if (opDescPtr->numOperands == 2) {
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr += (tokenPtr->numComponents + 1);
+ CompileSubExpr(interp, tokenPtr, convertPtr, envPtr);
}
TclEmitOpcode(opDescPtr->instruction, envPtr);
- infoPtr->hasOperators = 1;
+ *convertPtr = 0;
break;
}
@@ -447,19 +365,17 @@ CompileSubExpr(
switch (opIndex) {
case OP_PLUS:
- case OP_MINUS:
+ case OP_MINUS: {
+ Tcl_Token *afterSubexprPtr = exprTokenPtr
+ + exprTokenPtr->numComponents+1;
tokenPtr++;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
+ CompileSubExpr(interp, tokenPtr, convertPtr, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
/*
* Check whether the "+" or "-" is unary.
*/
- afterSubexprPtr = exprTokenPtr + exprTokenPtr->numComponents+1;
if (tokenPtr == afterSubexprPtr) {
TclEmitOpcode(((opIndex==OP_PLUS)? INST_UPLUS : INST_UMINUS),
envPtr);
@@ -470,58 +386,33 @@ CompileSubExpr(
* The "+" or "-" is binary.
*/
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr += (tokenPtr->numComponents + 1);
+ CompileSubExpr(interp, tokenPtr, convertPtr, envPtr);
TclEmitOpcode(((opIndex==OP_PLUS)? INST_ADD : INST_SUB), envPtr);
+ *convertPtr = 0;
break;
+ }
case OP_LAND:
case OP_LOR:
- code = CompileLandOrLorExpr(exprTokenPtr, opIndex, infoPtr, envPtr,
- &endPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr = endPtr;
+ CompileLandOrLorExpr(interp, exprTokenPtr, opIndex, envPtr);
+ *convertPtr = 0;
break;
case OP_QUESTY:
- code = CompileCondExpr(exprTokenPtr, infoPtr, envPtr, &endPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr = endPtr;
+ CompileCondExpr(interp, exprTokenPtr, convertPtr, envPtr);
break;
default:
- Tcl_Panic("CompileSubExpr: unexpected operator %d requiring special treatment",
- opIndex);
+ Tcl_Panic("CompileSubExpr: unexpected operator %d "
+ "requiring special treatment", opIndex);
} /* end switch on operator requiring special treatment */
- infoPtr->hasOperators = 1;
break;
- default:
- Tcl_Panic("CompileSubExpr: unexpected token type %d",
- tokenPtr->type);
}
- /*
- * Verify that the subexpression token had the required number of
- * subtokens: that we've advanced tokenPtr just beyond the subexpression's
- * last token. For example, a "*" subexpression must contain the tokens
- * for exactly two operands.
- */
-
- if (tokenPtr != (exprTokenPtr + exprTokenPtr->numComponents+1)) {
- LogSyntaxError(infoPtr);
- code = TCL_ERROR;
+ default:
+ Tcl_Panic("CompileSubExpr: unexpected token type %d", tokenPtr->type);
}
-
- done:
- return code;
}
/*
@@ -533,11 +424,7 @@ CompileSubExpr(
* subexpression.
*
* Results:
- * The return value is TCL_OK on a successful compilation and TCL_ERROR
- * on failure. If TCL_OK is returned, a pointer to the token just after
- * the last one in the subexpression is stored at the address in
- * endPtrPtr. If TCL_ERROR is returned, then the interpreter's result
- * contains an error message.
+ * None.
*
* Side effects:
* Adds instructions to envPtr to evaluate the expression at runtime.
@@ -545,18 +432,14 @@ CompileSubExpr(
*----------------------------------------------------------------------
*/
-static int
+static void
CompileLandOrLorExpr(
+ Tcl_Interp *interp, /* Interp in which compile takes place */
Tcl_Token *exprTokenPtr, /* Points to TCL_TOKEN_SUB_EXPR token
* containing the "&&" or "||" operator. */
int opIndex, /* A code describing the expression operator:
* either OP_LAND or OP_LOR. */
- ExprInfo *infoPtr, /* Describes the compilation state for the
- * expression being compiled. */
- CompileEnv *envPtr, /* Holds resulting instructions. */
- Tcl_Token **endPtrPtr) /* If successful, a pointer to the token just
- * after the last token in the subexpression
- * is stored here. */
+ CompileEnv *envPtr) /* Holds resulting instructions. */
{
JumpFixup shortCircuitFixup;/* Used to fix up the short circuit jump after
* the first subexpression. */
@@ -564,19 +447,15 @@ CompileLandOrLorExpr(
/* Used to fix up the second jump to the
* short-circuit target. */
JumpFixup endFixup; /* Used to fix up jump to the end. */
- Tcl_Token *tokenPtr;
- int code;
+ int convert = 0;
int savedStackDepth = envPtr->currStackDepth;
+ Tcl_Token *tokenPtr = exprTokenPtr+2;
/*
* Emit code for the first operand.
*/
- tokenPtr = exprTokenPtr+2;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
+ CompileSubExpr(interp, tokenPtr, &convert, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
/*
@@ -591,11 +470,7 @@ CompileLandOrLorExpr(
* Emit code for the second operand.
*/
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr += (tokenPtr->numComponents + 1);
+ CompileSubExpr(interp, tokenPtr, &convert, envPtr);
/*
* The result is the boolean value of the second operand. We code this in
@@ -635,11 +510,7 @@ CompileLandOrLorExpr(
}
TclFixupForwardJumpToHere(envPtr, &endFixup, 127);
- *endPtrPtr = tokenPtr;
-
- done:
envPtr->currStackDepth = savedStackDepth + 1;
- return code;
}
/*
@@ -651,11 +522,7 @@ CompileLandOrLorExpr(
* condExpr ::= lorExpr ['?' condExpr ':' condExpr]
*
* Results:
- * The return value is TCL_OK on a successful compilation and TCL_ERROR
- * on failure. If TCL_OK is returned, a pointer to the token just after
- * the last one in the subexpression is stored at the address in
- * endPtrPtr. If TCL_ERROR is returned, then the interpreter's result
- * contains an error message.
+ * None.
*
* Side effects:
* Adds instructions to envPtr to evaluate the expression at runtime.
@@ -663,34 +530,29 @@ CompileLandOrLorExpr(
*----------------------------------------------------------------------
*/
-static int
+static void
CompileCondExpr(
+ Tcl_Interp *interp, /* Interp in which compile takes place */
Tcl_Token *exprTokenPtr, /* Points to TCL_TOKEN_SUB_EXPR token
* containing the "?" operator. */
- ExprInfo *infoPtr, /* Describes the compilation state for the
+ int *convertPtr, /* Describes the compilation state for the
* expression being compiled. */
- CompileEnv *envPtr, /* Holds resulting instructions. */
- Tcl_Token **endPtrPtr) /* If successful, a pointer to the token just
- * after the last token in the subexpression
- * is stored here. */
+ CompileEnv *envPtr) /* Holds resulting instructions. */
{
JumpFixup jumpAroundThenFixup, jumpAroundElseFixup;
/* Used to update or replace one-byte jumps
* around the then and else expressions when
* their target PCs are determined. */
- Tcl_Token *tokenPtr;
- int elseCodeOffset, dist, code;
+ Tcl_Token *tokenPtr = exprTokenPtr+2;
+ int elseCodeOffset, dist, convert = 0;
+ int convertThen = 1, convertElse = 1;
int savedStackDepth = envPtr->currStackDepth;
/*
* Emit code for the test.
*/
- tokenPtr = exprTokenPtr+2;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
+ CompileSubExpr(interp, tokenPtr, &convert, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
/*
@@ -706,15 +568,8 @@ CompileCondExpr(
* integers, else floating-point numbers.
*/
- infoPtr->hasOperators = 0;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
+ CompileSubExpr(interp, tokenPtr, &convertThen, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
- if (!infoPtr->hasOperators) {
- TclEmitOpcode(INST_TRY_CVT_TO_NUMERIC, envPtr);
- }
/*
* Emit an unconditional jump around the "else" condExpr.
@@ -728,15 +583,7 @@ CompileCondExpr(
envPtr->currStackDepth = savedStackDepth;
elseCodeOffset = (envPtr->codeNext - envPtr->codeStart);
- infoPtr->hasOperators = 0;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- goto done;
- }
- tokenPtr += (tokenPtr->numComponents + 1);
- if (!infoPtr->hasOperators) {
- TclEmitOpcode(INST_TRY_CVT_TO_NUMERIC, envPtr);
- }
+ CompileSubExpr(interp, tokenPtr, &convertElse, envPtr);
/*
* Fix up the second jump around the "else" expression.
@@ -759,11 +606,9 @@ CompileCondExpr(
dist = (elseCodeOffset - jumpAroundThenFixup.codeOffset);
TclFixupForwardJump(envPtr, &jumpAroundThenFixup, dist, 127);
- *endPtrPtr = tokenPtr;
+ *convertPtr = convertThen || convertElse;
- done:
envPtr->currStackDepth = savedStackDepth + 1;
- return code;
}
/*
@@ -775,11 +620,7 @@ CompileCondExpr(
* mathFuncCall ::= funcName '(' [condExpr {',' condExpr}] ')'
*
* Results:
- * The return value is TCL_OK on a successful compilation and TCL_ERROR
- * on failure. If TCL_OK is returned, a pointer to the token just after
- * the last one in the subexpression is stored at the address in
- * endPtrPtr. If TCL_ERROR is returned, then the interpreter's result
- * contains an error message.
+ * None.
*
* Side effects:
* Adds instructions to envPtr to evaluate the math function at
@@ -788,24 +629,18 @@ CompileCondExpr(
*----------------------------------------------------------------------
*/
-static int
+static void
CompileMathFuncCall(
+ Tcl_Interp *interp, /* Interp in which compile takes place */
Tcl_Token *exprTokenPtr, /* Points to TCL_TOKEN_SUB_EXPR token
* containing the math function call. */
CONST char *funcName, /* Name of the math function. */
- ExprInfo *infoPtr, /* Describes the compilation state for the
- * expression being compiled. */
- CompileEnv *envPtr, /* Holds resulting instructions. */
- Tcl_Token **endPtrPtr) /* If successful, a pointer to the token just
- * after the last token in the subexpression
- * is stored here. */
+ CompileEnv *envPtr) /* Holds resulting instructions. */
{
Tcl_DString cmdName;
int objIndex;
Tcl_Token *tokenPtr, *afterSubexprPtr;
int argCount;
- int code = TCL_OK;
- int saveHasOperators = infoPtr->hasOperators;
/*
* Prepend "tcl::mathfunc::" to the function name, to produce the name of
@@ -830,11 +665,9 @@ CompileMathFuncCall(
tokenPtr = exprTokenPtr+2;
afterSubexprPtr = exprTokenPtr + (exprTokenPtr->numComponents + 1);
while (tokenPtr != afterSubexprPtr) {
+ int convert = 0;
++argCount;
- code = CompileSubExpr(tokenPtr, infoPtr, envPtr);
- if (code != TCL_OK) {
- return code;
- }
+ CompileSubExpr(interp, tokenPtr, &convert, envPtr);
tokenPtr += (tokenPtr->numComponents + 1);
}
@@ -845,43 +678,6 @@ CompileMathFuncCall(
} else {
TclEmitInstInt4(INST_INVOKE_STK4, argCount, envPtr);
}
-
- *endPtrPtr = afterSubexprPtr;
- infoPtr->hasOperators = saveHasOperators;
- return TCL_OK;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * LogSyntaxError --
- *
- * This procedure is invoked after an error occurs when compiling an
- * expression. It sets the interpreter result to an error message
- * describing the error.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Sets the interpreter result to an error message describing the
- * expression that was being compiled when the error occurred.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-LogSyntaxError(
- ExprInfo *infoPtr) /* Describes the compilation state for the
- * expression being compiled. */
-{
- Tcl_Obj *result =
- Tcl_NewStringObj("syntax error in expression \"", -1);
-
- TclAppendLimitedToObj(result, infoPtr->expr,
- (int)(infoPtr->lastChar - infoPtr->expr), 60, "");
- Tcl_AppendToObj(result, "\"", -1);
- Tcl_SetObjResult(infoPtr->interp, result);
}
/*