void espDestroyRequest(EspRequest *ep)
{
mprAssert(ep);
mprAssert(ep->eid >= 0);
mprFree(ep->uri);
mprFree(ep->docPath);
mprDestroyVar(&ep->variables[ESP_GLOBAL_OBJ]);
mprDestroyVar(&ep->variables[ESP_LOCAL_OBJ]);
ejsCloseEngine(ep->eid);
mprFree(ep);
}
/*
set a mpr component, allowing for sub objects, using the '.' convention
destroys 'val' after setting
*/
NTSTATUS mprSetVar(struct MprVar *v, const char *name, struct MprVar val)
{
const char *p = strchr(name, '.');
char *objname;
struct MprVar *v2;
NTSTATUS status;
if (p == NULL) {
v2 = mprSetProperty(v, name, &val);
if (v2 == NULL) {
DEBUG(1,("mprSetVar unable to set '%s'\n", name));
return NT_STATUS_INVALID_PARAMETER_MIX;
}
mprDestroyVar(&val);
return NT_STATUS_OK;
}
objname = talloc_strndup(mprMemCtx(), name, p-name);
if (objname == NULL) {
return NT_STATUS_NO_MEMORY;
}
v2 = mprGetProperty(v, objname, NULL);
if (v2 == NULL) {
mprSetVar(v, objname, mprObject(objname));
v2 = mprGetProperty(v, objname, NULL);
}
status = mprSetVar(v2, p+1, val);
talloc_free(objname);
return status;
}
/*
set the return value then free the variable
*/
void mpr_Return(int eid, struct MprVar v)
{
ejsSetReturnValue(eid, v);
mprDestroyVar(&v);
}
static int getLexicalToken(Ejs *ep, int state)
{
MprType type;
EjsInput *ip;
int done, tid, c, quote, style, idx;
mprAssert(ep);
ip = ep->input;
mprAssert(ip);
ep->tid = -1;
tid = -1;
type = BLD_FEATURE_NUM_TYPE_ID;
/*
* Use a putback tokens first. Don't free strings as caller needs access.
*/
if (ip->putBackIndex >= 0) {
idx = ip->putBackIndex;
tid = ip->putBack[idx].id;
ep->token = (char*) ip->putBack[idx].token;
tid = checkReservedWord(ep, state, 0, tid);
ip->putBackIndex--;
return tid;
}
ep->token = ip->tokServp = ip->tokEndp = ip->tokbuf;
*ip->tokServp = '\0';
if ((c = inputGetc(ep)) < 0) {
return EJS_TOK_EOF;
}
/*
* Main lexical analyser
*/
for (done = 0; !done; ) {
switch (c) {
case -1:
return EJS_TOK_EOF;
case ' ':
case '\t':
case '\r':
do {
if ((c = inputGetc(ep)) < 0)
break;
} while (c == ' ' || c == '\t' || c == '\r');
break;
case '\n':
return EJS_TOK_NEWLINE;
case '(':
tokenAddChar(ep, c);
return EJS_TOK_LPAREN;
case ')':
tokenAddChar(ep, c);
return EJS_TOK_RPAREN;
case '[':
tokenAddChar(ep, c);
return EJS_TOK_LBRACKET;
case ']':
tokenAddChar(ep, c);
return EJS_TOK_RBRACKET;
case '.':
tokenAddChar(ep, c);
return EJS_TOK_PERIOD;
case '{':
tokenAddChar(ep, c);
return EJS_TOK_LBRACE;
case '}':
tokenAddChar(ep, c);
return EJS_TOK_RBRACE;
case '+':
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c != '+' ) {
inputPutback(ep, c);
tokenAddChar(ep, EJS_EXPR_PLUS);
return EJS_TOK_EXPR;
}
tokenAddChar(ep, EJS_EXPR_INC);
return EJS_TOK_INC_DEC;
case '-':
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c != '-' ) {
inputPutback(ep, c);
tokenAddChar(ep, EJS_EXPR_MINUS);
return EJS_TOK_EXPR;
}
tokenAddChar(ep, EJS_EXPR_DEC);
return EJS_TOK_INC_DEC;
case '*':
tokenAddChar(ep, EJS_EXPR_MUL);
return EJS_TOK_EXPR;
case '%':
tokenAddChar(ep, EJS_EXPR_MOD);
return EJS_TOK_EXPR;
case '/':
/*
* Handle the division operator and comments
*/
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c != '*' && c != '/') {
inputPutback(ep, c);
tokenAddChar(ep, EJS_EXPR_DIV);
return EJS_TOK_EXPR;
}
style = c;
/*
* Eat comments. Both C and C++ comment styles are supported.
*/
while (1) {
if ((c = inputGetc(ep)) < 0) {
if (style == '/') {
return EJS_TOK_EOF;
}
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c == '\n' && style == '/') {
break;
} else if (c == '*') {
c = inputGetc(ep);
if (style == '/') {
if (c == '\n') {
break;
}
} else {
if (c == '/') {
break;
}
}
}
}
/*
* Continue looking for a token, so get the next character
*/
if ((c = inputGetc(ep)) < 0) {
return EJS_TOK_EOF;
}
break;
case '<': /* < and <= */
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c == '<') {
tokenAddChar(ep, EJS_EXPR_LSHIFT);
return EJS_TOK_EXPR;
} else if (c == '=') {
tokenAddChar(ep, EJS_EXPR_LESSEQ);
return EJS_TOK_EXPR;
}
tokenAddChar(ep, EJS_EXPR_LESS);
inputPutback(ep, c);
return EJS_TOK_EXPR;
case '>': /* > and >= */
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c == '>') {
tokenAddChar(ep, EJS_EXPR_RSHIFT);
return EJS_TOK_EXPR;
} else if (c == '=') {
tokenAddChar(ep, EJS_EXPR_GREATEREQ);
return EJS_TOK_EXPR;
}
tokenAddChar(ep, EJS_EXPR_GREATER);
inputPutback(ep, c);
return EJS_TOK_EXPR;
case '=': /* "==" */
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c == '=') {
tokenAddChar(ep, EJS_EXPR_EQ);
return EJS_TOK_EXPR;
}
inputPutback(ep, c);
return EJS_TOK_ASSIGNMENT;
case '!': /* "!=" or "!"*/
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
if (c == '=') {
tokenAddChar(ep, EJS_EXPR_NOTEQ);
return EJS_TOK_EXPR;
}
inputPutback(ep, c);
tokenAddChar(ep, EJS_EXPR_BOOL_COMP);
return EJS_TOK_EXPR;
case ';':
tokenAddChar(ep, c);
return EJS_TOK_SEMI;
case ',':
tokenAddChar(ep, c);
return EJS_TOK_COMMA;
case '|': /* "||" */
if ((c = inputGetc(ep)) < 0 || c != '|') {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
tokenAddChar(ep, EJS_COND_OR);
return EJS_TOK_LOGICAL;
case '&': /* "&&" */
if ((c = inputGetc(ep)) < 0 || c != '&') {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
tokenAddChar(ep, EJS_COND_AND);
return EJS_TOK_LOGICAL;
case '\"': /* String quote */
case '\'':
quote = c;
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Syntax Error");
return EJS_TOK_ERR;
}
while (c != quote) {
/*
* Check for escape sequence characters
*/
if (c == '\\') {
c = inputGetc(ep);
if (isdigit(c)) {
/*
* Octal support, \101 maps to 65 = 'A'. Put first
* char back so converter will work properly.
*/
inputPutback(ep, c);
c = charConvert(ep, 8, 3);
} else {
switch (c) {
case 'n':
c = '\n'; break;
case 'b':
c = '\b'; break;
case 'f':
c = '\f'; break;
case 'r':
c = '\r'; break;
case 't':
c = '\t'; break;
case 'x':
/*
* Hex support, \x41 maps to 65 = 'A'
*/
c = charConvert(ep, 16, 2);
break;
case 'u':
/*
* Unicode support, \x0401 maps to 65 = 'A'
*/
c = charConvert(ep, 16, 2);
c = c*16 + charConvert(ep, 16, 2);
break;
case '\'':
case '\"':
case '\\':
break;
default:
ejsError(ep, "Invalid Escape Sequence");
return EJS_TOK_ERR;
}
}
if (tokenAddChar(ep, c) < 0) {
return EJS_TOK_ERR;
}
} else {
if (tokenAddChar(ep, c) < 0) {
return EJS_TOK_ERR;
}
}
if ((c = inputGetc(ep)) < 0) {
ejsError(ep, "Unmatched Quote");
return EJS_TOK_ERR;
}
}
return EJS_TOK_LITERAL;
case '0':
if (tokenAddChar(ep, c) < 0) {
return EJS_TOK_ERR;
}
if ((c = inputGetc(ep)) < 0) {
break;
}
if (tolower(c) == 'x') {
do {
if (tokenAddChar(ep, c) < 0) {
return EJS_TOK_ERR;
}
if ((c = inputGetc(ep)) < 0) {
break;
}
} while (isdigit(c) || (tolower(c) >= 'a' && tolower(c) <= 'f'));
mprDestroyVar(&ep->tokenNumber);
ep->tokenNumber = mprParseVar(ep->token, type);
inputPutback(ep, c);
return EJS_TOK_NUMBER;
}
if (! isdigit(c)) {
#if BLD_FEATURE_FLOATING_POINT
if (c == '.' || tolower(c) == 'e' || c == '+' || c == '-') {
/* Fall through */
type = MPR_TYPE_FLOAT;
} else
#endif
{
mprDestroyVar(&ep->tokenNumber);
ep->tokenNumber = mprParseVar(ep->token, type);
inputPutback(ep, c);
return EJS_TOK_NUMBER;
}
}
/* Fall through to get more digits */
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
do {
if (tokenAddChar(ep, c) < 0) {
return EJS_TOK_ERR;
}
if ((c = inputGetc(ep)) < 0) {
break;
}
#if BLD_FEATURE_FLOATING_POINT
if (c == '.' || tolower(c) == 'e' || tolower(c) == 'f') {
type = MPR_TYPE_FLOAT;
}
} while (isdigit(c) || c == '.' || tolower(c) == 'e' || tolower(c) == 'f' ||
((type == MPR_TYPE_FLOAT) && (c == '+' || c == '-')));
#else
} while (isdigit(c));
#endif
mprDestroyVar(&ep->tokenNumber);
ep->tokenNumber = mprParseVar(ep->token, type);
inputPutback(ep, c);
return EJS_TOK_NUMBER;
default:
/*
* Identifiers or a function names
*/
while (1) {
if (c == '\\') {
if ((c = inputGetc(ep)) < 0) {
break;
}
if (c == '\n' || c == '\r') {
break;
}
} else if (tokenAddChar(ep, c) < 0) {
break;
}
if ((c = inputGetc(ep)) < 0) {
break;
}
if (!isalnum(c) && c != '$' && c != '_' && c != '\\') {
break;
}
}
if (*ep->token == '\0') {
c = inputGetc(ep);
break;
}
if (! isalpha((int) *ep->token) && *ep->token != '$' &&
*ep->token != '_') {
ejsError(ep, "Invalid identifier %s", ep->token);
return EJS_TOK_ERR;
}
tid = checkReservedWord(ep, state, c, EJS_TOK_ID);
if (tid != EJS_TOK_ID) {
return tid;
}
/*
* Skip white space after token to find out whether this is
* a function or not.
*/
while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
if ((c = inputGetc(ep)) < 0)
break;
}
tid = EJS_TOK_ID;
done++;
}
}
