addressType
evaluateMvariable(void)
{
symbolType *symbol;
symbol = getSymbol();
pushSymbol(symbol, evaluateExpression);
}
void
bindFunctionArguments(functionType *theFunction, int argCount)
{
argumentListType *argList;
argList = theFunction->functionArguments;
while (argCount > 0) {
if (argList == NULL) {
error(TOO_MANY_FUNCTION_ARGUMENTS_ERROR);
while (argCount-- > 0)
skipExpression();
} else {
pushSymbol(argList->argumentSymbol,
evaluateExpression());
argList = argList->nextArgument;
argCount--;
}
}
while (argList != NULL) {
pushSymbol(argList->argumentSymbol, 0);
argList = argList->nextArgument;
}
}
ParseStatus Parser::evalExpression() {
ParseStatus error = PARSE_OK;
while (error == PARSE_OK) {
Token t = lex[0];
// Check for terminators if we're not in a nested expression.
if (t.isDelimiter()) {
if (t.isTerminator() && delimiterDepth == 0) {
break;
}
error = pushDelimiter(t);
}
if (t.isLiteral()) {
error = pushSymbol(t);
}
if (t.isOperator()) {
error = pushOperator(t);
}
if (!error) lex++;
continue;
}
if (error) return error;
return emitEval();
/*
Token base = lex[0];
Token op = lex[1];
if (op.isDelimiter(DL_SEMICOLON)) {
// either "literal;" or "identifier;"
return evalLiteral();
}
if (base.isKeyword(KW_FUNCTION)) {
return parseFunction();
}
if (base.isDelimiter(DL_LPAREN)) {
// Tuple
return parseTuple();
}
if (base.isDelimiter(DL_LBRACE)) {
return parseBlock();
}
switch(base.type) {
case TT_EOF:
case TT_INVALID:
// Something's broken.
assert(false);
break;
case TT_OPERATOR:
// Unary operator
assert(false);
break;
case TT_DELIMITER:
// Tuple, array literal, block literal.
assert(false);
break;
case TT_NATIVE:
// Static cast to native type.
assert(false);
break;
case TT_IDENTIFIER:
// Function call or copy from variable.
assert(false);
case TT_INTEGER:
// Expression starting with integer.
assert(false);
case TT_FLOAT:
assert(false);
case TT_RUNE:
assert(false);
case TT_STRING:
assert(false);
case TT_DIRECTIVE:
assert(false);
case TT_COMMENT:
assert(false);
}
assert(false);
return PARSE_ERROR;
*/
}
