INVALID		/* CAN */,	INVALID		/* EM */,
	INVALID		/* SUB */,	INVALID		/* ESC */,
	INVALID		/* FS */,	INVALID		/* GS */,
	INVALID		/* RS */,	INVALID		/* US */,
	INVALID		/* SPACE */,	0		/* ! or != */,
	QUOTED		/* " */,	INVALID		/* # */,
	VARIABLE	/* $ */,	MOD		/* % */,
	0		/* & or && */,	INVALID		/* ' */,
	0		/* & or && */,	VARNAME		/* ' */,
	OPEN_PAREN	/* ( */,	CLOSE_PAREN	/* ) */,
	0		/* * or ** */,	PLUS		/* + */,
	COMMA		/* , */,	MINUS		/* - */,
	0		/* . */,	DIVIDE		/* / */,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,			/* 0-9 */
	0		/* : or := */,	SEPARATOR	/* ; */,
	0		/* < or << or <= */,

		 * exceptions are that when a bareword is followed by an open
		 * paren, it might be a function call, and when the bareword
		 * is a legal literal boolean value, we accept that as well.
		 */

		if (start[scanned+TclParseAllWhiteSpace(
			start+scanned, numBytes-scanned)] == '(') {

		    /* Look ahead for assignment operator */

		    /* 
		     * TODO: this can probably be simplified.  
		     * For now, it is working. 
		     */

		    Tcl_Parse vparse;
		    const char *varend, *varstart = &start[TclParseAllWhiteSpace(start, numBytes)];
		    int code, len;
		    TclParseInit(interp, varstart, numBytes, &vparse);
		    code = Tcl_ParseVarName(NULL, varstart, numBytes, &vparse, 0);
		    if (code != TCL_OK) {
			//fprintf(stderr, "Replace me with proper error!\n");
		    }
		    len = vparse.tokenPtr[0].size;
		    varend = varstart+len;
		    Tcl_FreeParse(&vparse);

		    /* Look ahead for Assignment operator ':=' */
		    if (code == TCL_OK &&
			varend[TclParseAllWhiteSpace(varend,numBytes-len)] == ':' && 
			varend[TclParseAllWhiteSpace(varend,numBytes-len)+1] == '=') {

			lexeme = VARNAME;

			/* Adjust scanned bytes */
			scanned = varend-start;

			/* The variable name is tokenized below as a quoted string */

		    } else {

			lexeme = FUNCTION;
		    lexeme = FUNCTION;

			/*
			 * When we compile the expression we'll need the function
			 * name, and there's no place in the parse tree to store
			 * it, so we keep a separate list of all the function
			 * names we've parsed in the order we found them.
			 */
		    /*
		     * When we compile the expression we'll need the function
		     * name, and there's no place in the parse tree to store
		     * it, so we keep a separate list of all the function
		     * names we've parsed in the order we found them.
		     */

			Tcl_ListObjAppendElement(NULL, funcList, literal);
		    }
		    Tcl_ListObjAppendElement(NULL, funcList, literal);


		} else if (start[scanned+TclParseAllWhiteSpace(
			start+scanned, numBytes-scanned)] == ':' &&
			   start[scanned+TclParseAllWhiteSpace(
			start+scanned, numBytes-scanned)+1] == '=') {

		    Tcl_ListObjAppendElement(NULL, litList, literal);
		    /* Simple bareword */
		    lexeme = VARNAME;

		    complete = lastParsed = OT_LITERAL;
		    start += scanned;
		    numBytes -= scanned;
		    /* The variable name is stored as an OT_LITERAL below */
		    continue;

		} else if (Tcl_GetBooleanFromObj(NULL,literal,&b) == TCL_OK) {
		    lexeme = BOOLEAN;
		} else {
		    Tcl_DecrRefCount(literal);
		    msg = Tcl_ObjPrintf("invalid bareword \"%.*s%s\"",
			    (scanned < limit) ? scanned : limit - 3, start,

		Tcl_ListObjAppendElement(NULL, litList, literal);
		complete = lastParsed = OT_LITERAL;
		start += scanned;
		numBytes -= scanned;
		continue;

	    case VARNAME: {
                Tcl_Parse vparse;  int vcode, length;
                TclParseInit(NULL, start, numBytes, &vparse);
                vcode = Tcl_ParseVarName(NULL, start, numBytes, &vparse, 0);
		int length;
		TclGetStringFromObj(literal, &length);
		if (length < scanned) {
                length = vparse.tokenPtr[0].size;
                Tcl_FreeParse(&vparse);

                if (vcode == TCL_OK && length > 1) {
                   start++; length--; numBytes--;
                   scanned = length;
		    // Go tokenize the literal...
		    break;
		} else {
                   break;
                } else {
		    Tcl_ListObjAppendElement(NULL, litList, literal);
		    complete = lastParsed = OT_LITERAL;
		    start += scanned;
                   //fprintf(stderr, "VARNAME-1: code=%d,len=%d, \"%s\"\n",vcode,length,start);
                   start++; scanned = 1; numBytes--;
		    numBytes -= scanned;
		    continue;
		}
                   continue;
                }
	    } /* VARNAME case */

	    default:
		break;
	    }

	    /*

		if (incompletePtr->lexeme != OPEN_PAREN) {
		    TclNewLiteralStringObj(msg, "unbalanced close paren");
		    errCode = "UNBALANCED";
		    goto error;
		}
	    }

	    /* Enfocre LHS is literal, bareword, function
	    /* Enforce LHS is literal or bareword
	     * TODO: If function, convert to array reference
	     */
	    if (lexeme == ASSIGN) {
		if (complete != OT_LITERAL &&
		    complete != OT_TOKENS &&
		    complete != OT_TOKENS) {
		    complete != FUNCTION) {

		    TclNewLiteralStringObj(msg, "Target of assignment must be string");
		    errCode = "SURPRISE";
		    goto error;		    
		}
	    }