r6981: first version of the builtin web server for Samba4

This includes an embedded server side scripting system called 'esp'
(see http://www.appwebserver.org/products/esp/esp.html) and javascript
based scripting language called 'esj' (see
http://www.appwebserver.org/products/ejs/ejs.html)

The justification for including this scripting language is that it
should make it much easier to write a high quality web interface for
Samba4. The scripting language can call into any Samba4 library code
(so for example it will be able to make ldb and loadparm calls), plus
it provides easy support for forms, cookies, sessions etc.

There is still quite a bit more work to do on the web server, but
there is enough here now for people to look at and comment. I will be
committing some sample web pages that test esp functionality shortly.
(This used to be commit 26f0ba92c0c565ac9e4cb5a079d795d4262497dd)

1 files changed, 2358 insertions, 0 deletions

diff --git a/source4/web_server/ejs/ejsParser.c b/source4/web_server/ejs/ejsParser.c
new file mode 100644
index 0000000000..a7d27fb0c9
--- /dev/null
+++ b/source4/web_server/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	"web_server/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
+ */