URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libnetworking/] [rtems_webserver/] [ejparse.c] - Blame information for rev 493

Go to most recent revision | Details | Compare with Previous | View Log

/*
 * ejparse.c -- Ejscript(TM) Parser
 *
 * Copyright (c) Go Ahead Software, Inc., 1995-1999
 *
 * See the file "license.txt" for usage and redistribution license requirements
 */
 
/******************************** Description *********************************/
 
/*
 *      Ejscript parser. This implementes a subset of the JavaScript language.
 *      Multiple Ejscript parsers can be opened at a time.
 */
 
/********************************** Includes **********************************/
 
#include        "ej.h"
 
/********************************** Local Data ********************************/
 
ej_t                    **ejHandles;                                                    /* List of ej handles */
int                             ejMax = -1;                                                             /* Maximum size of      */
 
/****************************** Forward Declarations **************************/
 
static ej_t             *ejPtr(int eid);
static void             clearString(char_t **ptr);
static void             setString(char_t **ptr, char_t *s);
static void             appendString(char_t **ptr, char_t *s);
static void             freeVar(sym_t* sp);
static int              parse(ej_t *ep, int state, int flags);
static int              parseStmt(ej_t *ep, int state, int flags);
static int              parseDeclaration(ej_t *ep, int state, int flags);
static int              parseArgs(ej_t *ep, int state, int flags);
static int              parseCond(ej_t *ep, int state, int flags);
static int              parseExpr(ej_t *ep, int state, int flags);
static int              evalExpr(ej_t *ep, char_t *lhs, int rel, char_t *rhs);
static int              evalCond(ej_t *ep, char_t *lhs, int rel, char_t *rhs);
static int              evalFunction(ej_t *ep);
static void             freeFunc(ejfunc_t *func);
 
/************************************* Code ***********************************/
/*
 *      Initialize a Ejscript engine
 */
 
int ejOpenEngine(sym_fd_t variables, sym_fd_t functions)
{
        ej_t    *ep;
        int             eid, vid;
 
        if ((eid = hAllocEntry((void***) &ejHandles, &ejMax, sizeof(ej_t))) < 0) {
                return -1;
        }
        ep = ejHandles[eid];
        ep->eid = eid;
 
/*
 *      Create a top level symbol table if one is not provided for variables and
 *      functions. Variables may create other symbol tables for block level
 *      declarations so we use hAlloc to manage a list of variable tables.
 */
        if ((vid = hAlloc((void***) &ep->variables)) < 0) {
                ejMax = hFree((void***) &ejHandles, ep->eid);
                return -1;
        }
        if (vid >= ep->variableMax) {
                ep->variableMax = vid + 1;
        }
 
        if (variables == -1) {
                ep->variables[vid] = symOpen(64) + EJ_OFFSET;
                ep->flags |= FLAGS_VARIABLES;
 
        } else {
                ep->variables[vid] = variables + EJ_OFFSET;
        }
 
        if (functions == -1) {
                ep->functions = symOpen(64);
                ep->flags |= FLAGS_FUNCTIONS;
        } else {
                ep->functions = functions;
        }
 
        ejLexOpen(ep);
 
/*
 *      Define standard constants
 */
        ejSetGlobalVar(ep->eid, T("null"), NULL);
 
#if EMF
        ejEmfOpen(ep->eid);
#endif
        return ep->eid;
}
 
/******************************************************************************/
/*
 *      Close
 */
 
void ejCloseEngine(int eid)
{
        ej_t    *ep;
        int             i;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
 
#if EMF
        ejEmfClose(eid);
#endif
 
        bfreeSafe(B_L, ep->error);
        ep->error = NULL;
        bfreeSafe(B_L, ep->result);
        ep->result = NULL;
 
        ejLexClose(ep);
 
        if (ep->flags & FLAGS_VARIABLES) {
                for (i = ep->variableMax - 1; i >= 0; i--) {
                        symClose(ep->variables[i] - EJ_OFFSET, freeVar);
                        ep->variableMax = hFree((void***) &ep->variables, i);
                }
        }
        if (ep->flags & FLAGS_FUNCTIONS) {
                symClose(ep->functions, freeVar);
        }
 
        ejMax = hFree((void***) &ejHandles, ep->eid);
        bfree(B_L, ep);
}
 
/******************************************************************************/
/*
 *      Callback from symClose. Free the variable.
 */
 
static void freeVar(sym_t* sp)
{
        valueFree(&sp->content);
}
 
/******************************************************************************/
/*
 *      Evaluate a Ejscript file
 */
 
#if DEV
char_t *ejEvalFile(int eid, char_t *path, char_t **emsg)
{
        gstat_t sbuf;
        ej_t    *ep;
        char_t  *script, *rs;
        char    *fileBuf;
        int             fd;
 
        a_assert(path && *path);
 
        if (emsg) {
                *emsg = NULL;
        }
        if ((ep = ejPtr(eid)) == NULL) {
                return NULL;
        }
 
        if ((fd = gopen(path, O_RDONLY | O_BINARY, 0666)) < 0) {
                ejError(ep, T("Bad handle %d"), eid);
                return NULL;
        }
        if (gstat(path, &sbuf) < 0) {
                close(fd);
                ejError(ep, T("Cant stat %s"), path);
                return NULL;
        }
        if ((fileBuf = balloc(B_L, sbuf.st_size + 1)) == NULL) {
                close(fd);
                ejError(ep, T("Cant malloc %d"), sbuf.st_size);
                return NULL;
        }
        if (read(fd, fileBuf, sbuf.st_size) != (int)sbuf.st_size) {
                close(fd);
                bfree(B_L, fileBuf);
                ejError(ep, T("Error reading %s"), path);
                return NULL;
        }
        fileBuf[sbuf.st_size] = '\0';
        close(fd);
 
        if ((script = ballocAscToUni(fileBuf)) == NULL) {
                bfree(B_L, fileBuf);
                ejError(ep, T("Cant malloc %d"), sbuf.st_size + 1);
                return NULL;
        }
        bfree(B_L, fileBuf);
 
        rs = ejEvalBlock(eid, script, emsg);
 
        bfree(B_L, script);
        return rs;
}
#endif
 
/******************************************************************************/
/*
 *      Create a new variable scope block so that consecutive ejEval calls may
 *      be made with the same varible scope. This space MUST be closed with
 *      ejCloseBlock when the evaluations are complete.
 */
 
int ejOpenBlock(int eid)
{
        ej_t    *ep;
        int             vid;
 
        if((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        if ((vid = hAlloc((void***) &ep->variables)) < 0) {
                return -1;
        }
        if (vid >= ep->variableMax) {
                ep->variableMax = vid + 1;
        }
        ep->variables[vid] = symOpen(64) + EJ_OFFSET;
        return vid;
 
}
 
/******************************************************************************/
/*
 *      Close a variable scope block. The vid parameter is the return value from
 *      the call to ejOpenBlock
 */
 
int ejCloseBlock(int eid, int vid)
{
        ej_t    *ep;
 
        if((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        symClose(ep->variables[vid] - EJ_OFFSET, freeVar);
        ep->variableMax = hFree((void***) &ep->variables, vid);
        return 0;
 
}
/******************************************************************************/
/*
 *      Create a new variable scope block and evaluate a script. All variables
 *      created during this context will be automatically deleted when complete.
 */
 
char_t *ejEvalBlock(int eid, char_t *script, char_t **emsg)
{
        char_t* returnVal;
        int             vid;
 
        a_assert(script);
 
        vid = ejOpenBlock(eid);
        returnVal = ejEval(eid, script, emsg);
        ejCloseBlock(eid, vid);
 
        return returnVal;
}
 
/******************************************************************************/
/*
 *      Parse and evaluate a Ejscript. The caller may provide a symbol table to
 *      use for variables and function definitions. Return char_t pointer on
 *      success otherwise NULL pointer is returned.
 */
 
char_t *ejEval(int eid, char_t *script, char_t **emsg)
{
        ej_t    *ep;
        ejinput_t       *oldBlock;
        int             state;
 
        a_assert(script);
 
        if (emsg) {
                *emsg = NULL;
        }
        if ((ep = ejPtr(eid)) == NULL) {
                return NULL;
        }
 
        setString(&ep->result, T(""));
 
/*
 *      Allocate a new evaluation block, and save the old one
 */
        oldBlock = ep->input;
        ejLexOpenScript(ep, script);
 
/*
 *      Do the actual parsing and evaluation
 */
        do {
                state = parse(ep, STATE_BEGIN, FLAGS_EXE);
        } while (state != STATE_EOF && state != STATE_ERR);
 
        ejLexCloseScript(ep);
 
/*
 *      Return any error string to the user
 */
        if (state == STATE_ERR && emsg) {
                *emsg = bstrdup(B_L, ep->error);
        }
 
/*
 *      Restore the old evaluation block
 */
        ep->input = oldBlock;
 
        if (state == STATE_EOF) {
                return ep->result;
        }
        if (state == STATE_ERR) {
                return NULL;
        }
        return ep->result;
}
 
/******************************************************************************/
/*
 *      Recursive descent parser for Ejscript
 */
 
static int parse(ej_t *ep, int state, int flags)
{
        a_assert(ep);
 
        switch (state) {
/*
 *      Any statement, function arguments or conditional expressions
 */
        case STATE_STMT:
        case STATE_DEC:
                state = parseStmt(ep, state, flags);
                break;
 
        case STATE_EXPR:
                state = parseStmt(ep, state, flags);
                break;
 
/*
 *      Variable declaration list
 */
        case STATE_DEC_LIST:
                state = parseDeclaration(ep, state, flags);
                break;
 
/*
 *      Function argument string
 */
        case STATE_ARG_LIST:
                state = parseArgs(ep, state, flags);
                break;
 
/*
 *      Logical condition list (relational operations separated by &&, ||)
 */
        case STATE_COND:
                state = parseCond(ep, state, flags);
                break;
 
/*
 *      Expression list
 */
        case STATE_RELEXP:
                state = parseExpr(ep, state, flags);
                break;
        }
 
        if (state == STATE_ERR && ep->error == NULL) {
                ejError(ep, T("Syntax error"));
        }
        return state;
}
 
/******************************************************************************/
/*
 *      Parse any statement including functions and simple relational operations
 */
 
static int parseStmt(ej_t *ep, int state, int flags)
{
        ejfunc_t        func;
        ejfunc_t        *saveFunc;
        ejinput_t       condScript, endScript, bodyScript, incrScript;
        char_t          *value;
        char_t          *identifier;
        int                     done, expectSemi, thenFlags, elseFlags, tid, cond, forFlags;
 
        a_assert(ep);
 
/*
 *      Set these to NULL, else we try to free them if an error occurs.
 */
        endScript.putBackToken = NULL;
        bodyScript.putBackToken = NULL;
        incrScript.putBackToken = NULL;
        condScript.putBackToken = NULL;
 
        expectSemi = 0;
        saveFunc = NULL;
 
        for (done = 0; !done; ) {
                tid = ejLexGetToken(ep, state);
 
                switch (tid) {
                default:
                        ejLexPutbackToken(ep, TOK_EXPR, ep->token);
                        done++;
                        break;
 
                case TOK_ERR:
                        state = STATE_ERR;
                        done++;
                        break;
 
                case TOK_EOF:
                        state = STATE_EOF;
                        done++;
                        break;
 
                case TOK_NEWLINE:
                        break;
 
                case TOK_SEMI:
/*
 *                      This case is when we discover no statement and just a lone ';'
 */
                        if (state != STATE_STMT) {
                                ejLexPutbackToken(ep, tid, ep->token);
                        }
                        done++;
                        break;
 
                case TOK_ID:
/*
 *                      This could either be a reference to a variable or an assignment
 */
                        identifier = NULL;
                        setString(&identifier, ep->token);
/*
 *                      Peek ahead to see if this is an assignment
 */
                        tid = ejLexGetToken(ep, state);
                        if (tid == TOK_ASSIGNMENT) {
                                if (parse(ep, STATE_RELEXP, flags) != STATE_RELEXP_DONE) {
                                        goto error;
                                }
                                if (flags & FLAGS_EXE) {
                                        if ( state == STATE_DEC ) {
                                                ejSetLocalVar(ep->eid, identifier, ep->result);
                                        }
                                        else {
                                                if (ejGetVar(ep->eid, identifier, &value) > 0) {
                                                        ejSetLocalVar(ep->eid, identifier, ep->result);
                                                } else {
                                                        ejSetGlobalVar(ep->eid, identifier, ep->result);
                                                }
                                        }
                                }
 
                        } else if (tid == TOK_INC_DEC ) {
                                value = NULL;
                                if ( flags & FLAGS_EXE ) {
                                        if (ejGetVar(ep->eid, identifier, &value) < 0) {
                                                ejError(ep, T("Undefined variable %s\n"), identifier);
                                                goto error;
                                        }
                                        setString(&ep->result, value);
                                        if (evalExpr(ep, value, (int) *ep->token, T("1")) < 0) {
                                                state = STATE_ERR;
                                                break;
                                        }
                                        ejSetGlobalVar(ep->eid, identifier, ep->result);
                                }
 
                        } else {
/*
 *                              If we are processing a declaration, allow undefined vars
 */
                                value = NULL;
                                if (state == STATE_DEC) {
                                        if (ejGetVar(ep->eid, identifier, &value) > 0) {
                                                ejError(ep, T("Variable already declared"),
                                                        identifier);
                                                clearString(&identifier);
                                                goto error;
                                        }
                                        ejSetLocalVar(ep->eid, identifier, NULL);
                                } else {
                                        if ( flags & FLAGS_EXE ) {
                                                if (ejGetVar(ep->eid, identifier, &value) < 0) {
                                                        ejError(ep, T("Undefined variable %s\n"),
                                                                identifier);
                                                        clearString(&identifier);
                                                        goto error;
                                                }
                                        }
                                }
                                setString(&ep->result, value);
                                ejLexPutbackToken(ep, tid, ep->token);
                        }
                        clearString(&identifier);
 
                        if (state == STATE_STMT) {
                                expectSemi++;
                        }
                        done++;
                        break;
 
                case TOK_LITERAL:
/*
 *                      Set the result to the literal (number or string constant)
 */
                        setString(&ep->result, ep->token);
                        if (state == STATE_STMT) {
                                expectSemi++;
                        }
                        done++;
                        break;
 
                case TOK_FUNCTION:
/*
 *                      We must save any current ep->func value for the current stack frame
 */
                        if (ep->func) {
                                saveFunc = ep->func;
                        }
                        memset(&func, 0, sizeof(ejfunc_t));
                        setString(&func.fname, ep->token);
                        ep->func = &func;
 
                        setString(&ep->result, T(""));
                        if (ejLexGetToken(ep, state) != TOK_LPAREN) {
                                freeFunc(&func);
                                goto error;
                        }
 
                        if (parse(ep, STATE_ARG_LIST, flags) != STATE_ARG_LIST_DONE) {
                                freeFunc(&func);
                                ep->func = saveFunc;
                                goto error;
                        }
/*
 *                      Evaluate the function if required
 */
                        if (flags & FLAGS_EXE && evalFunction(ep) < 0) {
                                freeFunc(&func);
                                ep->func = saveFunc;
                                goto error;
                        }
 
                        freeFunc(&func);
                        ep->func = saveFunc;
 
                        if (ejLexGetToken(ep, state) != TOK_RPAREN) {
                                goto error;
                        }
                        if (state == STATE_STMT) {
                                expectSemi++;
                        }
                        done++;
                        break;
 
                case TOK_IF:
                        if (state != STATE_STMT) {
                                goto error;
                        }
                        if (ejLexGetToken(ep, state) != TOK_LPAREN) {
                                goto error;
                        }
/*
 *                      Evaluate the entire condition list "(condition)"
 */
                        if (parse(ep, STATE_COND, flags) != STATE_COND_DONE) {
                                goto error;
                        }
                        if (ejLexGetToken(ep, state) != TOK_RPAREN) {
                                goto error;
                        }
/*
 *                      This is the "then" case. We need to always parse both cases and
 *                      execute only the relevant case.
 */
                        if (*ep->result == '1') {
                                thenFlags = flags;
                                elseFlags = flags & ~FLAGS_EXE;
                        } else {
                                thenFlags = flags & ~FLAGS_EXE;
                                elseFlags = flags;
                        }
/*
 *                      Process the "then" case
 */
                        if (parse(ep, STATE_STMT, thenFlags) != STATE_STMT_DONE) {
                                goto error;
                        }
                        tid = ejLexGetToken(ep, state);
                        if (tid != TOK_ELSE) {
                                ejLexPutbackToken(ep, tid, ep->token);
                                done++;
                                break;
                        }
/*
 *                      Process the "else" case
 */
                        if (parse(ep, STATE_STMT, elseFlags) != STATE_STMT_DONE) {
                                goto error;
                        }
                        done++;
                        break;
 
                case TOK_FOR:
/*
 *                      Format for the expression is:
 *
 *                              for (initial; condition; incr) {
 *                                      body;
 *                              }
 */
                        if (state != STATE_STMT) {
                                goto error;
                        }
                        if (ejLexGetToken(ep, state) != TOK_LPAREN) {
                                goto error;
                        }
 
/*
 *                      Evaluate the for loop initialization statement
 */
                        if (parse(ep, STATE_EXPR, flags) != STATE_EXPR_DONE) {
                                goto error;
                        }
                        if (ejLexGetToken(ep, state) != TOK_SEMI) {
                                goto error;
                        }
 
/*
 *                      The first time through, we save the current input context just
 *                      to each step: prior to the conditional, the loop increment and the
 *                      loop body.
 */
                        ejLexSaveInputState(ep, &condScript);
                        if (parse(ep, STATE_COND, flags) != STATE_COND_DONE) {
                                goto error;
                        }
                        cond = (*ep->result != '0');
 
                        if (ejLexGetToken(ep, state) != TOK_SEMI) {
                                goto error;
                        }
 
/*
 *                      Don't execute the loop increment statement or the body first time
 */
                        forFlags = flags & ~FLAGS_EXE;
                        ejLexSaveInputState(ep, &incrScript);
                        if (parse(ep, STATE_EXPR, forFlags) != STATE_EXPR_DONE) {
                                goto error;
                        }
                        if (ejLexGetToken(ep, state) != TOK_RPAREN) {
                                goto error;
                        }
 
/*
 *                      Parse the body and remember the end of the body script
 */
                        ejLexSaveInputState(ep, &bodyScript);
                        if (parse(ep, STATE_STMT, forFlags) != STATE_STMT_DONE) {
                                goto error;
                        }
                        ejLexSaveInputState(ep, &endScript);
 
/*
 *                      Now actually do the for loop. Note loop has been rotated
 */
                        while (cond && (flags & FLAGS_EXE) ) {
/*
 *                              Evaluate the body
 */
                                ejLexRestoreInputState(ep, &bodyScript);
                                if (parse(ep, STATE_STMT, flags) != STATE_STMT_DONE) {
                                        goto error;
                                }
/*
 *                              Evaluate the increment script
 */
                                ejLexRestoreInputState(ep, &incrScript);
                                if (parse(ep, STATE_EXPR, flags) != STATE_EXPR_DONE) {
                                        goto error;
                                }
/*
 *                              Evaluate the condition
 */
                                ejLexRestoreInputState(ep, &condScript);
                                if (parse(ep, STATE_COND, flags) != STATE_COND_DONE) {
                                        goto error;
                                }
                                cond = (*ep->result != '0');
                        }
                        ejLexRestoreInputState(ep, &endScript);
                        done++;
                        break;
 
                case TOK_VAR:
                        if (parse(ep, STATE_DEC_LIST, flags) != STATE_DEC_LIST_DONE) {
                                goto error;
                        }
                        done++;
                        break;
 
                case TOK_COMMA:
                        ejLexPutbackToken(ep, TOK_EXPR, ep->token);
                        done++;
                        break;
 
                case TOK_LPAREN:
                        if (state == STATE_EXPR) {
                                if (parse(ep, STATE_RELEXP, flags) != STATE_RELEXP_DONE) {
                                        goto error;
                                }
                                if (ejLexGetToken(ep, state) != TOK_RPAREN) {
                                        goto error;
                                }
                                return STATE_EXPR_DONE;
                        }
                        done++;
                        break;
 
                case TOK_RPAREN:
                        ejLexPutbackToken(ep, tid, ep->token);
                        return STATE_EXPR_DONE;
 
                case TOK_LBRACE:
/*
 *                      This handles any code in braces except "if () {} else {}"
 */
                        if (state != STATE_STMT) {
                                goto error;
                        }
 
/*
 *                      Parse will return STATE_STMT_BLOCK_DONE when the RBRACE is seen
 */
                        do {
                                state = parse(ep, STATE_STMT, flags);
                        } while (state == STATE_STMT_DONE);
 
                        if (ejLexGetToken(ep, state) != TOK_RBRACE) {
                                goto error;
                        }
                        return STATE_STMT_DONE;
 
                case TOK_RBRACE:
                        if (state == STATE_STMT) {
                                ejLexPutbackToken(ep, tid, ep->token);
                                return STATE_STMT_BLOCK_DONE;
                        }
                        goto error;
 
                case TOK_RETURN:
                        if (parse(ep, STATE_RELEXP, flags) != STATE_RELEXP_DONE) {
                                goto error;
                        }
                        if (flags & FLAGS_EXE) {
                                while ( ejLexGetToken(ep, state) != TOK_EOF );
                                done++;
                                return STATE_EOF;
                        }
                        break;
                }
        }
 
        if (expectSemi) {
                tid = ejLexGetToken(ep, state);
                if (tid != TOK_SEMI && tid != TOK_NEWLINE) {
                        goto error;
                }
 
/*
 *              Skip newline after semi-colon
 */
                tid = ejLexGetToken(ep, state);
                if (tid != TOK_NEWLINE) {
                        ejLexPutbackToken(ep, tid, ep->token);
                }
        }
 
/*
 *      Free resources and return the correct status
 */
doneParse:
        if (tid == TOK_FOR) {
                ejLexFreeInputState(ep, &condScript);
                ejLexFreeInputState(ep, &incrScript);
                ejLexFreeInputState(ep, &endScript);
                ejLexFreeInputState(ep, &bodyScript);
        }
        if (state == STATE_STMT) {
                return STATE_STMT_DONE;
        } else if (state == STATE_DEC) {
                return STATE_DEC_DONE;
        } else if (state == STATE_EXPR) {
                return STATE_EXPR_DONE;
        } else if (state == STATE_EOF) {
                return state;
        } else {
                return STATE_ERR;
        }
 
/*
 *      Common error exit
 */
error:
        state = STATE_ERR;
        goto doneParse;
}
 
/******************************************************************************/
/*
 *      Parse variable declaration list
 */
 
static int parseDeclaration(ej_t *ep, int state, int flags)
{
        int             tid;
 
        a_assert(ep);
 
/*
 *      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.
 */
 
        do {
                if ((tid = ejLexGetToken(ep, state)) != TOK_ID) {
                        return STATE_ERR;
                }
                ejLexPutbackToken(ep, tid, ep->token);
 
/*
 *              Parse the entire assignment or simple identifier declaration
 */
                if (parse(ep, STATE_DEC, flags) != STATE_DEC_DONE) {
                        return STATE_ERR;
                }
 
/*
 *              Peek at the next token, continue if comma seen
 */
                tid = ejLexGetToken(ep, state);
                if (tid == TOK_SEMI) {
                        return STATE_DEC_LIST_DONE;
                } else if (tid != TOK_COMMA) {
                        return STATE_ERR;
                }
        } while (tid == TOK_COMMA);
 
        if (tid != TOK_SEMI) {
                return STATE_ERR;
        }
        return STATE_DEC_LIST_DONE;
}
 
/******************************************************************************/
/*
 *      Parse function arguments
 */
 
static int parseArgs(ej_t *ep, int state, int flags)
{
        int             tid, aid;
 
        a_assert(ep);
 
        do {
                state = parse(ep, STATE_RELEXP, flags);
                if (state == STATE_EOF || state == STATE_ERR) {
                        return state;
                }
                if (state == STATE_RELEXP_DONE) {
                        aid = hAlloc((void***) &ep->func->args);
                        ep->func->args[aid] = bstrdup(B_L, ep->result);
                        ep->func->nArgs++;
                }
/*
 *              Peek at the next token, continue if more args (ie. comma seen)
 */
                tid = ejLexGetToken(ep, state);
                if (tid != TOK_COMMA) {
                        ejLexPutbackToken(ep, tid, ep->token);
                }
        } while (tid == TOK_COMMA);
 
        if (tid != TOK_RPAREN && state != STATE_RELEXP_DONE) {
                return STATE_ERR;
        }
        return STATE_ARG_LIST_DONE;
}
 
/******************************************************************************/
/*
 *      Parse conditional expression (relational ops separated by ||, &&)
 */
 
static int parseCond(ej_t *ep, int state, int flags)
{
        char_t  *lhs, *rhs;
        int             tid, operator;
 
        a_assert(ep);
 
        setString(&ep->result, T(""));
        rhs = lhs = NULL;
        operator = 0;
 
        do {
/*
 *      Recurse to handle one side of a conditional. Accumulate the
 *      left hand side and the final result in ep->result.
 */
                state = parse(ep, STATE_RELEXP, flags);
                if (state != STATE_RELEXP_DONE) {
                        state = STATE_ERR;
                        break;
                }
                if (operator > 0) {
                        setString(&rhs, ep->result);
                        if (evalCond(ep, lhs, operator, rhs) < 0) {
                                state = STATE_ERR;
                                break;
                        }
                }
                setString(&lhs, ep->result);
 
                tid = ejLexGetToken(ep, state);
                if (tid == TOK_LOGICAL) {
                        operator = (int) *ep->token;
 
                } else if (tid == TOK_RPAREN || tid == TOK_SEMI) {
                        ejLexPutbackToken(ep, tid, ep->token);
                        state = STATE_COND_DONE;
                        break;
 
                } else {
                        ejLexPutbackToken(ep, tid, ep->token);
                }
 
        } while (state == STATE_RELEXP_DONE);
 
        if (lhs) {
                bfree(B_L, lhs);
        }
        if (rhs) {
                bfree(B_L, rhs);
        }
        return state;
}
 
/******************************************************************************/
/*
 *      Parse expression (leftHandSide operator rightHandSide)
 */
 
static int parseExpr(ej_t *ep, int state, int flags)
{
        char_t  *lhs, *rhs;
        int             rel, tid;
 
        a_assert(ep);
 
        setString(&ep->result, T(""));
        rhs = lhs = NULL;
        rel = 0;
 
        do {
/*
 *      This loop will handle an entire expression list. We call parse
 *      to evalutate each term which returns the result in ep->result.
 */
                state = parse(ep, STATE_EXPR, flags);
                if (state != STATE_EXPR_DONE) {
                        state = STATE_ERR;
                        break;
                }
                if (rel > 0) {
                        setString(&rhs, ep->result);
                        if (evalExpr(ep, lhs, rel, rhs) < 0) {
                                state = STATE_ERR;
                                break;
                        }
                }
                setString(&lhs, ep->result);
 
                if ((tid = ejLexGetToken(ep, state)) == TOK_EXPR) {
                        rel = (int) *ep->token;
 
                } else if (tid == TOK_INC_DEC) {
                        rel = (int) *ep->token;
 
                } else {
                        ejLexPutbackToken(ep, tid, ep->token);
                        state = STATE_RELEXP_DONE;
                }
 
        } while (state == STATE_EXPR_DONE);
 
        if (rhs)
                bfree(B_L, rhs);
        if (lhs)
                bfree(B_L, lhs);
        return state;
}
 
/******************************************************************************/
/*
 *      Evaluate a condition. Implements &&, ||, !
 */
 
static int evalCond(ej_t *ep, char_t *lhs, int rel, char_t *rhs)
{
        char_t  buf[16];
        int             l, r, lval;
 
        a_assert(lhs);
        a_assert(rhs);
        a_assert(rel > 0);
 
        lval = 0;
        if (gisdigit(*lhs) && gisdigit(*rhs)) {
                l = gatoi(lhs);
                r = gatoi(rhs);
                switch (rel) {
                case COND_AND:
                        lval = l && r;
                        break;
                case COND_OR:
                        lval = l || r;
                        break;
                default:
                        ejError(ep, T("Bad operator %d"), rel);
                        return -1;
                }
        } else {
                if (!gisdigit(*lhs)) {
                        ejError(ep, T("Conditional must be numeric"), lhs);
                } else {
                        ejError(ep, T("Conditional must be numeric"), rhs);
                }
        }
 
        stritoa(lval, buf, sizeof(buf));
        setString(&ep->result, buf);
        return 0;
}
 
/******************************************************************************/
/*
 *      Evaluate an operation
 */
 
static int evalExpr(ej_t *ep, char_t *lhs, int rel, char_t *rhs)
{
        char_t  *cp, buf[16];
        int             numeric, l, r, lval;
 
        a_assert(lhs);
        a_assert(rhs);
        a_assert(rel > 0);
 
/*
 *      All of the characters in the lhs and rhs must be numeric
 */
        numeric = 1;
        for (cp = lhs; *cp; cp++) {
                if (!gisdigit(*cp)) {
                        numeric = 0;
                        break;
                }
        }
        if (numeric) {
                for (cp = rhs; *cp; cp++) {
                        if (!gisdigit(*cp)) {
                                numeric = 0;
                                break;
                        }
                }
        }
        if (numeric) {
                l = gatoi(lhs);
                r = gatoi(rhs);
                switch (rel) {
                case EXPR_PLUS:
                        lval = l + r;
                        break;
                case EXPR_INC:
                        lval = l + 1;
                        break;
                case EXPR_MINUS:
                        lval = l - r;
                        break;
                case EXPR_DEC:
                        lval = l - 1;
                        break;
                case EXPR_MUL:
                        lval = l * r;
                        break;
                case EXPR_DIV:
                        if (r != 0) {
                                lval = l / r;
                        } else {
                                lval = 0;
                        }
                        break;
                case EXPR_MOD:
                        if (r != 0) {
                                lval = l % r;
                        } else {
                                lval = 0;
                        }
                        break;
                case EXPR_LSHIFT:
                        lval = l << r;
                        break;
                case EXPR_RSHIFT:
                        lval = l >> r;
                        break;
                case EXPR_EQ:
                        lval = l == r;
                        break;
                case EXPR_NOTEQ:
                        lval = l != r;
                        break;
                case EXPR_LESS:
                        lval = (l < r) ? 1 : 0;
                        break;
                case EXPR_LESSEQ:
                        lval = (l <= r) ? 1 : 0;
                        break;
                case EXPR_GREATER:
                        lval = (l > r) ? 1 : 0;
                        break;
                case EXPR_GREATEREQ:
                        lval = (l >= r) ? 1 : 0;
                        break;
                default:
                        ejError(ep, T("Bad operator %d"), rel);
                        return -1;
                }
 
        } else {
                switch (rel) {
                case EXPR_PLUS:
                        clearString(&ep->result);
                        appendString(&ep->result, lhs);
                        appendString(&ep->result, rhs);
                        return 0;
                case EXPR_LESS:
                        lval = gstrcmp(lhs, rhs) < 0;
                        break;
                case EXPR_LESSEQ:
                        lval = gstrcmp(lhs, rhs) <= 0;
                        break;
                case EXPR_GREATER:
                        lval = gstrcmp(lhs, rhs) > 0;
                        break;
                case EXPR_GREATEREQ:
                        lval = gstrcmp(lhs, rhs) >= 0;
                        break;
                case EXPR_EQ:
                        lval = gstrcmp(lhs, rhs) == 0;
                        break;
                case EXPR_NOTEQ:
                        lval = gstrcmp(lhs, rhs) != 0;
                        break;
                case EXPR_INC:
                case EXPR_DEC:
                case EXPR_MINUS:
                case EXPR_DIV:
                case EXPR_MOD:
                case EXPR_LSHIFT:
                case EXPR_RSHIFT:
                default:
                        ejError(ep, T("Bad operator"));
                        return -1;
                }
        }
 
        stritoa(lval, buf, sizeof(buf));
        setString(&ep->result, buf);
        return 0;
}
 
/******************************************************************************/
/*
 *      Evaluate a function
 */
 
static int evalFunction(ej_t *ep)
{
        sym_t   *sp;
        int             (*fn)(int eid, void *handle, int argc, char_t **argv);
 
        if ((sp = symLookup(ep->functions, ep->func->fname)) == NULL) {
                ejError(ep, T("Undefined procedure %s"), ep->func->fname);
                return -1;
        }
        fn = (int (*)(int, void*, int, char_t**)) sp->content.value.integer;
        if (fn == NULL) {
                ejError(ep, T("Undefined procedure %s"), ep->func->fname);
                return -1;
        }
 
        return (*fn)(ep->eid, (void*) ep->userHandle, ep->func->nArgs,
                ep->func->args);
}
 
/******************************************************************************/
/*
 *      Output a parse ej_error message
 */
 
void ejError(ej_t* ep, char_t* fmt, ...)
{
        va_list         args;
        ejinput_t       *ip;
        char_t          *errbuf, *msgbuf;
 
        a_assert(ep);
        a_assert(fmt);
        ip = ep->input;
 
        va_start(args, fmt);
        msgbuf = NULL;
        gvsnprintf(&msgbuf, E_MAX_ERROR, fmt, args);
        va_end(args);
 
        if (ep && ip) {
                errbuf = NULL;
                gsnprintf(&errbuf, E_MAX_ERROR, T("%s\n At line %d, line => \n\n%s\n"),
                        msgbuf, ip->lineNumber, ip->line);
                bfreeSafe(B_L, ep->error);
                ep->error = errbuf;
        }
        bfreeSafe(B_L, msgbuf);
}
 
/******************************************************************************/
/*
 *      Clear a string value
 */
 
static void clearString(char_t **ptr)
{
        a_assert(ptr);
 
        if (*ptr) {
                bfree(B_L, *ptr);
        }
        *ptr = NULL;
}
 
/******************************************************************************/
/*
 *      Set a string value
 */
 
static void setString(char_t **ptr, char_t *s)
{
        a_assert(ptr);
 
        if (*ptr) {
                bfree(B_L, *ptr);
        }
        *ptr = bstrdup(B_L, s);
}
 
/******************************************************************************/
/*
 *      Append to the pointer value
 */
 
static void appendString(char_t **ptr, char_t *s)
{
        int     len, oldlen;
 
        a_assert(ptr);
 
        if (*ptr) {
                len = gstrlen(s);
                oldlen = gstrlen(*ptr);
                *ptr = brealloc(B_L, *ptr, (len + oldlen + 1) * sizeof(char_t));
                gstrcpy(&(*ptr)[oldlen], s);
        } else {
                *ptr = bstrdup(B_L, s);
        }
}
 
/******************************************************************************/
/*
 *      Define a function
 */
 
int ejSetGlobalFunction(int eid, char_t *name,
        int (*fn)(int eid, void *handle, int argc, char_t **argv))
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        return ejSetGlobalFunctionDirect(ep->functions, name, fn);
}
 
/******************************************************************************/
/*
 *      Define a function directly into the function symbol table.
 */
 
int ejSetGlobalFunctionDirect(sym_fd_t functions, char_t *name,
        int (*fn)(int eid, void *handle, int argc, char_t **argv))
{
        if (symEnter(functions, name, valueInteger((long) fn), 0) == NULL) {
                return -1;
        }
        return 0;
}
 
/******************************************************************************/
/*
 *      Get a function definition
 */
 
void *ejGetGlobalFunction(int eid, char_t *name)
{
        ej_t    *ep;
        sym_t   *sp;
        int             (*fn)(int eid, void *handle, int argc, char_t **argv);
 
        if ((ep = ejPtr(eid)) == NULL) {
                return NULL;
        }
        if ((sp = symLookup(ep->functions, name)) != NULL) {
                fn = (int (*)(int, void*, int, char_t**)) sp->content.value.integer;
                return (void*) fn;
        }
        return NULL;
}
 
/******************************************************************************/
/*
 *      Utility routine to crack Ejscript arguments. Return the number of args
 *      seen. This routine only supports %s and %d type args.
 *
 *      Typical usage:
 *
 *              if (ejArgs(argc, argv, "%s %d", &name, &age) < 2) {
 *                      error("Insufficient args\n");
 *                      return -1;
 *              }
 */
 
int ejArgs(int argc, char_t **argv, char_t *fmt, ...)
{
        va_list vargs;
        char_t  *cp, **sp;
        int             *ip;
        int             argn;
 
        va_start(vargs, fmt);
 
        if (argv == NULL) {
                return 0;
        }
 
        for (argn = 0, cp = fmt; cp && *cp && argv[argn]; ) {
                if (*cp++ != '%') {
                        continue;
                }
 
                switch (*cp) {
                case 'd':
                        ip = va_arg(vargs, int*);
                        *ip = gatoi(argv[argn]);
                        break;
 
                case 's':
                        sp = va_arg(vargs, char_t**);
                        *sp = argv[argn];
                        break;
 
                default:
/*
 *                      Unsupported
 */
                        a_assert(0);
                }
                argn++;
        }
 
        va_end(vargs);
        return argn;
}
 
/******************************************************************************/
/*
 *      Define the user handle
 */
 
void ejSetUserHandle(int eid, int handle)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
        ep->userHandle = handle;
}
 
/******************************************************************************/
/*
 *      Get the user handle
 */
 
int ejGetUserHandle(int eid)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        return ep->userHandle;
}
 
/******************************************************************************/
/*
 *      Get the current line number
 */
 
int ejGetLineNumber(int eid)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        return ep->input->lineNumber;
}
 
/******************************************************************************/
/*
 *      Set the result
 */
 
void ejSetResult(int eid, char_t *s)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
        setString(&ep->result, s);
}
 
/******************************************************************************/
/*
 *      Get the result
 */
 
char_t *ejGetResult(int eid)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return NULL;
        }
        return ep->result;
}
 
/******************************************************************************/
/*
 *      Set a variable. Note: a variable with a value of NULL means declared but
 *      undefined. The value is defined in the top-most variable frame.
 */
 
void ejSetVar(int eid, char_t *var, char_t *value)
{
        ej_t    *ep;
        value_t v;
 
        a_assert(var && *var);
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
        if (value == NULL) {
                v = valueString(value, 0);
        } else {
                v = valueString(value, VALUE_ALLOCATE);
        }
        symEnter(ep->variables[ep->variableMax - 1] - EJ_OFFSET, var, v, 0);
}
 
/******************************************************************************/
/*
 *      Set a local variable. Note: a variable with a value of NULL means
 *      declared but undefined. The value is defined in the top-most variable frame.
 */
 
void ejSetLocalVar(int eid, char_t *var, char_t *value)
{
        ej_t    *ep;
        value_t v;
 
        a_assert(var && *var);
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
        if (value == NULL) {
                v = valueString(value, 0);
        } else {
                v = valueString(value, VALUE_ALLOCATE);
        }
        symEnter(ep->variables[ep->variableMax - 1] - EJ_OFFSET, var, v, 0);
}
 
/******************************************************************************/
/*
 *      Set a global variable. Note: a variable with a value of NULL means
 *      declared but undefined. The value is defined in the global variable frame.
 */
 
void ejSetGlobalVar(int eid, char_t *var, char_t *value)
{
        ej_t    *ep;
        value_t v;
 
        a_assert(var && *var);
 
        if ((ep = ejPtr(eid)) == NULL) {
                return;
        }
        if (value == NULL) {
                v = valueString(value, 0);
        } else {
                v = valueString(value, VALUE_ALLOCATE);
        }
        symEnter(ep->variables[0] - EJ_OFFSET, var, v, 0);
}
 
/******************************************************************************/
/*
 *      Get a variable
 */
 
int ejGetVar(int eid, char_t *var, char_t **value)
{
        ej_t    *ep;
        sym_t   *sp;
        int             i;
 
        a_assert(var && *var);
        a_assert(value);
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
 
        for (i = ep->variableMax - 1; i >= 0; i--) {
                if ((sp = symLookup(ep->variables[i] - EJ_OFFSET, var)) == NULL) {
                        continue;
                }
                a_assert(sp->content.type == string);
                *value = sp->content.value.string;
                return i;
        }
        return -1;
}
 
/******************************************************************************/
#if UNUSED
/*
 *      Get the variable symbol table
 */
 
sym_fd_t ejGetVariableTable(int eid)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        return ep->variables;
}
#endif
/******************************************************************************/
/*
 *      Get the functions symbol table
 */
 
sym_fd_t ejGetFunctionTable(int eid)
{
        ej_t    *ep;
 
        if ((ep = ejPtr(eid)) == NULL) {
                return -1;
        }
        return ep->functions;
}
 
/******************************************************************************/
/*
 *      Free an argument list
 */
 
static void freeFunc(ejfunc_t *func)
{
        int     i;
 
        for (i = func->nArgs - 1; i >= 0; i--) {
                bfree(B_L, func->args[i]);
                func->nArgs = hFree((void***) &func->args, i);
        }
        if (func->fname) {
                bfree(B_L, func->fname);
                func->fname = NULL;
        }
}
 
/******************************************************************************/
/*
 *      Get Ejscript pointer
 */
 
static ej_t *ejPtr(int eid)
{
        a_assert(0 <= eid && eid < ejMax);
 
        if (eid < 0 || eid >= ejMax || ejHandles[eid] == NULL) {
                ejError(NULL, T("Bad handle %d"), eid);
                return NULL;
        }
        return ejHandles[eid];
}
 
/******************************************************************************/
Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [rtems/] [c/] [src/] [libnetworking/] [rtems_webserver/] [ejparse.c] - Blame information for rev 493

Line No.	Rev	Author	Line
1	30	unneback	`/*`
2			`* ejparse.c -- Ejscript(TM) Parser`
3			`*`
4			`* Copyright (c) Go Ahead Software, Inc., 1995-1999`
5			`*`
6			`* See the file "license.txt" for usage and redistribution license requirements`
7			`*/`
8
9			`/****************************** Description *******************************/`
10
11			`/*`
12			`* Ejscript parser. This implementes a subset of the JavaScript language.`
13			`* Multiple Ejscript parsers can be opened at a time.`
14			`*/`
15
16			`/******************************** Includes ********************************/`
17
18			`#include "ej.h"`
19
20			`/******************************** Local Data ******************************/`
21
22			`ej_t *ejHandles; / List of ej handles */`
23			`int ejMax = -1; /* Maximum size of */`
24
25			`/**************************** Forward Declarations ************************/`
26
27			`static ej_t *ejPtr(int eid);`
28			`static void clearString(char_t **ptr);`
29			`static void setString(char_t *ptr, char_t s);`
30			`static void appendString(char_t *ptr, char_t s);`
31			`static void freeVar(sym_t* sp);`
32			`static int parse(ej_t *ep, int state, int flags);`
33			`static int parseStmt(ej_t *ep, int state, int flags);`
34			`static int parseDeclaration(ej_t *ep, int state, int flags);`
35			`static int parseArgs(ej_t *ep, int state, int flags);`
36			`static int parseCond(ej_t *ep, int state, int flags);`
37			`static int parseExpr(ej_t *ep, int state, int flags);`
38			`static int evalExpr(ej_t ep, char_t lhs, int rel, char_t *rhs);`
39			`static int evalCond(ej_t ep, char_t lhs, int rel, char_t *rhs);`
40			`static int evalFunction(ej_t *ep);`