diff options
Diffstat (limited to 'source4/lib/ejs/ejsParser.c')
| -rw-r--r-- | source4/lib/ejs/ejsParser.c | 2358 |
1 files changed, 2358 insertions, 0 deletions
diff --git a/source4/lib/ejs/ejsParser.c b/source4/lib/ejs/ejsParser.c new file mode 100644 index 0000000000..f9335ec004 --- /dev/null +++ b/source4/lib/ejs/ejsParser.c @@ -0,0 +1,2358 @@ +/* + * @file ejsParser.c + * @brief EJS Parser and Execution + */ +/********************************* Copyright **********************************/ +/* + * @copy default.g + * + * Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved. + * Portions Copyright (c) GoAhead Software, 1995-2000. All Rights Reserved. + * + * This software is distributed under commercial and open source licenses. + * You may use the GPL open source license described below or you may acquire + * a commercial license from Mbedthis Software. You agree to be fully bound + * by the terms of either license. Consult the LICENSE.TXT distributed with + * this software for full details. + * + * This software is open source; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. See the GNU General Public License for more + * details at: http://www.mbedthis.com/downloads/gplLicense.html + * + * This program is distributed WITHOUT ANY WARRANTY; without even the + * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * This GPL license does NOT permit incorporating this software into + * proprietary programs. If you are unable to comply with the GPL, you must + * acquire a commercial license to use this software. Commercial licenses + * for this software and support services are available from Mbedthis + * Software at http://www.mbedthis.com + * + * @end + */ + +/********************************** Includes **********************************/ + +#include "lib/ejs/ejsInternal.h" + +#if BLD_FEATURE_EJS + +/****************************** Forward Declarations **************************/ + +static void appendValue(MprVar *v1, MprVar *v2); +static int evalCond(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs); +static int evalExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs); +#if BLD_FEATURE_FLOATING_POINT +static int evalFloatExpr(Ejs *ep, double l, int rel, double r); +#endif +static int evalBoolExpr(Ejs *ep, bool l, int rel, bool r); +static int evalNumericExpr(Ejs *ep, MprNum l, int rel, MprNum r); +static int evalStringExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs); +static int evalFunction(Ejs *ep, MprVar *obj, int flags); +static void freeProc(EjsProc *proc); +static int parseArgs(Ejs *ep, int state, int flags); +static int parseAssignment(Ejs *ep, int state, int flags, char *id, + char *fullName); +static int parseCond(Ejs *ep, int state, int flags); +static int parseDeclaration(Ejs *ep, int state, int flags); +static int parseExpr(Ejs *ep, int state, int flags); +static int parseFor(Ejs *ep, int state, int flags); +static int parseForIn(Ejs *ep, int state, int flags); +static int parseFunctionDec(Ejs *ep, int state, int flags); +static int parseFunction(Ejs *ep, int state, int flags, char *id); +static int parseId(Ejs *ep, int state, int flags, char **id, + char **fullName, int *fullNameLen, int *done); +static int parseInc(Ejs *ep, int state, int flags); +static int parseIf(Ejs *ep, int state, int flags, int *done); +static int parseStmt(Ejs *ep, int state, int flags); +static void removeNewlines(Ejs *ep, int state); +static void updateResult(Ejs *ep, int state, int flags, MprVar *vp); + +/************************************* Code ***********************************/ +/* + * Recursive descent parser for EJS + */ + +int ejsParse(Ejs *ep, int state, int flags) +{ + mprAssert(ep); + + switch (state) { + /* + * Any statement, function arguments or conditional expressions + */ + case EJS_STATE_STMT: + if ((state = parseStmt(ep, state, flags)) != EJS_STATE_STMT_DONE && + state != EJS_STATE_EOF && state != EJS_STATE_STMT_BLOCK_DONE && + state != EJS_STATE_RET) { + state = EJS_STATE_ERR; + } + break; + + case EJS_STATE_DEC: + if ((state = parseStmt(ep, state, flags)) != EJS_STATE_DEC_DONE && + state != EJS_STATE_EOF) { + state = EJS_STATE_ERR; + } + break; + + case EJS_STATE_EXPR: + if ((state = parseStmt(ep, state, flags)) != EJS_STATE_EXPR_DONE && + state != EJS_STATE_EOF) { + state = EJS_STATE_ERR; + } + break; + + /* + * Variable declaration list + */ + case EJS_STATE_DEC_LIST: + state = parseDeclaration(ep, state, flags); + break; + + /* + * Function argument string + */ + case EJS_STATE_ARG_LIST: + state = parseArgs(ep, state, flags); + break; + + /* + * Logical condition list (relational operations separated by &&, ||) + */ + case EJS_STATE_COND: + state = parseCond(ep, state, flags); + break; + + /* + * Expression list + */ + case EJS_STATE_RELEXP: + state = parseExpr(ep, state, flags); + break; + } + + if (state == EJS_STATE_ERR && ep->error == NULL) { + ejsError(ep, "Syntax error"); + } + return state; +} + +/******************************************************************************/ +/* + * Parse any statement including functions and simple relational operations + */ + +static int parseStmt(Ejs *ep, int state, int flags) +{ + EjsProc *saveProc; + MprVar *vp, *saveObj; + char *id, *fullName, *initToken; + int done, expectSemi, tid, fullNameLen, rel; + int initId; + + mprAssert(ep); + + expectSemi = 0; + saveProc = NULL; + id = 0; + fullName = 0; + fullNameLen = 0; + + ep->currentObj = 0; + ep->currentProperty = 0; + + for (done = 0; !done && state != EJS_STATE_ERR; ) { + tid = ejsLexGetToken(ep, state); + + switch (tid) { + default: + ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token); + done++; + break; + + case EJS_TOK_EXPR: + rel = (int) *ep->token; + if (state == EJS_STATE_EXPR) { + ejsLexPutbackToken(ep, EJS_TOK_EXPR, ep->token); + } + done++; + break; + + case EJS_TOK_LOGICAL: + ejsLexPutbackToken(ep, tid, ep->token); + done++; + break; + + case EJS_TOK_ERR: + state = EJS_STATE_ERR; + done++; + break; + + case EJS_TOK_EOF: + state = EJS_STATE_EOF; + done++; + break; + + case EJS_TOK_NEWLINE: + break; + + case EJS_TOK_SEMI: + /* + * This case is when we discover no statement and just a lone ';' + */ + if (state != EJS_STATE_STMT) { + ejsLexPutbackToken(ep, tid, ep->token); + } + done++; + break; + + case EJS_TOK_PERIOD: + if (flags & EJS_FLAGS_EXE) { + if (ep->currentProperty == 0) { + ejsError(ep, "Undefined object \"%s\"\n", id); + goto error; + } + } + ep->currentObj = ep->currentProperty; + + if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) { + ejsError(ep, "Bad property after '.': %s\n", ep->token); + goto error; + } + mprFree(id); + id = mprStrdup(ep->token); + + vp = ejsFindProperty(ep, state, ep->currentObj, id, flags); + updateResult(ep, state, flags, vp); + +#if BLD_DEBUG + fullNameLen = mprReallocStrcat(&fullName, MPR_MAX_VAR, fullNameLen, + 0, ".", 0); +#endif + + ep->currentProperty = vp; + ejsLexPutbackToken(ep, tid, ep->token); + break; + + case EJS_TOK_LBRACKET: + ep->currentObj = ep->currentProperty; + saveObj = ep->currentObj; + if (ejsParse(ep, EJS_STATE_RELEXP, flags) != EJS_STATE_RELEXP_DONE){ + goto error; + } + ep->currentObj = saveObj; + + mprFree(id); + mprVarToString(&id, MPR_MAX_STRING, 0, &ep->result); + + if (id[0] == '\0') { + if (flags & EJS_FLAGS_EXE) { + ejsError(ep, + "[] expression evaluates to the empty string\n"); + goto error; + } + } else { + vp = ejsFindProperty(ep, state, ep->currentObj, id, flags); + ep->currentProperty = vp; + updateResult(ep, state, flags, vp); + } + +#if BLD_DEBUG + if (id[0] && strlen(id) < (MPR_MAX_VAR / 2)) { + /* + * If not executing yet, id may not be known + */ + fullNameLen = mprReallocStrcat(&fullName, MPR_MAX_VAR, + fullNameLen, 0, "[", id, "]", 0); + } +#endif + + if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_RBRACKET) { + ejsError(ep, "Missing ']'\n"); + goto error; + } + break; + + case EJS_TOK_ID: + state = parseId(ep, state, flags, &id, &fullName, &fullNameLen, + &done); + if (done && state == EJS_STATE_STMT) { + expectSemi++; + } + break; + + case EJS_TOK_ASSIGNMENT: + state = parseAssignment(ep, state, flags, id, fullName); + if (state == EJS_STATE_STMT) { + expectSemi++; + done++; + } + break; + + case EJS_TOK_INC_DEC: + state = parseInc(ep, state, flags); + if (state == EJS_STATE_STMT) { + expectSemi++; + } + break; + + case EJS_TOK_NEW: + if (ejsParse(ep, EJS_STATE_EXPR, flags | EJS_FLAGS_NEW) + != EJS_STATE_EXPR_DONE) { + goto error; + } + break; + + case EJS_TOK_DELETE: + if (ejsParse(ep, EJS_STATE_EXPR, + flags | EJS_FLAGS_DELETE) != EJS_STATE_EXPR_DONE) { + goto error; + } + mprDeleteProperty(ep->currentObj, ep->currentProperty->name); + done++; + break; + + case EJS_TOK_FUNCTION: + state = parseFunctionDec(ep, state, flags); + done++; + break; + + case EJS_TOK_LITERAL: + /* + * Set the result to the string literal + */ + mprCopyVarValue(&ep->result, mprCreateStringVar(ep->token, 0), + MPR_SHALLOW_COPY); + if (state == EJS_STATE_STMT) { + expectSemi++; + } + done++; + break; + + case EJS_TOK_NUMBER: + /* + * Set the result to the parsed number + */ + mprCopyVar(&ep->result, &ep->tokenNumber, 0); + if (state == EJS_STATE_STMT) { + expectSemi++; + } + done++; + break; + + case EJS_TOK_FUNCTION_NAME: + state = parseFunction(ep, state, flags, id); + if (state == EJS_STATE_STMT) { + expectSemi++; + } + if (ep->flags & EJS_FLAGS_EXIT) { + state = EJS_STATE_RET; + } + done++; + break; + + case EJS_TOK_IF: + state = parseIf(ep, state, flags, &done); + if (state == EJS_STATE_RET) { + goto doneParse; + } + break; + + case EJS_TOK_FOR: + if (state != EJS_STATE_STMT) { + goto error; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) { + goto error; + } + /* + * Need to peek 2-3 tokens ahead and see if this is a + * for ([var] x in set) + * or + * for (init ; whileCond; incr) + */ + initId = ejsLexGetToken(ep, EJS_STATE_EXPR); + if (initId == EJS_TOK_ID && strcmp(ep->token, "var") == 0) { + /* Simply eat var tokens */ + initId = ejsLexGetToken(ep, EJS_STATE_EXPR); + } + initToken = mprStrdup(ep->token); + + tid = ejsLexGetToken(ep, EJS_STATE_EXPR); + + ejsLexPutbackToken(ep, tid, ep->token); + ejsLexPutbackToken(ep, initId, initToken); + mprFree(initToken); + + if (tid == EJS_TOK_IN) { + if ((state = parseForIn(ep, state, flags)) < 0) { + goto error; + } + } else { + if ((state = parseFor(ep, state, flags)) < 0) { + goto error; + } + } + done++; + break; + + case EJS_TOK_VAR: + if (ejsParse(ep, EJS_STATE_DEC_LIST, flags) + != EJS_STATE_DEC_LIST_DONE) { + goto error; + } + done++; + break; + + case EJS_TOK_COMMA: + ejsLexPutbackToken(ep, tid, ep->token); + done++; + break; + + case EJS_TOK_LPAREN: + if (state == EJS_STATE_EXPR) { + if (ejsParse(ep, EJS_STATE_RELEXP, flags) + != EJS_STATE_RELEXP_DONE) { + goto error; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + goto error; + } + } + done++; + break; + + case EJS_TOK_RPAREN: + ejsLexPutbackToken(ep, tid, ep->token); + done++; + break; + + case EJS_TOK_LBRACE: + /* + * This handles any code in braces except "if () {} else {}" + */ + if (state != EJS_STATE_STMT) { + goto error; + } + + /* + * Parse will return EJS_STATE_STMT_BLOCK_DONE when the RBRACE + * is seen. + */ + do { + state = ejsParse(ep, EJS_STATE_STMT, flags); + } while (state == EJS_STATE_STMT_DONE); + + if (state != EJS_STATE_RET) { + if (ejsLexGetToken(ep, state) != EJS_TOK_RBRACE) { + goto error; + } + state = EJS_STATE_STMT_DONE; + } + done++; + break; + + case EJS_TOK_RBRACE: + if (state == EJS_STATE_STMT) { + ejsLexPutbackToken(ep, tid, ep->token); + state = EJS_STATE_STMT_BLOCK_DONE; + done++; + break; + } + goto error; + + case EJS_TOK_RETURN: + if (ejsParse(ep, EJS_STATE_RELEXP, flags) + != EJS_STATE_RELEXP_DONE) { + goto error; + } + if (flags & EJS_FLAGS_EXE) { + while (ejsLexGetToken(ep, state) != EJS_TOK_EOF) { + ; + } + state = EJS_STATE_RET; + done++; + } + break; + } + } + + if (expectSemi) { + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_SEMI && tid != EJS_TOK_NEWLINE && + tid != EJS_TOK_EOF) { + goto error; + } + + /* + * Skip newline after semi-colon + */ + removeNewlines(ep, state); + } + +/* + * Free resources and return the correct status + */ +doneParse: + mprFree(id); + mprFree(fullName); + + /* + * Advance the state + */ + switch (state) { + case EJS_STATE_STMT: + return EJS_STATE_STMT_DONE; + + case EJS_STATE_DEC: + return EJS_STATE_DEC_DONE; + + case EJS_STATE_EXPR: + return EJS_STATE_EXPR_DONE; + + case EJS_STATE_STMT_DONE: + case EJS_STATE_STMT_BLOCK_DONE: + case EJS_STATE_EOF: + case EJS_STATE_RET: + return state; + + default: + return EJS_STATE_ERR; + } + +/* + * Common error exit + */ +error: + state = EJS_STATE_ERR; + goto doneParse; +} + +/******************************************************************************/ +/* + * Parse function arguments + */ + +static int parseArgs(Ejs *ep, int state, int flags) +{ + int tid; + + mprAssert(ep); + + do { + /* + * Peek and see if there are no args + */ + tid = ejsLexGetToken(ep, state); + ejsLexPutbackToken(ep, tid, ep->token); + if (tid == EJS_TOK_RPAREN) { + break; + } + + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state == EJS_STATE_EOF || state == EJS_STATE_ERR) { + return state; + } + if (state == EJS_STATE_RELEXP_DONE) { + if (flags & EJS_FLAGS_EXE) { + mprAssert(ep->proc->args); + mprAddToArray(ep->proc->args, + mprDupVar(&ep->result, MPR_SHALLOW_COPY)); + } + } + /* + * Peek at the next token, continue if more args (ie. comma seen) + */ + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_COMMA) { + ejsLexPutbackToken(ep, tid, ep->token); + } + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_RPAREN && state != EJS_STATE_RELEXP_DONE) { + return EJS_STATE_ERR; + } + return EJS_STATE_ARG_LIST_DONE; +} + +/******************************************************************************/ +/* + * Parse an assignment statement + */ + +static int parseAssignment(Ejs *ep, int state, int flags, char *id, + char *fullName) +{ + MprVar *vp, *saveProperty, *saveObj; + + if (id == 0) { + return -1; + } + + saveObj = ep->currentObj; + saveProperty = ep->currentProperty; + if (ejsParse(ep, EJS_STATE_RELEXP, flags | EJS_FLAGS_ASSIGNMENT) + != EJS_STATE_RELEXP_DONE) { + return -1; + } + ep->currentObj = saveObj; + ep->currentProperty = saveProperty; + + if (! (flags & EJS_FLAGS_EXE)) { + return state; + } + + if (ep->currentProperty) { + /* + * Update the variable. Update the property name if not + * yet defined. + */ + if (ep->currentProperty->name == 0 || + ep->currentProperty->name[0] == '\0') { + mprSetVarName(ep->currentProperty, id); + } + if (mprWriteProperty(ep->currentProperty, &ep->result) < 0){ + ejsError(ep, "Can't write to variable\n"); + return -1; + } + + } else { + /* + * Create the variable + */ + if (ep->currentObj) { + if (ep->currentObj->type != MPR_TYPE_OBJECT) { + if (strcmp(ep->currentObj->name, "session") == 0) { + ejsError(ep, "Variable \"%s\" is not an array or object." + "If using ESP, you need useSession(); in your page.", + ep->currentObj->name); + } else { + ejsError(ep, "Variable \"%s\" is not an array or object", + ep->currentObj->name); + } + return -1; + } + vp = mprCreateProperty(ep->currentObj, id, &ep->result); + + } else { + /* + * Standard says: "var x" means declare locally. + * "x = 2" means declare globally if x is undefined. + */ + if (state == EJS_STATE_DEC) { + vp = mprCreateProperty(ep->local, id, &ep->result); + } else { + vp = mprCreateProperty(ep->global, id, &ep->result); + } + } +#if BLD_DEBUG + mprSetVarFullName(vp, fullName); +#endif + } + return state; +} + +/******************************************************************************/ +/* + * Parse conditional expression (relational ops separated by ||, &&) + */ + +static int parseCond(Ejs *ep, int state, int flags) +{ + MprVar lhs, rhs; + int tid, operator; + + mprAssert(ep); + + mprDestroyVar(&ep->result); + rhs = lhs = mprCreateUndefinedVar(); + operator = 0; + + do { + /* + * Recurse to handle one side of a conditional. Accumulate the + * left hand side and the final result in ep->result. + */ + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state != EJS_STATE_RELEXP_DONE) { + state = EJS_STATE_ERR; + break; + } + + if (operator > 0) { + mprCopyVar(&rhs, &ep->result, MPR_SHALLOW_COPY); + if (evalCond(ep, &lhs, operator, &rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + } + mprCopyVar(&lhs, &ep->result, MPR_SHALLOW_COPY); + + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_LOGICAL) { + operator = (int) *ep->token; + + } else if (tid == EJS_TOK_RPAREN || tid == EJS_TOK_SEMI) { + ejsLexPutbackToken(ep, tid, ep->token); + state = EJS_STATE_COND_DONE; + break; + + } else { + ejsLexPutbackToken(ep, tid, ep->token); + } + tid = (state == EJS_STATE_RELEXP_DONE); + + } while (state == EJS_STATE_RELEXP_DONE); + + mprDestroyVar(&lhs); + mprDestroyVar(&rhs); + return state; +} + +/******************************************************************************/ +/* + * Parse variable declaration list. Declarations can be of the following forms: + * var x; + * var x, y, z; + * var x = 1 + 2 / 3, y = 2 + 4; + * + * We set the variable to NULL if there is no associated assignment. + */ + +static int parseDeclaration(Ejs *ep, int state, int flags) +{ + int tid; + + mprAssert(ep); + + do { + if ((tid = ejsLexGetToken(ep, state)) != EJS_TOK_ID) { + return EJS_STATE_ERR; + } + ejsLexPutbackToken(ep, tid, ep->token); + + /* + * Parse the entire assignment or simple identifier declaration + */ + if (ejsParse(ep, EJS_STATE_DEC, flags) != EJS_STATE_DEC_DONE) { + return EJS_STATE_ERR; + } + + /* + * Peek at the next token, continue if comma seen + */ + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_SEMI) { + return EJS_STATE_DEC_LIST_DONE; + } else if (tid != EJS_TOK_COMMA) { + return EJS_STATE_ERR; + } + } while (tid == EJS_TOK_COMMA); + + if (tid != EJS_TOK_SEMI) { + return EJS_STATE_ERR; + } + return EJS_STATE_DEC_LIST_DONE; +} + +/******************************************************************************/ +/* + * Parse expression (leftHandSide operator rightHandSide) + */ + +static int parseExpr(Ejs *ep, int state, int flags) +{ + MprVar lhs, rhs; + int rel, tid; + + mprAssert(ep); + + mprDestroyVar(&ep->result); + rhs = lhs = mprCreateUndefinedVar(); + rel = 0; + tid = 0; + + do { + /* + * This loop will handle an entire expression list. We call parse + * to evalutate each term which returns the result in ep->result. + */ + if (tid == EJS_TOK_LOGICAL) { + state = ejsParse(ep, EJS_STATE_RELEXP, flags); + if (state != EJS_STATE_RELEXP_DONE) { + state = EJS_STATE_ERR; + break; + } + } else { + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_EXPR && (int) *ep->token == EJS_EXPR_MINUS) { + lhs = mprCreateIntegerVar(0); + rel = (int) *ep->token; + } else { + ejsLexPutbackToken(ep, tid, ep->token); + } + + state = ejsParse(ep, EJS_STATE_EXPR, flags); + if (state != EJS_STATE_EXPR_DONE) { + state = EJS_STATE_ERR; + break; + } + } + + if (rel > 0) { + mprCopyVar(&rhs, &ep->result, MPR_SHALLOW_COPY); + if (tid == EJS_TOK_LOGICAL) { + if (evalCond(ep, &lhs, rel, &rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + } else { + if (evalExpr(ep, &lhs, rel, &rhs) < 0) { + state = EJS_STATE_ERR; + break; + } + } + } + mprCopyVar(&lhs, &ep->result, MPR_SHALLOW_COPY); + + if ((tid = ejsLexGetToken(ep, state)) == EJS_TOK_EXPR || + tid == EJS_TOK_INC_DEC || tid == EJS_TOK_LOGICAL) { + rel = (int) *ep->token; + + } else { + ejsLexPutbackToken(ep, tid, ep->token); + state = EJS_STATE_RELEXP_DONE; + } + + } while (state == EJS_STATE_EXPR_DONE); + + mprDestroyVar(&lhs); + mprDestroyVar(&rhs); + + return state; +} + +/******************************************************************************/ +/* + * Parse the "for ... in" statement. Format for the statement is: + * + * for (var in expr) { + * body; + * } + */ + +static int parseForIn(Ejs *ep, int state, int flags) +{ + EjsInput endScript, bodyScript; + MprVar *iteratorVar, *setVar, *vp, v; + int forFlags, tid; + + mprAssert(ep); + + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_ID) { + return -1; + } + ejsLexPutbackToken(ep, tid, ep->token); + + if (ejsParse(ep, EJS_STATE_EXPR, EJS_FLAGS_FOREACH | EJS_FLAGS_EXE) + != EJS_STATE_EXPR_DONE) { + return -1; + } + if (ep->currentProperty == 0) { + return -1; + } + iteratorVar = ep->currentProperty; + + if (ejsLexGetToken(ep, state) != EJS_TOK_IN) { + return -1; + } + + /* + * Get the set + */ + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_ID) { + return -1; + } + ejsLexPutbackToken(ep, tid, ep->token); + + if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE) { + return -1; + } + if (ep->currentProperty == 0 && flags & EJS_FLAGS_EXE) { + return -1; + } + setVar = ep->currentProperty; + + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + return -1; + } + + /* + * Parse the body and remember the end of the body script + */ + forFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, &bodyScript); + if (ejsParse(ep, EJS_STATE_STMT, forFlags) != EJS_STATE_STMT_DONE) { + ejsLexFreeInputState(ep, &bodyScript); + return -1; + } + ejsInitInputState(&endScript); + ejsLexSaveInputState(ep, &endScript); + + /* + * Now actually do the for loop. + */ + if (flags & EJS_FLAGS_EXE) { + if (setVar->type == MPR_TYPE_OBJECT) { + vp = mprGetFirstProperty(setVar, MPR_ENUM_DATA); + while (vp) { + if (strcmp(vp->name, "length") != 0) { + v = mprCreateStringVar(vp->name, 0); + if (mprWriteProperty(iteratorVar, &v) < 0) { + ejsError(ep, "Can't write to variable\n"); + ejsLexFreeInputState(ep, &bodyScript); + ejsLexFreeInputState(ep, &endScript); + return -1; + } + + ejsLexRestoreInputState(ep, &bodyScript); + switch (ejsParse(ep, EJS_STATE_STMT, flags)) { + case EJS_STATE_RET: + return EJS_STATE_RET; + case EJS_STATE_STMT_DONE: + break; + default: + ejsLexFreeInputState(ep, &endScript); + ejsLexFreeInputState(ep, &bodyScript); + return -1; + } + } + vp = mprGetNextProperty(setVar, vp, MPR_ENUM_DATA); + } + } else { + ejsError(ep, "Variable \"%s\" is not an array or object", + setVar->name); + ejsLexFreeInputState(ep, &endScript); + ejsLexFreeInputState(ep, &bodyScript); + return -1; + } + } + ejsLexRestoreInputState(ep, &endScript); + + ejsLexFreeInputState(ep, &endScript); + ejsLexFreeInputState(ep, &bodyScript); + + return state; +} + +/******************************************************************************/ +/* + * Parse the for statement. Format for the expression is: + * + * for (initial; condition; incr) { + * body; + * } + */ + +static int parseFor(Ejs *ep, int state, int flags) +{ + EjsInput condScript, endScript, bodyScript, incrScript; + int forFlags, cond; + + ejsInitInputState(&endScript); + ejsInitInputState(&bodyScript); + ejsInitInputState(&incrScript); + ejsInitInputState(&condScript); + + mprAssert(ep); + + /* + * Evaluate the for loop initialization statement + */ + if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE) { + return -1; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) { + return -1; + } + + /* + * The first time through, we save the current input context just prior + * to each step: prior to the conditional, the loop increment and + * the loop body. + */ + ejsLexSaveInputState(ep, &condScript); + if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) { + goto error; + } + cond = (ep->result.boolean != 0); + + if (ejsLexGetToken(ep, state) != EJS_TOK_SEMI) { + goto error; + } + + /* + * Don't execute the loop increment statement or the body + * first time. + */ + forFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, &incrScript); + if (ejsParse(ep, EJS_STATE_EXPR, forFlags) != EJS_STATE_EXPR_DONE) { + goto error; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + goto error; + } + + /* + * Parse the body and remember the end of the body script + */ + ejsLexSaveInputState(ep, &bodyScript); + if (ejsParse(ep, EJS_STATE_STMT, forFlags) != EJS_STATE_STMT_DONE) { + goto error; + } + ejsLexSaveInputState(ep, &endScript); + + /* + * Now actually do the for loop. Note loop has been rotated + */ + while (cond && (flags & EJS_FLAGS_EXE)) { + /* + * Evaluate the body + */ + ejsLexRestoreInputState(ep, &bodyScript); + + switch (ejsParse(ep, EJS_STATE_STMT, flags)) { + case EJS_STATE_RET: + return EJS_STATE_RET; + case EJS_STATE_STMT_DONE: + break; + default: + goto error; + } + /* + * Evaluate the increment script + */ + ejsLexRestoreInputState(ep, &incrScript); + if (ejsParse(ep, EJS_STATE_EXPR, flags) != EJS_STATE_EXPR_DONE){ + goto error; + } + /* + * Evaluate the condition + */ + ejsLexRestoreInputState(ep, &condScript); + if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) { + goto error; + } + mprAssert(ep->result.type == MPR_TYPE_BOOL); + cond = (ep->result.boolean != 0); + } + + ejsLexRestoreInputState(ep, &endScript); + +done: + ejsLexFreeInputState(ep, &condScript); + ejsLexFreeInputState(ep, &incrScript); + ejsLexFreeInputState(ep, &endScript); + ejsLexFreeInputState(ep, &bodyScript); + return state; + +error: + state = EJS_STATE_ERR; + goto done; +} + +/******************************************************************************/ +/* + * Parse a function declaration + */ + +static int parseFunctionDec(Ejs *ep, int state, int flags) +{ + EjsInput endScript, bodyScript; + MprVar v, *currentObj, *vp; + char *procName; + int len, tid, bodyFlags; + + mprAssert(ep); + mprAssert(ejsPtr(ep->eid)); + + /* + * function <name>(arg, arg, arg) { body }; + * function name(arg, arg, arg) { body }; + */ + + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_ID) { + procName = mprStrdup(ep->token); + tid = ejsLexGetToken(ep, state); + } else { + procName = 0; + } + if (tid != EJS_TOK_LPAREN) { + mprFree(procName); + return EJS_STATE_ERR; + } + + /* + * Hand craft the function value structure. + */ + v = mprCreateFunctionVar(0, 0, 0); + tid = ejsLexGetToken(ep, state); + while (tid == EJS_TOK_ID) { + mprAddToArray(v.function.args, mprStrdup(ep->token)); + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_RPAREN || tid != EJS_TOK_COMMA) { + break; + } + tid = ejsLexGetToken(ep, state); + } + if (tid != EJS_TOK_RPAREN) { + mprFree(procName); + mprDestroyVar(&v); + return EJS_STATE_ERR; + } + + /* Allow new lines before opening brace */ + do { + tid = ejsLexGetToken(ep, state); + } while (tid == EJS_TOK_NEWLINE); + + if (tid != EJS_TOK_LBRACE) { + mprFree(procName); + mprDestroyVar(&v); + return EJS_STATE_ERR; + } + + /* + * Parse the function body. Turn execute off. + */ + bodyFlags = flags & ~EJS_FLAGS_EXE; + ejsLexSaveInputState(ep, &bodyScript); + + do { + state = ejsParse(ep, EJS_STATE_STMT, bodyFlags); + } while (state == EJS_STATE_STMT_DONE); + + tid = ejsLexGetToken(ep, state); + if (state != EJS_STATE_STMT_BLOCK_DONE || tid != EJS_TOK_RBRACE) { + mprFree(procName); + mprDestroyVar(&v); + ejsLexFreeInputState(ep, &bodyScript); + return EJS_STATE_ERR; + } + ejsLexSaveInputState(ep, &endScript); + + /* + * Save the function body between the starting and ending parse positions. + * Overwrite the trailing '}' with a null. + */ + len = endScript.scriptServp - bodyScript.scriptServp; + v.function.body = mprMalloc(len + 1); + memcpy(v.function.body, bodyScript.scriptServp, len); + + if (len <= 0) { + v.function.body[0] = '\0'; + } else { + v.function.body[len - 1] = '\0'; + } + ejsLexFreeInputState(ep, &bodyScript); + ejsLexFreeInputState(ep, &endScript); + + /* + * If we are in an assignment, don't register the function name, rather + * return the function structure in the parser result. + */ + if (flags & EJS_FLAGS_ASSIGNMENT) { + mprCopyVar(&ep->result, &v, MPR_SHALLOW_COPY); + } else { + currentObj = ejsFindObj(ep, 0, procName, flags); + vp = mprSetProperty(currentObj, procName, &v); + } + + mprFree(procName); + mprDestroyVar(&v); + + return EJS_STATE_STMT; +} + +/******************************************************************************/ +/* + * Parse a function name and invoke the function + */ + +static int parseFunction(Ejs *ep, int state, int flags, char *id) +{ + EjsProc proc, *saveProc; + MprVar *saveObj; + + /* + * Must save any current ep->proc value for the current stack frame + * to allow for recursive function calls. + */ + saveProc = (ep->proc) ? ep->proc: 0; + + memset(&proc, 0, sizeof(EjsProc)); + proc.procName = mprStrdup(id); + proc.fn = ep->currentProperty; + proc.args = mprCreateArray(); + ep->proc = &proc; + + mprDestroyVar(&ep->result); + + saveObj = ep->currentObj; + if (ejsParse(ep, EJS_STATE_ARG_LIST, flags) != EJS_STATE_ARG_LIST_DONE) { + freeProc(&proc); + ep->proc = saveProc; + return -1; + } + ep->currentObj = saveObj; + + /* + * Evaluate the function if required + */ + if (flags & EJS_FLAGS_EXE) { + if (evalFunction(ep, ep->currentObj, flags) < 0) { + freeProc(&proc); + ep->proc = saveProc; + return -1; + } + } + + freeProc(&proc); + ep->proc = saveProc; + + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + return -1; + } + return state; +} + +/******************************************************************************/ +/* + * Parse an identifier. This is a segment of a fully qualified variable. + * May come here for an initial identifier or for property names + * after a "." or "[...]". + */ + +static int parseId(Ejs *ep, int state, int flags, char **id, char **fullName, + int *fullNameLen, int *done) +{ + int tid; + + mprFree(*id); + *id = mprStrdup(ep->token); +#if BLD_DEBUG + *fullNameLen = mprReallocStrcat(fullName, MPR_MAX_VAR, *fullNameLen, + 0, *id, 0); +#endif + if (ep->currentObj == 0) { + ep->currentObj = ejsFindObj(ep, state, *id, flags); + } + + /* + * Find the referenced variable and store it in currentProperty. + */ + ep->currentProperty = ejsFindProperty(ep, state, ep->currentObj, + *id, flags); + updateResult(ep, state, flags, ep->currentProperty); + +#if BLD_DEBUG + if (ep->currentProperty && (ep->currentProperty->name == 0 || + ep->currentProperty->name[0] == '\0')) { + mprSetVarName(ep->currentProperty, *id); + } +#endif + + tid = ejsLexGetToken(ep, state); + if (tid == EJS_TOK_LPAREN) { + if (ep->currentProperty == 0) { + ejsError(ep, "Function name not defined \"%s\"\n", *id); + return -1; + } + ejsLexPutbackToken(ep, EJS_TOK_FUNCTION_NAME, ep->token); + return state; + } + + if (tid == EJS_TOK_PERIOD || tid == EJS_TOK_LBRACKET || + tid == EJS_TOK_ASSIGNMENT || tid == EJS_TOK_INC_DEC) { + ejsLexPutbackToken(ep, tid, ep->token); + return state; + } + + /* + * Only come here for variable access and declarations. + * Assignment handled elsewhere. + */ + if (flags & EJS_FLAGS_EXE) { + if (state == EJS_STATE_DEC) { + /* + * Declare a variable. Standard allows: var x ; var x ; + */ +#if DISABLED + if (ep->currentProperty != 0) { + ejsError(ep, "Variable already defined \"%s\"\n", *id); + return -1; + } +#endif + /* + * Create or overwrite if it already exists + */ + mprSetPropertyValue(ep->currentObj, *id, + mprCreateUndefinedVar()); + ep->currentProperty = 0; + mprDestroyVar(&ep->result); + + } else if (flags & EJS_FLAGS_FOREACH) { + if (ep->currentProperty == 0) { + ep->currentProperty = + mprCreatePropertyValue(ep->currentObj, *id, + mprCreateUndefinedVar()); + } + + } else { + if (ep->currentProperty == 0) { + if (ep->currentObj == ep->global || + ep->currentObj == ep->local) { + ejsError(ep, "Undefined variable \"%s\"\n", *id); + return -1; + } + ep->currentProperty = mprCreatePropertyValue(ep->currentObj, + *id, mprCreateUndefinedVar()); + } + } + } + ejsLexPutbackToken(ep, tid, ep->token); + if (tid == EJS_TOK_RBRACKET || tid == EJS_TOK_COMMA || + tid == EJS_TOK_IN) { + *done = 1; + } + return state; +} + +/******************************************************************************/ +/* + * Parse an "if" statement + */ + +static int parseIf(Ejs *ep, int state, int flags, int *done) +{ + bool ifResult; + int thenFlags, elseFlags, tid; + + if (state != EJS_STATE_STMT) { + return -1; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_LPAREN) { + return -1; + } + + /* + * Evaluate the entire condition list "(condition)" + */ + if (ejsParse(ep, EJS_STATE_COND, flags) != EJS_STATE_COND_DONE) { + return -1; + } + if (ejsLexGetToken(ep, state) != EJS_TOK_RPAREN) { + return -1; + } + + /* + * This is the "then" case. We need to always parse both cases and + * execute only the relevant case. + */ + ifResult = mprVarToBool(&ep->result); + if (ifResult) { + thenFlags = flags; + elseFlags = flags & ~EJS_FLAGS_EXE; + } else { + thenFlags = flags & ~EJS_FLAGS_EXE; + elseFlags = flags; + } + + /* + * Process the "then" case. + */ + switch (ejsParse(ep, EJS_STATE_STMT, thenFlags)) { + case EJS_STATE_RET: + state = EJS_STATE_RET; + return state; + case EJS_STATE_STMT_DONE: + break; + default: + return -1; + } + + /* + * Check to see if there is an "else" case + */ + removeNewlines(ep, state); + tid = ejsLexGetToken(ep, state); + if (tid != EJS_TOK_ELSE) { + ejsLexPutbackToken(ep, tid, ep->token); + *done = 1; + return state; + } + + /* + * Process the "else" case. + */ + switch (ejsParse(ep, EJS_STATE_STMT, elseFlags)) { + case EJS_STATE_RET: + state = EJS_STATE_RET; + return state; + case EJS_STATE_STMT_DONE: + break; + default: + return -1; + } + *done = 1; + return state; +} + +/******************************************************************************/ +/* + * Parse an "++" or "--" statement + */ + +static int parseInc(Ejs *ep, int state, int flags) +{ + MprVar one; + + if (! (flags & EJS_FLAGS_EXE)) { + return state; + } + + if (ep->currentProperty == 0) { + ejsError(ep, "Undefined variable \"%s\"\n", ep->token); + return -1; + } + one = mprCreateIntegerVar(1); + if (evalExpr(ep, ep->currentProperty, (int) *ep->token, + &one) < 0) { + return -1; + } + if (mprWriteProperty(ep->currentProperty, &ep->result) < 0) { + ejsError(ep, "Can't write to variable\n"); + return -1; + } + return state; +} + +/******************************************************************************/ +/* + * Evaluate a condition. Implements &&, ||, !. Returns with a boolean result + * in ep->result. Returns -1 on errors, zero if successful. + */ + +static int evalCond(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs) +{ + bool l, r, lval; + + mprAssert(rel > 0); + + l = mprVarToBool(lhs); + r = mprVarToBool(rhs); + + switch (rel) { + case EJS_COND_AND: + lval = l && r; + break; + case EJS_COND_OR: + lval = l || r; + break; + default: + ejsError(ep, "Bad operator %d", rel); + return -1; + } + + mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0); + return 0; +} + +/******************************************************************************/ +/* + * Evaluate an operation. Returns with the result in ep->result. Returns -1 + * on errors, otherwise zero is returned. + */ + +static int evalExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs) +{ + char *str; + MprNum lval, num; + int rc; + + mprAssert(rel > 0); + str = 0; + lval = 0; + + /* + * Type conversion. This is tricky and must be according to the standard. + * Only numbers (including floats) and strings can be compared. All other + * types are first converted to numbers by preference and if that fails, + * to strings. + * + * First convert objects to comparable types. The "===" operator will + * test the sameness of object references. Here, we coerce to comparable + * types first. + */ + if (lhs->type == MPR_TYPE_OBJECT) { + if (ejsRunFunction(ep->eid, lhs, "toValue", 0) == 0) { + mprCopyVar(lhs, &ep->result, MPR_SHALLOW_COPY); + } else { + if (ejsRunFunction(ep->eid, lhs, "toString", 0) == 0) { + mprCopyVar(lhs, &ep->result, MPR_SHALLOW_COPY); + } + } + /* Nothing more can be done */ + } + + if (rhs->type == MPR_TYPE_OBJECT) { + if (ejsRunFunction(ep->eid, rhs, "toValue", 0) == 0) { + mprCopyVar(rhs, &ep->result, MPR_SHALLOW_COPY); + } else { + if (ejsRunFunction(ep->eid, rhs, "toString", 0) == 0) { + mprCopyVar(rhs, &ep->result, MPR_SHALLOW_COPY); + } + } + /* Nothing more can be done */ + } + + /* + * From here on, lhs and rhs may contain allocated data (strings), so + * we must always destroy before overwriting. + */ + + /* + * Only allow a few bool operations. Otherwise convert to number. + */ + if (lhs->type == MPR_TYPE_BOOL && rhs->type == MPR_TYPE_BOOL && + (rel != EJS_EXPR_EQ && rel != EJS_EXPR_NOTEQ && + rel != EJS_EXPR_BOOL_COMP)) { + num = mprVarToNumber(lhs); + mprDestroyVar(lhs); + *lhs = mprCreateNumberVar(num); + } + + /* + * Types do not match, so try to coerce the right operand to match the left + * But first, try to convert a left operand that is a numeric stored as a + * string, into a numeric. + */ + if (lhs->type != rhs->type) { + if (lhs->type == MPR_TYPE_STRING) { + if (isdigit((int) lhs->string[0])) { + num = mprVarToNumber(lhs); + mprDestroyVar(lhs); + *lhs = mprCreateNumberVar(num); + /* Examine further below */ + + } else { + /* + * Convert the RHS to a string + */ + mprVarToString(&str, MPR_MAX_STRING, 0, rhs); + mprDestroyVar(rhs); + *rhs = mprCreateStringVar(str, 1); + mprFree(str); + } + +#if BLD_FEATURE_FLOATING_POINT + } else if (lhs->type == MPR_TYPE_FLOAT) { + /* + * Convert rhs to floating + */ + double f = mprVarToFloat(rhs); + mprDestroyVar(rhs); + *rhs = mprCreateFloatVar(f); + +#endif +#if BLD_FEATURE_INT64 + } else if (lhs->type == MPR_TYPE_INT64) { + /* + * Convert the rhs to 64 bit + */ + int64 n = mprVarToInteger64(rhs); + mprDestroyVar(rhs); + *rhs = mprCreateInteger64Var(n); +#endif + } else if (lhs->type == MPR_TYPE_BOOL || lhs->type == MPR_TYPE_INT) { + + if (rhs->type == MPR_TYPE_STRING) { + /* + * Convert to lhs to a string + */ + mprVarToString(&str, MPR_MAX_STRING, 0, lhs); + mprDestroyVar(lhs); + *lhs = mprCreateStringVar(str, 1); + mprFree(str); + +#if BLD_FEATURE_FLOATING_POINT + } else if (rhs->type == MPR_TYPE_FLOAT) { + /* + * Convert lhs to floating + */ + double f = mprVarToFloat(lhs); + mprDestroyVar(lhs); + *lhs = mprCreateFloatVar(f); +#endif + + } else { + /* + * Convert both operands to numbers + */ + num = mprVarToNumber(lhs); + mprDestroyVar(lhs); + *lhs = mprCreateNumberVar(num); + + num = mprVarToNumber(rhs); + mprDestroyVar(rhs); + *rhs = mprCreateNumberVar(num); + } + } + } + + /* + * We have failed to coerce the types to be the same. Special case here + * for undefined and null. We need to allow comparisions against these + * special values. + */ + if (lhs->type == MPR_TYPE_UNDEFINED || lhs->type == MPR_TYPE_NULL) { + switch (rel) { + case EJS_EXPR_EQ: + lval = lhs->type == rhs->type; + break; + case EJS_EXPR_NOTEQ: + lval = lhs->type != rhs->type; + break; + default: + lval = 0; + } + mprCopyVarValue(&ep->result, mprCreateBoolVar((bool) lval), 0); + return 0; + } + + /* + * Types are the same here + */ + switch (lhs->type) { + default: + case MPR_TYPE_UNDEFINED: + case MPR_TYPE_NULL: + /* Should be handled above */ + mprAssert(0); + return 0; + + case MPR_TYPE_STRING_CFUNCTION: + case MPR_TYPE_CFUNCTION: + case MPR_TYPE_FUNCTION: + case MPR_TYPE_OBJECT: + mprCopyVarValue(&ep->result, mprCreateBoolVar(0), 0); + return 0; + + case MPR_TYPE_BOOL: + rc = evalBoolExpr(ep, lhs->boolean, rel, rhs->boolean); + break; + +#if BLD_FEATURE_FLOATING_POINT + case MPR_TYPE_FLOAT: + rc = evalFloatExpr(ep, lhs->floating, rel, rhs->floating); + break; +#endif + + case MPR_TYPE_INT: + rc = evalNumericExpr(ep, (MprNum) lhs->integer, rel, + (MprNum) rhs->integer); + break; + +#if BLD_FEATURE_INT64 + case MPR_TYPE_INT64: + rc = evalNumericExpr(ep, (MprNum) lhs->integer64, rel, + (MprNum) rhs->integer64); + break; +#endif + + case MPR_TYPE_STRING: + rc = evalStringExpr(ep, lhs, rel, rhs); + } + return rc; +} + +/******************************************************************************/ +#if BLD_FEATURE_FLOATING_POINT +/* + * Expressions with floating operands + */ + +static int evalFloatExpr(Ejs *ep, double l, int rel, double r) +{ + double lval; + bool logical; + + lval = 0; + logical = 0; + + switch (rel) { + case EJS_EXPR_PLUS: + lval = l + r; + break; + case EJS_EXPR_INC: + lval = l + 1; + break; + case EJS_EXPR_MINUS: + lval = l - r; + break; + case EJS_EXPR_DEC: + lval = l - 1; + break; + case EJS_EXPR_MUL: + lval = l * r; + break; + case EJS_EXPR_DIV: + lval = l / r; + break; + default: + logical++; + break; + } + + /* + * Logical operators + */ + if (logical) { + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_LESS: + lval = (l < r) ? 1 : 0; + break; + case EJS_EXPR_LESSEQ: + lval = (l <= r) ? 1 : 0; + break; + case EJS_EXPR_GREATER: + lval = (l > r) ? 1 : 0; + break; + case EJS_EXPR_GREATEREQ: + lval = (l >= r) ? 1 : 0; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, "Bad operator %d", rel); + return -1; + } + mprCopyVarValue(&ep->result, mprCreateBoolVar(lval != 0), 0); + + } else { + mprCopyVarValue(&ep->result, mprCreateFloatVar(lval), 0); + } + return 0; +} + +#endif /* BLD_FEATURE_FLOATING_POINT */ +/******************************************************************************/ +/* + * Expressions with boolean operands + */ + +static int evalBoolExpr(Ejs *ep, bool l, int rel, bool r) +{ + bool lval; + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, "Bad operator %d", rel); + return -1; + } + mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0); + return 0; +} + +/******************************************************************************/ +/* + * Expressions with numeric operands + */ + +static int evalNumericExpr(Ejs *ep, MprNum l, int rel, MprNum r) +{ + MprNum lval; + bool logical; + + lval = 0; + logical = 0; + + switch (rel) { + case EJS_EXPR_PLUS: + lval = l + r; + break; + case EJS_EXPR_INC: + lval = l + 1; + break; + case EJS_EXPR_MINUS: + lval = l - r; + break; + case EJS_EXPR_DEC: + lval = l - 1; + break; + case EJS_EXPR_MUL: + lval = l * r; + break; + case EJS_EXPR_DIV: + if (r != 0) { + lval = l / r; + } else { + ejsError(ep, "Divide by zero"); + return -1; + } + break; + case EJS_EXPR_MOD: + if (r != 0) { + lval = l % r; + } else { + ejsError(ep, "Modulo zero"); + return -1; + } + break; + case EJS_EXPR_LSHIFT: + lval = l << r; + break; + case EJS_EXPR_RSHIFT: + lval = l >> r; + break; + + default: + logical++; + break; + } + + /* + * Logical operators + */ + if (logical) { + + switch (rel) { + case EJS_EXPR_EQ: + lval = l == r; + break; + case EJS_EXPR_NOTEQ: + lval = l != r; + break; + case EJS_EXPR_LESS: + lval = (l < r) ? 1 : 0; + break; + case EJS_EXPR_LESSEQ: + lval = (l <= r) ? 1 : 0; + break; + case EJS_EXPR_GREATER: + lval = (l > r) ? 1 : 0; + break; + case EJS_EXPR_GREATEREQ: + lval = (l >= r) ? 1 : 0; + break; + case EJS_EXPR_BOOL_COMP: + lval = (r == 0) ? 1 : 0; + break; + default: + ejsError(ep, "Bad operator %d", rel); + return -1; + } + mprCopyVarValue(&ep->result, mprCreateBoolVar(lval != 0), 0); + + } else { + mprCopyVarValue(&ep->result, mprCreateNumberVar(lval), 0); + } + return 0; +} + +/******************************************************************************/ +/* + * Expressions with string operands + */ + +static int evalStringExpr(Ejs *ep, MprVar *lhs, int rel, MprVar *rhs) +{ + int lval; + + mprAssert(ep); + mprAssert(lhs); + mprAssert(rhs); + + switch (rel) { + case EJS_EXPR_LESS: + lval = strcmp(lhs->string, rhs->string) < 0; + break; + case EJS_EXPR_LESSEQ: + lval = strcmp(lhs->string, rhs->string) <= 0; + break; + case EJS_EXPR_GREATER: + lval = strcmp(lhs->string, rhs->string) > 0; + break; + case EJS_EXPR_GREATEREQ: + lval = strcmp(lhs->string, rhs->string) >= 0; + break; + case EJS_EXPR_EQ: + lval = strcmp(lhs->string, rhs->string) == 0; + break; + case EJS_EXPR_NOTEQ: + lval = strcmp(lhs->string, rhs->string) != 0; + break; + case EJS_EXPR_PLUS: + /* + * This differs from all the above operations. We append rhs to lhs. + */ + mprDestroyVar(&ep->result); + appendValue(&ep->result, lhs); + appendValue(&ep->result, rhs); + return 0; + + case EJS_EXPR_INC: + case EJS_EXPR_DEC: + case EJS_EXPR_MINUS: + case EJS_EXPR_DIV: + case EJS_EXPR_MOD: + case EJS_EXPR_LSHIFT: + case EJS_EXPR_RSHIFT: + default: + ejsError(ep, "Bad operator"); + return -1; + } + + mprCopyVarValue(&ep->result, mprCreateBoolVar(lval), 0); + return 0; +} + +/******************************************************************************/ +/* + * Evaluate a function. obj is set to the current object if a function is being + * run. + */ + +static int evalFunction(Ejs *ep, MprVar *obj, int flags) +{ + EjsProc *proc; + MprVar arguments, callee, thisObject, *prototype, **argValues; + MprArray *formalArgs, *actualArgs; + char buf[16], **argNames, **argBuf; + int i, rc, fid; + + mprAssert(ep); + mprAssert(ejsPtr(ep->eid)); + + rc = -1; + proc = ep->proc; + prototype = proc->fn; + actualArgs = proc->args; + argValues = (MprVar**) actualArgs->handles; + + /* + * Create a new variable stack frame. ie. new local variables. + */ + fid = ejsOpenBlock(ep->eid); + + if (flags & EJS_FLAGS_NEW) { + /* + * Create a new bare object and pass it into the constructor as the + * "this" local variable. + */ + thisObject = ejsCreateObj("this", EJS_OBJ_HASH_SIZE); + mprCreatePropertyValue(ep->local, "this", thisObject); + + } else if (obj) { + mprCreateProperty(ep->local, "this", obj); + } + + switch (prototype->type) { + default: + mprAssert(0); + break; + + case MPR_TYPE_STRING_CFUNCTION: + if (actualArgs->used > 0) { + argBuf = mprMalloc(actualArgs->used * sizeof(char*)); + for (i = 0; i < actualArgs->used; i++) { + mprVarToString(&argBuf[i], MPR_MAX_STRING, 0, argValues[i]); + } + } else { + argBuf = 0; + } + + /* + * Call the function depending on the various handle flags + */ + ep->thisPtr = prototype->cFunctionWithStrings.thisPtr; + if (prototype->flags & MPR_VAR_ALT_HANDLE) { + rc = ((EjsAltStringCFunction) prototype->cFunctionWithStrings.fn) + (ep->eid, ep->altHandle, actualArgs->used, argBuf); + } else if (prototype->flags & MPR_VAR_SCRIPT_HANDLE) { + rc = (prototype->cFunctionWithStrings.fn)(ep->eid, + actualArgs->used, argBuf); + } else { + rc = (prototype->cFunctionWithStrings.fn)(ep->primaryHandle, + actualArgs->used, argBuf); + } + + if (actualArgs->used > 0) { + for (i = 0; i < actualArgs->used; i++) { + mprFree(argBuf[i]); + } + mprFree(argBuf); + } + ep->thisPtr = 0; + break; + + case MPR_TYPE_CFUNCTION: + /* + * Call the function depending on the various handle flags + */ + ep->thisPtr = prototype->cFunction.thisPtr; + if (prototype->flags & MPR_VAR_ALT_HANDLE) { + rc = ((EjsAltCFunction) prototype->cFunction.fn) + (ep->eid, ep->altHandle, actualArgs->used, argValues); + } else if (prototype->flags & MPR_VAR_SCRIPT_HANDLE) { + rc = (prototype->cFunction.fn)(ep->eid, actualArgs->used, + argValues); + } else { + rc = (prototype->cFunction.fn)(ep->primaryHandle, + actualArgs->used, argValues); + } + ep->thisPtr = 0; + break; + + case MPR_TYPE_FUNCTION: + + formalArgs = prototype->function.args; + argNames = (char**) formalArgs->handles; + +#if FUTURE + if (formalArgs->used != actualArgs->used) { + ejsError(ep, "Bad number of args. Should be %d", formalArgs->used); + return -1; + } +#endif + + /* + * Create the arguments and callee variables + */ + arguments = ejsCreateObj("arguments", EJS_SMALL_OBJ_HASH_SIZE); + callee = ejsCreateObj("callee", EJS_SMALL_OBJ_HASH_SIZE); + + /* + * Overwrite the length property + */ + mprCreatePropertyValue(&arguments, "length", + mprCreateIntegerVar(actualArgs->used)); + mprCreatePropertyValue(&callee, "length", + mprCreateIntegerVar(formalArgs->used)); + + /* + * Define all the agruments to be set to the actual parameters + */ + for (i = 0; i < formalArgs->used; i++) { + mprCreateProperty(ep->local, argNames[i], argValues[i]); + mprItoa(i, buf, sizeof(buf)); + mprCreateProperty(&arguments, buf, argValues[i]); + } + + mprCreateProperty(&arguments, "callee", &callee); + mprCreateProperty(ep->local, "arguments", &arguments); + + /* + * Can destroy our variables here as they are now referenced via + * "local" + */ + mprDestroyVar(&callee); + mprDestroyVar(&arguments); + + /* + * Actually run the function + */ + rc = ejsEvalScript(ep->eid, prototype->function.body, 0, 0); + break; + } + + ejsCloseBlock(ep->eid, fid); + + /* + * New statements return the newly created object as the result of the + * command + */ + if (flags & EJS_FLAGS_NEW) { + mprDestroyVar(&ep->result); + /* + * Don't copy, we want to assign the actual object into result. + * (mprCopyVar would inc the refCount to 2). + */ + ep->result = thisObject; + } + return rc; +} + +/******************************************************************************/ +/* + * Run a function + */ + +int ejsRunFunction(int eid, MprVar *obj, const char *functionName, MprArray *args) +{ + EjsProc proc, *saveProc; + Ejs *ep; + int rc; + + mprAssert(obj); + mprAssert(functionName && *functionName); + + if ((ep = ejsPtr(eid)) == NULL) { + mprAssert(ep); + return MPR_ERR_NOT_FOUND; + } + saveProc = ep->proc; + ep->proc = &proc; + + memset(&proc, 0, sizeof(EjsProc)); + mprDestroyVar(&ep->result); + + proc.fn = mprGetProperty(obj, functionName, 0); + if (proc.fn == 0 || proc.fn->type == MPR_TYPE_UNDEFINED) { + ep->proc = saveProc; + return MPR_ERR_NOT_FOUND; + } + proc.procName = mprStrdup(functionName); + if (args == 0) { + proc.args = mprCreateArray(); + rc = evalFunction(ep, obj, 0); + } else { + proc.args = args; + rc = evalFunction(ep, obj, 0); + proc.args = 0; + } + + freeProc(&proc); + ep->proc = saveProc; + + return rc; +} + +/******************************************************************************/ +/* + * Find which object contains the property given the current context. + * Only used for top level properties. + */ + +MprVar *ejsFindObj(Ejs *ep, int state, const char *property, int flags) +{ + MprVar *vp; + MprVar *obj; + + mprAssert(ep); + mprAssert(property && *property); + + if (flags & EJS_FLAGS_GLOBAL) { + obj = ep->global; + + } else if (state == EJS_STATE_DEC || flags & EJS_FLAGS_LOCAL) { + obj = ep->local; + + } else { + /* First look local, then look global */ + vp = mprGetProperty(ep->local, property, 0); + if (vp) { + obj = ep->local; + } else if (mprGetProperty(ep->local, property, 0)) { + obj = ep->local; + } else { + obj = ep->global; + } + } + return obj; +} + +/******************************************************************************/ +/* + * Find an object property given a object and a property name. We + * intelligently look in the local and global namespaces depending on + * our state. If not found in local or global, try base classes for function + * names only. Returns the property or NULL. + */ + +MprVar *ejsFindProperty(Ejs *ep, int state, MprVar *obj, char *property, + int flags) +{ + MprVar *vp; + + mprAssert(ep); + if (flags & EJS_FLAGS_EXE) { + mprAssert(property && *property); + } + + if (obj != 0) { +#if FUTURE && MB + op = obj; + do { + vp = mprGetProperty(op, property, 0); + if (vp != 0) { + if (op != obj && mprVarIsFunction(vp->type)) { + } + break; + } + op = op->baseObj; + } while (op); +#endif + vp = mprGetProperty(obj, property, 0); + + } else { + if (state == EJS_STATE_DEC) { + vp = mprGetProperty(ep->local, property, 0); + + } else { + /* Look local first, then global */ + vp = mprGetProperty(ep->local, property, 0); + if (vp == NULL) { + vp = mprGetProperty(ep->global, property, 0); + } + } + } + return vp; +} + +/******************************************************************************/ +/* + * Update result + */ + +static void updateResult(Ejs *ep, int state, int flags, MprVar *vp) +{ + if (flags & EJS_FLAGS_EXE && state != EJS_STATE_DEC) { + mprDestroyVar(&ep->result); + if (vp) { + mprCopyProperty(&ep->result, vp, MPR_SHALLOW_COPY); + } + } +} + +/******************************************************************************/ +/* + * Append to the pointer value + */ + +static void appendValue(MprVar *dest, MprVar *src) +{ + char *value, *oldBuf, *buf; + int len, oldLen; + + mprAssert(dest); + + mprVarToString(&value, MPR_MAX_STRING, 0, src); + + if (mprVarIsValid(dest)) { + len = strlen(value); + oldBuf = dest->string; + oldLen = strlen(oldBuf); + buf = mprRealloc(oldBuf, (len + oldLen + 1) * sizeof(char)); + dest->string = buf; + strncpy(&buf[oldLen], value, len+1); + } else { + *dest = mprCreateStringVar(value, 1); + } + mprFree(value); +} + +/******************************************************************************/ +/* + * Exit with status + */ + +void ejsSetExitStatus(int eid, int status) +{ + Ejs *ep; + + if ((ep = ejsPtr(eid)) == NULL) { + mprAssert(ep); + return; + } + ep->exitStatus = status; + ep->flags |= EJS_FLAGS_EXIT; +} + +/******************************************************************************/ +/* + * Free an argument list + */ + +static void freeProc(EjsProc *proc) +{ + MprVar **argValues; + int i; + + if (proc->args) { + argValues = (MprVar**) proc->args->handles; + + for (i = 0; i < proc->args->max; i++) { + if (argValues[i]) { + mprDestroyVar(argValues[i]); + mprFree(argValues[i]); + mprRemoveFromArray(proc->args, i); + } + } + + mprDestroyArray(proc->args); + } + + if (proc->procName) { + mprFree(proc->procName); + proc->procName = NULL; + } +} + +/******************************************************************************/ +/* + * This function removes any new lines. Used for else cases, etc. + */ + +static void removeNewlines(Ejs *ep, int state) +{ + int tid; + + do { + tid = ejsLexGetToken(ep, state); + } while (tid == EJS_TOK_NEWLINE); + + ejsLexPutbackToken(ep, tid, ep->token); +} + +/******************************************************************************/ + +#else +void ejsParserDummy() {} + +/******************************************************************************/ +#endif /* BLD_FEATURE_EJS */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim:tw=78 + * vim600: sw=4 ts=4 fdm=marker + * vim<600: sw=4 ts=4 + */ |