statianzo
/
tiny-js-wasm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b901b74369'
${ noResults }
tiny-js-wasm/TinyJS.cpp

1483 lines
46 KiB
Raw Blame History

/*
* TinyJS
*
* A single-file Javascript-alike engine
*
* Authored By Gordon Williams <gw@pur3.co.uk>
*
* Copyright (C) 2009 Pur3 Ltd
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* Version 0.1 : (gw) First published on Google Code
Version 0.11 : Making sure the 'root' variable never changes
'symbol_base' added for the current base of the sybmbol table
Version 0.12 : Added findChildOrCreate, changed string passing to use references
Fixed broken string encoding in getJSString()
Removed getInitCode and added getJSON instead
Added nil
Added rough JSON parsing
Improved example app
Version 0.13 : Added tokenEnd/tokenLastEnd to lexer to avoid parsing whitespace
Ability to define functions without names
Can now do "var mine = function(a,b) { ... };"
Slightly better 'trace' function
Added findChildOrCreateByPath function
Added simple test suite
Added skipping of blocks when not executing
Version 0.14 : Added parsing of more number types
Added parsing of string defined with '
Changed nil to null as per spec, added 'undefined'
Now set variables with the correct scope, and treat unknown
as 'undefined' rather than failing
Added proper (I hope) handling of null and undefined
Added === check
NOTE: Currently TinyJS passes by VALUE for function, and never copies
references - which is a major difference between this and proper
JavaScript.
It also doesn't support class prototypes, or the 'new' operator
*/
#include "TinyJS.h"
#include <assert.h>
#define ASSERT(X) assert(X)
#define CLEAN(x) { CScriptVar *__v = x; if (__v && !__v->parent) delete __v; }
#include <string>
#include <string.h>
#include <sstream>
#include <cstdlib>
using namespace std;
#ifdef __GNUC__
#define vsprintf_s vsnprintf
#define sprintf_s snprintf
#endif
// ----------------------------------------------------------------------------------- Utils
bool isWhitespace(char ch) {
return (ch==' ') || (ch=='\t') || (ch=='\n') || (ch=='\r');
}
bool isNumeric(char ch) {
return (ch>='0') && (ch<='9');
}
bool isHexadecimal(char ch) {
return ((ch>='0') && (ch<='9')) ||
((ch>='a') && (ch<='f')) ||
((ch>='A') && (ch<='F'));
}
bool isAlpha(char ch) {
return ((ch>='a') && (ch<='z')) || ((ch>='A') && (ch<='Z')) || ch=='_';
}
bool isIDString(const char *s) {
if (!isAlpha(*s))
return false;
while (*s) {
if (!(isAlpha(*s) || isNumeric(*s)))
return false;
s++;
}
return true;
}
void replace(string &str, char textFrom, const char *textTo) {
int sLen = strlen(textTo);
size_t p = str.find(textFrom);
while (p != string::npos) {
str = str.substr(0, p) + textTo + str.substr(p+1);
p = str.find(textFrom, p+sLen);
}
}
/// convert the given string into a quoted string suitable for javascript
std::string getJSString(const std::string &str) {
std::string nStr = str;
for (size_t i=0;i<nStr.size();i++) {
const char *replaceWith = "";
bool replace = true;
switch (nStr[i]) {
case '\\': replaceWith = "\\\\"; break;
case '\n': replaceWith = "\\n"; break;
case '"': replaceWith = "\\\""; break;
default: replace=false;
}
if (replace) {
nStr = nStr.substr(0, i) + replaceWith + nStr.substr(i+1);
i += strlen(replaceWith)-1;
}
}
return "\"" + nStr + "\"";
}
// ----------------------------------------------------------------------------------- CSCRIPTEXCEPTION
CScriptException::CScriptException(const string &exceptionText) {
text = exceptionText;
}
// ----------------------------------------------------------------------------------- CSCRIPTLEX
CScriptLex::CScriptLex(const string &input) {
data = strdup(input.c_str());
dataOwned = true;
dataStart = 0;
dataEnd = strlen(data);
reset();
}
CScriptLex::CScriptLex(CScriptLex *owner, int startChar, int endChar) {
data = owner->data;
dataOwned = false;
dataStart = startChar;
dataEnd = endChar;
reset();
}
CScriptLex::~CScriptLex(void)
{
if (dataOwned)
free((void*)data);
}
void CScriptLex::reset() {
dataPos = dataStart;
tokenStart = 0;
tokenEnd = 0;
tokenLastEnd = 0;
tk = 0;
tkStr = "";
getNextCh();
getNextCh();
getNextToken();
}
void CScriptLex::match(int expected_tk) {
if (tk!=expected_tk) {
ostringstream errorString;
errorString << "Got " << getTokenStr(tk) << " expected " << getTokenStr(expected_tk)
<< " at " << getPosition(tokenStart) << "in '" << data << "'";
throw new CScriptException(errorString.str());
}
getNextToken();
}
string CScriptLex::getTokenStr(int token) {
if (token>32 && token<128) {
char buf[4] = "' '";
buf[1] = token;
return buf;
}
switch (token) {
case LEX_EOF : return "EOF";
case LEX_ID : return "ID";
case LEX_INT : return "INT";
case LEX_FLOAT : return "FLOAT";
case LEX_STR : return "STRING";
case LEX_EQUAL : return "==";
case LEX_TYPEEQUAL : return "===";
case LEX_NEQUAL : return "!=";
case LEX_NTYPEEQUAL : return "!==";
case LEX_LEQUAL : return "<=";
case LEX_GEQUAL : return ">=";
case LEX_PLUSEQUAL : return "+=";
case LEX_MINUSEQUAL : return "-=";
case LEX_PLUSPLUS : return "++";
case LEX_MINUSMINUS : return "--";
case LEX_ANDAND : return "&&";
case LEX_OROR : return "||";
// reserved words
case LEX_R_IF : return "if";
case LEX_R_ELSE : return "else";
case LEX_R_WHILE : return "while";
case LEX_R_FOR : return "for";
case LEX_R_FUNCTION : return "function";
case LEX_R_RETURN : return "return";
case LEX_R_VAR : return "var";
case LEX_R_TRUE : return "true";
case LEX_R_FALSE : return "false";
case LEX_R_NULL : return "null";
case LEX_R_UNDEFINED : return "undefined";
}
ostringstream msg;
msg << "?[" << token << "]";
return msg.str();
}
void CScriptLex::getNextCh() {
currCh = nextCh;
if (dataPos < dataEnd)
nextCh = data[dataPos];
else
nextCh = 0;
dataPos++;
}
void CScriptLex::getNextToken() {
tk = LEX_EOF;
tkStr.clear();
while (currCh && isWhitespace(currCh)) getNextCh();
// newline comments
if (currCh=='/' && nextCh=='/') {
while (currCh && currCh!='\n') getNextCh();
getNextCh();
getNextToken();
return;
}
// block comments
if (currCh=='/' && nextCh=='*') {
while (currCh && (currCh!='*' || nextCh!='/')) getNextCh();
getNextCh();
getNextCh();
getNextToken();
return;
}
// record beginning of this token
tokenStart = dataPos-2;
// tokens
if (isAlpha(currCh)) { // IDs
while (isAlpha(currCh) || isNumeric(currCh)) {
tkStr += currCh;
getNextCh();
}
tk = LEX_ID;
if (tkStr=="if") tk = LEX_R_IF;
else if (tkStr=="else") tk = LEX_R_ELSE;
else if (tkStr=="while") tk = LEX_R_WHILE;
else if (tkStr=="for") tk = LEX_R_FOR;
else if (tkStr=="function") tk = LEX_R_FUNCTION;
else if (tkStr=="return") tk = LEX_R_RETURN;
else if (tkStr=="var") tk = LEX_R_VAR;
else if (tkStr=="true") tk = LEX_R_TRUE;
else if (tkStr=="false") tk = LEX_R_FALSE;
else if (tkStr=="null") tk = LEX_R_NULL;
else if (tkStr=="undefined") tk = LEX_R_UNDEFINED;
} else if (isNumeric(currCh)) { // Numbers
bool isHex = false;
if (currCh=='0') { tkStr += currCh; getNextCh(); }
if (currCh=='x') {
isHex = true;
tkStr += currCh; getNextCh();
}
tk = LEX_INT;
while (isNumeric(currCh) || (isHex && isHexadecimal(currCh))) {
tkStr += currCh;
getNextCh();
}
if (!isHex && currCh=='.') {
tk = LEX_FLOAT;
tkStr += '.';
getNextCh();
while (isNumeric(currCh)) {
tkStr += currCh;
getNextCh();
}
}
// do fancy e-style floating point
if (!isHex && currCh=='e') {
tk = LEX_FLOAT;
tkStr += currCh; getNextCh();
if (currCh=='-') { tkStr += currCh; getNextCh(); }
while (isNumeric(currCh)) {
tkStr += currCh; getNextCh();
}
}
} else if (currCh=='"') {
// strings...
getNextCh();
while (currCh && currCh!='"') {
if (currCh == '\\') {
getNextCh();
switch (currCh) {
case 'n' : tkStr += '\n'; break;
case '"' : tkStr += '"'; break;
case '\\' : tkStr += '\\'; break;
default: tkStr += currCh;
}
} else {
tkStr += currCh;
}
getNextCh();
}
getNextCh();
tk = LEX_STR;
} else if (currCh=='\'') {
// strings again...
getNextCh();
while (currCh && currCh!='\'') {
if (currCh == '\\') {
getNextCh();
switch (currCh) {
case 'n' : tkStr += '\n'; break;
case '\'' : tkStr += '\''; break;
case '\\' : tkStr += '\\'; break;
default: tkStr += currCh;
}
} else {
tkStr += currCh;
}
getNextCh();
}
getNextCh();
tk = LEX_STR;
} else {
// single chars
tk = currCh;
if (currCh) getNextCh();
if (tk=='=' && currCh=='=') { // ==
tk = LEX_EQUAL;
getNextCh();
if (currCh=='=') { // ===
tk = LEX_TYPEEQUAL;
getNextCh();
}
} else if (tk=='!' && currCh=='=') { // !=
tk = LEX_NEQUAL;
getNextCh();
if (currCh=='=') { // !==
tk = LEX_NTYPEEQUAL;
getNextCh();
}
} else if (tk=='<' && currCh=='=') {
tk = LEX_LEQUAL;
getNextCh();
} else if (tk=='>' && currCh=='=') {
tk = LEX_GEQUAL;
getNextCh();
} else if (tk=='+' && currCh=='=') {
tk = LEX_PLUSEQUAL;
getNextCh();
} else if (tk=='-' && currCh=='=') {
tk = LEX_MINUSEQUAL;
getNextCh();
} else if (tk=='+' && currCh=='+') {
tk = LEX_PLUSPLUS;
getNextCh();
} else if (tk=='-' && currCh=='-') {
tk = LEX_MINUSMINUS;
getNextCh();
} else if (tk=='&' && currCh=='&') {
tk = LEX_ANDAND;
getNextCh();
} else if (tk=='|' && currCh=='|') {
tk = LEX_OROR;
getNextCh();
}
}
/* This isn't quite right yet */
tokenLastEnd = tokenEnd;
tokenEnd = dataPos-3;
}
string CScriptLex::getSubString(int lastPosition) {
int lastCharIdx = tokenLastEnd+1;
if (lastCharIdx < dataEnd) {
/* save a memory alloc by using our data array to create the
substring */
char old = data[lastCharIdx];
data[lastCharIdx] = 0;
std::string value = &data[lastPosition];
data[lastCharIdx] = old;
return value;
} else {
return std::string(&data[lastPosition]);
}
}
CScriptLex *CScriptLex::getSubLex(int lastPosition) {
int lastCharIdx = tokenLastEnd+1;
if (lastCharIdx < dataEnd)
return new CScriptLex( this, lastPosition, lastCharIdx);
else
return new CScriptLex( this, lastPosition, dataEnd );
}
string CScriptLex::getPosition(int pos) {
int line = 1,col = 1;
for (int i=0;i<pos;i++) {
char ch;
if (i < dataEnd)
ch = data[i];
else
ch = 0;
col++;
if (ch=='\n') {
line++;
col = 0;
}
}
char buf[256];
sprintf_s(buf, 256, "(line: %d, col: %d)", line, col);
return buf;
}
// ----------------------------------------------------------------------------------- CSCRIPTVAR
CScriptVar::CScriptVar(void) {
init();
name=TINYJS_TEMP_NAME;
data=TINYJS_BLANK_DATA;
flags = SCRIPTVAR_UNDEFINED;
}
CScriptVar::~CScriptVar(void) {
removeAllChildren();
}
CScriptVar::CScriptVar(string varName, string varData, int varFlags) {
init();
name = varName;
flags = varFlags;
data = varData;
}
CScriptVar::CScriptVar(double val) {
init();
setDouble(val);
}
CScriptVar::CScriptVar(int val) {
init();
setInt(val);
}
void CScriptVar::init() {
firstChild = 0;
lastChild = 0;
nextSibling = 0;
prevSibling = 0;
parent = 0;
flags = 0;
jsCallback = 0;
}
CScriptVar *CScriptVar::findChild(const string &childName) {
CScriptVar *v = firstChild;
while (v) {
if (v->name.compare(childName)==0)
return v;
v = v->nextSibling;
}
return 0;
}
CScriptVar *CScriptVar::findChildOrCreate(const string &childName) {
CScriptVar *v = findChild(childName);
if (!v) {
v = new CScriptVar(childName);
addChild(v);
}
return v;
}
CScriptVar *CScriptVar::findChildOrCreateByPath(const std::string &path) {
size_t p = path.find('.');
if (p == string::npos)
return findChildOrCreate(path);
return findChildOrCreate(path.substr(0,p))->
findChildOrCreateByPath(path.substr(p+1));
}
CScriptVar *CScriptVar::findRecursive(const string &childName) {
CScriptVar *v = findChild(childName);
if (!v && parent)
v = parent->findRecursive(childName);
return v;
}
void CScriptVar::addChild(CScriptVar *child) {
ASSERT(!child->parent && !child->nextSibling && !child->prevSibling);
child->parent = this;
if (lastChild) {
lastChild->nextSibling = child;
child->prevSibling = lastChild;
lastChild = child;
} else {
firstChild = child;
lastChild = child;
}
}
void CScriptVar::addNamedChild(const std::string &childName, CScriptVar *child) {
if (!child) {
// not given anything - just add empty child
addChild(new CScriptVar(childName));
} else if (child->parent) {
// current element has an owner, so copy it
CScriptVar *c = new CScriptVar(childName);
c->copyValue(child);
addChild(c);
} else {
// no owners - just change name and add it
child->name = childName;
addChild(child);
}
}
CScriptVar *CScriptVar::addChildNoDup(CScriptVar *child) {
ASSERT(!child->parent);
CScriptVar *v = findChild(child->getName());
if (v) {
v->copyValue(child);
delete child;
} else {
addChild(child);
v = child;
}
return v;
}
void CScriptVar::removeChild(CScriptVar *child) {
ASSERT(child->parent == this);
if (child->nextSibling)
child->nextSibling->prevSibling = child->prevSibling;
if (child->prevSibling)
child->prevSibling->nextSibling = child->nextSibling;
if (lastChild == child)
lastChild = child->prevSibling;
if (firstChild == child)
firstChild = child->nextSibling;
child->prevSibling = 0;
child->nextSibling = 0;
child->parent = 0;
}
void CScriptVar::removeAllChildren() {
CScriptVar *c = firstChild;
while (c) {
CScriptVar *t = c->nextSibling;
delete c;
c = t;
}
firstChild = 0;
lastChild = 0;
}
CScriptVar *CScriptVar::getRoot() {
CScriptVar *p = this;
while (p->parent) p = p->parent;
return p;
}
const string &CScriptVar::getName() {
return name;
}
int CScriptVar::getInt() {
/* strtol understands about hex and octal */
if (isInt()) return strtol(data.c_str(),0,0);
if (isNull()) return 0;
if (isUndefined()) return 0;
if (isDouble()) return (int)getDouble();
return 0;
}
double CScriptVar::getDouble() {
if (isDouble()) return strtod(data.c_str(),0);
if (isInt()) return getInt();
if (isNull()) return 0;
if (isUndefined()) return 0;
return 0; /* or NaN? */
}
const string &CScriptVar::getString() {
/* Because we can't return a string that is generated on demand.
* I should really just use char* :) */
static string s_null = "null";
static string s_undefined = "undefined";
if (isNull()) return s_null;
if (isUndefined()) return s_undefined;
return data;
}
void CScriptVar::setInt(int val) {
char buf[256];
sprintf(buf, "%d", val);
flags = (flags&~SCRIPTVAR_VARTYPEMASK) | SCRIPTVAR_INTEGER;
data = buf;
}
void CScriptVar::setDouble(double val) {
char buf[256];
sprintf(buf, "%lf", val);
flags = (flags&~SCRIPTVAR_VARTYPEMASK) | SCRIPTVAR_DOUBLE;
data = buf;
}
void CScriptVar::setString(const string &str) {
// name sure it's not still a number or integer
flags = (flags&~SCRIPTVAR_VARTYPEMASK) | SCRIPTVAR_STRING;
data = str;
}
void CScriptVar::setUndefined() {
// name sure it's not still a number or integer
flags = (flags&~SCRIPTVAR_VARTYPEMASK) | SCRIPTVAR_UNDEFINED;
data = TINYJS_BLANK_DATA;
removeAllChildren();
}
CScriptVar *CScriptVar::mathsOp(CScriptVar *b, int op) {
CScriptVar *a = this;
// TODO Equality checks on classes/structures
// Type equality check
if (op == LEX_TYPEEQUAL || op == LEX_NTYPEEQUAL) {
bool eql = ((a->flags & SCRIPTVAR_VARTYPEMASK) ==
(b->flags & SCRIPTVAR_VARTYPEMASK)) &&
a->data == b->data;
if (op == LEX_TYPEEQUAL)
return new CScriptVar(eql);
else
return new CScriptVar(!eql);
}
// do maths...
if (a->isUndefined() && b->isUndefined()) {
return new CScriptVar();
} else if ((a->isNumeric() || a->isUndefined()) &&
(b->isNumeric() || b->isUndefined())) {
if (!a->isDouble() && !b->isDouble()) {
// use ints
int da = a->getInt();
int db = b->getInt();
switch (op) {
case '+': return new CScriptVar(da+db);
case '-': return new CScriptVar(da-db);
case '*': return new CScriptVar(da*db);
case '/': return new CScriptVar(da/db);
case '&': return new CScriptVar(da&db);
case '|': return new CScriptVar(da|db);
case '^': return new CScriptVar(da^db);
case '%': return new CScriptVar(da%db);
case LEX_EQUAL: return new CScriptVar(da==db);
case LEX_NEQUAL: return new CScriptVar(da!=db);
case '<': return new CScriptVar(da<db);
case LEX_LEQUAL: return new CScriptVar(da<=db);
case '>': return new CScriptVar(da>db);
case LEX_GEQUAL: return new CScriptVar(da>=db);
default: throw new CScriptException("This operation not supported on the int datatype");
}
} else {
// use doubles
double da = a->getDouble();
double db = b->getDouble();
switch (op) {
case '+': return new CScriptVar(da+db);
case '-': return new CScriptVar(da-db);
case '*': return new CScriptVar(da*db);
case '/': return new CScriptVar(da/db);
case LEX_EQUAL: return new CScriptVar(da==db);
case LEX_NEQUAL: return new CScriptVar(da!=db);
case '<': return new CScriptVar(da<db);
case LEX_LEQUAL: return new CScriptVar(da<=db);
case '>': return new CScriptVar(da>db);
case LEX_GEQUAL: return new CScriptVar(da>=db);
default: throw new CScriptException("This operation not supported on the double datatype");
}
}
} else {
string da = a->getString();
string db = b->getString();
// use strings
switch (op) {
case '+': return new CScriptVar(TINYJS_TEMP_NAME, da+db, SCRIPTVAR_STRING);
case LEX_EQUAL: return new CScriptVar(da==db);
case LEX_NEQUAL: return new CScriptVar(da!=db);
case '<': return new CScriptVar(da<db);
case LEX_LEQUAL: return new CScriptVar(da<=db);
case '>': return new CScriptVar(da>db);
case LEX_GEQUAL: return new CScriptVar(da>=db);
default: throw new CScriptException("This operation not supported on the string datatype");
}
}
ASSERT(0);
return 0;
}
void CScriptVar::copyValue(CScriptVar *val) {
if (val) {
// we *don't* copy the name
data = val->data;
flags = (flags & ~SCRIPTVAR_VARTYPEMASK) | (val->flags & SCRIPTVAR_VARTYPEMASK);
// copy children
removeAllChildren();
CScriptVar *child = val->firstChild;
while (child) {
addChild(child->deepCopy());
child = child->nextSibling;
}
} else {
setUndefined();
}
}
CScriptVar *CScriptVar::deepCopy() {
CScriptVar *newVar = new CScriptVar(name, data, flags);
// copy children
CScriptVar *child = firstChild;
while (child) {
newVar->addChild(child->deepCopy());
child = child->nextSibling;
}
return newVar;
}
void CScriptVar::trace(string indentStr) {
TRACE("%s'%s' = '%s' %s\n",
indentStr.c_str(),
name.c_str(),
data.c_str(),
getFlagsAsString().c_str());
string indent = indentStr+" ";
CScriptVar *child = firstChild;
while (child) {
child->trace(indent);
child = child->nextSibling;
}
}
string CScriptVar::getFlagsAsString() {
string flagstr = "";
if (flags&SCRIPTVAR_FUNCTION) flagstr = flagstr + "FUNCTION ";
if (flags&SCRIPTVAR_PARAMETER) flagstr = flagstr + "PARAMETER ";
if (flags&SCRIPTVAR_NATIVE) flagstr = flagstr + "NATIVE ";
if (flags&SCRIPTVAR_DOUBLE) flagstr = flagstr + "DOUBLE ";
if (flags&SCRIPTVAR_INTEGER) flagstr = flagstr + "INTEGER ";
if (flags&SCRIPTVAR_STRING) flagstr = flagstr + "STRING ";
return flagstr;
}
string CScriptVar::getParsableString() {
// Numbers can just be put in directly
if (isNumeric())
return getString();
if (isFunction()) {
ostringstream funcStr;
funcStr << "function (";
// get list of parameters
CScriptVar *child = firstChild;
bool first = true;
while (child) {
if (child->isParameter()) {
if (!first) { funcStr << ","; first = false; }
funcStr << child->getName();
}
child = child->nextSibling;
}
// add function body
funcStr << ")" << getString();
return funcStr.str();
}
// if it is a string then we quote it
if (isString())
return getJSString(getString());
if (isNull())
return "null";
return "undefined";
}
void CScriptVar::getJSON(ostringstream &destination) {
if (firstChild) {
// children - handle with bracketed list
destination << " { \n";
CScriptVar *child = firstChild;
while (child) {
destination << getJSString(child->name) << " : ";
child->getJSON(destination);
child = child->nextSibling;
if (child)
destination << ",\n";
else
destination << "\n";
}
destination << " }\n";
} else {
// no children, just write value directly
destination << getParsableString();
}
}
void CScriptVar::setCallback(JSCallback callback) {
jsCallback = callback;
}
// ----------------------------------------------------------------------------------- CSCRIPT
CTinyJS::CTinyJS() {
l = 0;
root = symbol_base = new CScriptVar("root", "");
}
CTinyJS::~CTinyJS() {
ASSERT(!l);
symbol_base = 0;
delete root;
}
void CTinyJS::trace() {
root->trace();
}
void CTinyJS::execute(const string &code) {
CScriptLex *oldLex = l;
l = new CScriptLex(code);
symbol_base = root;
try {
bool execute = true;
while (l->tk) statement(execute);
} catch (CScriptException *e) {
ostringstream msg;
msg << "Error " << e->text << " at " << l->getPosition(l->tokenLastEnd);
delete l;
l = oldLex;
throw new CScriptException(msg.str());
}
delete l;
l = oldLex;
}
string CTinyJS::evaluate(const string &code) {
CScriptLex *oldLex = l;
l = new CScriptLex(code);
symbol_base = root;
CScriptVar *v = 0;
try {
bool execute = true;
v = base(execute);
} catch (CScriptException *e) {
ostringstream msg;
msg << "Error " << e->text << " at " << l->getPosition(l->tokenLastEnd);
delete l;
l = oldLex;
throw new CScriptException(msg.str());
}
delete l;
l = oldLex;
string result = v ? v->getString() : "";
CLEAN(v);
return result;
}
void CTinyJS::parseFunctionArguments(CScriptVar *funcVar) {
l->match('(');
while (l->tk!=')') {
CScriptVar *funcParam = new CScriptVar(l->tkStr, "", SCRIPTVAR_PARAMETER);
funcVar->addChildNoDup(funcParam);
l->match(LEX_ID);
if (l->tk!=')') l->match(',');
}
l->match(')');
}
void CTinyJS::addNative(const string &funcDesc, JSCallback ptr) {
CScriptLex *oldLex = l;
l = new CScriptLex(funcDesc);
l->match(LEX_R_FUNCTION);
CScriptVar *funcVar = new CScriptVar(l->tkStr, "", SCRIPTVAR_FUNCTION | SCRIPTVAR_NATIVE);
funcVar->setCallback(ptr);
l->match(LEX_ID);
parseFunctionArguments(funcVar);
delete l;
l = oldLex;
root->addChild(funcVar);
}
CScriptVar *CTinyJS::parseFunctionDefinition() {
// actually parse a function...
l->match(LEX_R_FUNCTION);
string funcName = TINYJS_TEMP_NAME;
/* we can have functions without names */
if (l->tk==LEX_ID) {
funcName = l->tkStr;
l->match(LEX_ID);
}
CScriptVar *funcVar = new CScriptVar(funcName, "", SCRIPTVAR_FUNCTION);
parseFunctionArguments(funcVar);
int funcBegin = l->tokenStart;
bool noexecute = false;
block(noexecute);
funcVar->data = l->getSubString(funcBegin);
return funcVar;
}
CScriptVar *CTinyJS::factor(bool &execute) {
if (l->tk=='(') {
l->match('(');
CScriptVar *a = base(execute);
l->match(')');
return a;
}
if (l->tk==LEX_R_TRUE) {
l->match(LEX_R_TRUE);
return new CScriptVar(1);
}
if (l->tk==LEX_R_FALSE) {
l->match(LEX_R_FALSE);
return new CScriptVar(0);
}
if (l->tk==LEX_R_NULL) {
l->match(LEX_R_NULL);
return new CScriptVar("","",SCRIPTVAR_NULL);
}
if (l->tk==LEX_R_UNDEFINED) {
l->match(LEX_R_UNDEFINED);
return new CScriptVar("","",SCRIPTVAR_UNDEFINED);
}
if (l->tk==LEX_ID) {
CScriptVar *a = symbol_base->findRecursive(l->tkStr);
if (!a) {
/* Variable doesn't exist! JavaScript says we should create it
* (we won't add it here. This is done in the assignment operator)*/
a = new CScriptVar(l->tkStr);
}
l->match(LEX_ID);
while (l->tk=='(' || l->tk=='.' || l->tk=='[') {
if (l->tk=='(') { // ------------------------------------- Function Call
if (!a->isFunction()) {
string errorMsg = "Expecting '";
errorMsg = errorMsg + a->getName() + "' to be a function";
throw new CScriptException(errorMsg.c_str());
}
l->match('(');
// create a new symbol table entry for execution of this function
CScriptVar *functionRoot = new CScriptVar("__EXECUTESTACK__", "", SCRIPTVAR_FUNCTION);
// grab in all parameters
CScriptVar *v = a->firstChild;
while (v) {
if (v->isParameter()) {
CScriptVar *value = base(execute);
if (execute) {
CScriptVar *param = new CScriptVar(v->getName(), "", SCRIPTVAR_PARAMETER);
param->copyValue(value);
functionRoot->addChild(param);
}
CLEAN(value);
if (l->tk!=')') l->match(',');
}
v = v->nextSibling;
}
l->match(')');
// setup a return variable
CScriptVar *returnVar = new CScriptVar(TINYJS_RETURN_VAR, "");
// execute function!
if (execute) {
// add the function's execute space to the symbol table so we can recurse
CScriptVar *old_symbol_base = symbol_base;
symbol_base->addChild(functionRoot);
functionRoot->addChild(returnVar);
symbol_base = functionRoot;
if (a->isNative()) {
ASSERT(a->jsCallback);
a->jsCallback(functionRoot);
} else {
CScriptLex *oldLex = l;
fflush(stdout);
l = new CScriptLex(a->getString());
block(execute);
// because return will probably have called this, and set execute to false
execute = true;
delete l;
l = oldLex;
}
symbol_base = old_symbol_base;
symbol_base->removeChild(functionRoot);
functionRoot->removeChild(returnVar);
}
delete functionRoot;
a = returnVar;
} else if (l->tk == '.') { // ------------------------------------- Record Access
l->match('.');
CScriptVar *child = a->findRecursive(l->tkStr);
if (!child) {
// TODO: Error here if this doesn't exist??
child = new CScriptVar(l->tkStr, "");
a->addChild(child);
}
l->match(LEX_ID);
a = child;
} else if (l->tk == '[') { // ------------------------------------- Array Access
l->match('[');
CScriptVar *index = expression(execute);
l->match(']');
CScriptVar *child = a->findRecursive(index->getString());
if (!child) {
child = new CScriptVar(index->getString(), "");
a->addChild(child);
}
CLEAN(index);
a = child;
} else ASSERT(0);
}
return a;
}
if (l->tk==LEX_INT || l->tk==LEX_FLOAT) {
CScriptVar *a = new CScriptVar(
TINYJS_TEMP_NAME, l->tkStr,
((l->tk==LEX_INT)?SCRIPTVAR_INTEGER:SCRIPTVAR_DOUBLE));
l->match(l->tk);
return a;
}
if (l->tk==LEX_STR) {
CScriptVar *a = new CScriptVar(TINYJS_TEMP_NAME, l->tkStr, SCRIPTVAR_STRING);
l->match(LEX_STR);
return a;
}
if (l->tk=='{') {
CScriptVar *contents = new CScriptVar();
/* JSON-style object definition */
l->match('{');
while (l->tk != '}') {
string id = l->tkStr;
// we only allow strings or IDs on the left hand side of an initialisation
if (l->tk==LEX_STR) l->match(LEX_STR);
else l->match(LEX_ID);
l->match(':');
CScriptVar *a = base(execute);
contents->addNamedChild(id, a);
// no need to clean here, as it will definitely be used
if (l->tk != '}') l->match(',');
}
l->match('}');
return contents;
}
if (l->tk=='[') {
CScriptVar *contents = new CScriptVar();
/* JSON-style array */
l->match('[');
int idx = 0;
while (l->tk != ']') {
char idx_str[16]; // big enough for 2^32
sprintf(idx_str,"%d",idx);
CScriptVar *a = base(execute);
contents->addNamedChild(idx_str, a);
// no need to clean here, as it will definitely be used
if (l->tk != ']') l->match(',');
idx++;
}
l->match(']');
return contents;
}
if (l->tk==LEX_R_FUNCTION) {
CScriptVar *funcVar = parseFunctionDefinition();
if (funcVar->name != TINYJS_TEMP_NAME)
TRACE("Functions not defined at statement-level are not meant to have a name");
return funcVar;
}
// Nothing we can do here... just hope it's the end...
l->match(LEX_EOF);
return new CScriptVar();
}
CScriptVar *CTinyJS::unary(bool &execute) {
CScriptVar *a;
if (l->tk=='!') {
l->match('!'); // binary not
a = factor(execute);
if (execute) {
CScriptVar zero(0);
CScriptVar *res = a->mathsOp(&zero, LEX_EQUAL);
CLEAN(a);
a = res;
}
} else
a = factor(execute);
return a;
}
CScriptVar *CTinyJS::term(bool &execute) {
CScriptVar *a = unary(execute);
while (l->tk=='*' || l->tk=='/') {
int op = l->tk;
l->match(l->tk);
CScriptVar *b = unary(execute);
if (execute) {
CScriptVar *res = a->mathsOp(b, op);
CLEAN(a);
CLEAN(b);
a = res;
} else {
CLEAN(b);
}
}
return a;
}
CScriptVar *CTinyJS::expression(bool &execute) {
bool negate = false;
if (l->tk=='-') {
l->match('-');
negate = true;
}
CScriptVar *a = term(execute);
if (negate) {
CScriptVar *zero = new CScriptVar(0);
CScriptVar *res = zero->mathsOp(a, '-');
CLEAN(a);
CLEAN(zero);
a = res;
}
while (l->tk=='+' || l->tk=='-' ||
l->tk==LEX_PLUSPLUS || l->tk==LEX_MINUSMINUS) {
int op = l->tk;
l->match(l->tk);
if (op==LEX_PLUSPLUS || op==LEX_MINUSMINUS) {
if (execute) {
CScriptVar one(1);
CScriptVar *res = a->mathsOp(&one, op==LEX_PLUSPLUS ? '+' : '-');
a->copyValue(res);
CLEAN(res);
}
} else {
CScriptVar *b = term(execute);
if (execute) {
CScriptVar *res = a->mathsOp(b, op);
CLEAN(a);
CLEAN(b);
a = res;
} else {
CLEAN(b);
}
}
}
return a;
}
CScriptVar *CTinyJS::condition(bool &execute) {
CScriptVar *a = expression(execute);
CScriptVar *b;
while (l->tk==LEX_EQUAL || l->tk==LEX_NEQUAL ||
l->tk==LEX_TYPEEQUAL || l->tk==LEX_NTYPEEQUAL ||
l->tk==LEX_LEQUAL || l->tk==LEX_GEQUAL ||
l->tk=='<' || l->tk=='>') {
int op = l->tk;
l->match(l->tk);
b = expression(execute);
if (execute) {
CScriptVar *res = a->mathsOp(b, op);
CLEAN(a);
CLEAN(b);
a = res;
} else {
CLEAN(b);
}
}
return a;
}
CScriptVar *CTinyJS::logic(bool &execute) {
CScriptVar *a = condition(execute);
CScriptVar *b;
while (l->tk=='&' || l->tk=='|' || l->tk=='^' || l->tk==LEX_ANDAND || l->tk==LEX_OROR) {
bool noexecute = false;
int op = l->tk;
l->match(l->tk);
bool shortCircuit = false;
bool boolean = false;
// if we have short-circuit ops, then if we know the outcome
// we don't bother to execute the other op. Even if not
// we need to tell mathsOp it's an & or |
if (op==LEX_ANDAND) {
op = '&';
shortCircuit = !a->getBool();
boolean = true;
} else if (op==LEX_OROR) {
op = '|';
shortCircuit = a->getBool();
boolean = true;
}
b = condition(shortCircuit ? noexecute : execute);
if (execute && !shortCircuit) {
if (boolean) {
CScriptVar *newa = new CScriptVar(a->getBool());
CScriptVar *newb = new CScriptVar(b->getBool());
CLEAN(a);
CLEAN(b);
a = newa;
b = newb;
}
CScriptVar *res = a->mathsOp(b, op);
CLEAN(a);
CLEAN(b);
a = res;
} else {
CLEAN(b);
}
}
return a;
}
CScriptVar *CTinyJS::base(bool &execute) {
CScriptVar *lhs = logic(execute);
if (l->tk=='=' || l->tk==LEX_PLUSEQUAL || l->tk==LEX_MINUSEQUAL) {
/* If we're assigning to this and we don't have a parent,
* add it to the symbol table root as per JavaScript. */
if (!lhs->parent) {
if (lhs->name.length()>0)
root->addChildNoDup(lhs);
else
TRACE("Trying to assign to an un-named type\n");
}
int op = l->tk;
l->match(l->tk);
CScriptVar *rhs = base(execute);
if (execute) {
if (op=='=') {
lhs->copyValue(rhs);
} else if (op==LEX_PLUSEQUAL) {
CScriptVar *res = lhs->mathsOp(rhs, '+');
lhs->copyValue(res);
CLEAN(res);
} else if (op==LEX_MINUSEQUAL) {
CScriptVar *res = lhs->mathsOp(rhs, '-');
lhs->copyValue(res);
CLEAN(res);
} else ASSERT(0);
}
CLEAN(rhs);
}
return lhs;
}
void CTinyJS::block(bool &execute) {
// TODO: fast skip of blocks
l->match('{');
if (execute) {
while (l->tk && l->tk!='}')
statement(execute);
l->match('}');
} else {
int brackets = 1;
while (l->tk && brackets) {
if (l->tk == '{') brackets++;
if (l->tk == '}') brackets--;
l->match(l->tk);
}
}
}
void CTinyJS::statement(bool &execute) {
if (l->tk==LEX_ID ||
l->tk==LEX_INT ||
l->tk==LEX_FLOAT ||
l->tk==LEX_STR ||
l->tk=='-') {
/* Execute a simple statement that only contains basic arithmetic... */
CLEAN(base(execute));
l->match(';');
} else if (l->tk=='{') {
/* A block of code */
block(execute);
} else if (l->tk==';') {
/* Empty statement - to allow things like ;;; */
l->match(';');
} else if (l->tk==LEX_R_VAR) {
/* variable creation. TODO - we need a better way of parsing the left
* hand side. Maybe just have a flag called can_create_var that we
* set and then we parse as if we're doing a normal equals.*/
l->match(LEX_R_VAR);
CScriptVar *a = 0;
if (execute)
a = symbol_base->findChildOrCreate(l->tkStr);
l->match(LEX_ID);
// now do stuff defined with dots
while (l->tk == '.') {
l->match('.');
if (execute) {
CScriptVar *lastA = a;
a = lastA->findChildOrCreate(l->tkStr);
}
l->match(LEX_ID);
}
// sort out initialiser
if (l->tk == '=') {
l->match('=');
CScriptVar *var = base(execute);
if (execute)
a->copyValue(var);
CLEAN(var);
}
l->match(';');
} else if (l->tk==LEX_R_IF) {
l->match(LEX_R_IF);
l->match('(');
CScriptVar *var = base(execute);
l->match(')');
bool cond = execute && var->getBool();
CLEAN(var);
bool noexecute = false; // because we need to be abl;e to write to it
statement(cond ? execute : noexecute);
if (l->tk==LEX_R_ELSE) {
l->match(LEX_R_ELSE);
statement(cond ? noexecute : execute);
}
} else if (l->tk==LEX_R_WHILE) {
// We do repetition by pulling out the string representing our statement
// there's definitely some opportunity for optimisation here
l->match(LEX_R_WHILE);
l->match('(');
int whileCondStart = l->tokenStart;
bool noexecute = false;
CScriptVar *cond = base(execute);
bool loopCond = execute && cond->getBool();
CLEAN(cond);
CScriptLex *whileCond = l->getSubLex(whileCondStart);
l->match(')');
int whileBodyStart = l->tokenStart;
statement(loopCond ? execute : noexecute);
CScriptLex *whileBody = l->getSubLex(whileBodyStart);
CScriptLex *oldLex = l;
int loopCount = TINYJS_LOOP_MAX_ITERATIONS;
while (loopCond && loopCount-->0) {
whileCond->reset();
l = whileCond;
cond = base(execute);
loopCond = execute && cond->getBool();
CLEAN(cond);
if (loopCond) {
whileBody->reset();
l = whileBody;
statement(execute);
}
}
l = oldLex;
delete whileCond;
delete whileBody;
if (loopCount<=0) {
root->trace();
TRACE("WHILE Loop exceeded %d iterations at %s\n", TINYJS_LOOP_MAX_ITERATIONS, l->getPosition(l->tokenLastEnd).c_str());
throw new CScriptException("LOOP_ERROR");
}
} else if (l->tk==LEX_R_FOR) {
l->match(LEX_R_FOR);
l->match('(');
statement(execute); // initialisation
//l->match(';');
int forCondStart = l->tokenStart;
bool noexecute = false;
CScriptVar *cond = base(execute); // condition
bool loopCond = execute && cond->getBool();
CLEAN(cond);
CScriptLex *forCond = l->getSubLex(forCondStart);
l->match(';');
int forIterStart = l->tokenStart;
base(noexecute); // iterator
CScriptLex *forIter = l->getSubLex(forIterStart);
l->match(')');
int forBodyStart = l->tokenStart;
statement(loopCond ? execute : noexecute);
CScriptLex *forBody = l->getSubLex(forBodyStart);
CScriptLex *oldLex = l;
if (loopCond) {
forIter->reset();
l = forIter;
base(execute);
}
int loopCount = TINYJS_LOOP_MAX_ITERATIONS;
while (execute && loopCond && loopCount-->0) {
forCond->reset();
l = forCond;
cond = base(execute);
loopCond = cond->getBool();
CLEAN(cond);
if (execute && loopCond) {
forBody->reset();
l = forBody;
statement(execute);
}
if (execute && loopCond) {
forIter->reset();
l = forIter;
base(execute);
}
}
l = oldLex;
delete forCond;
delete forIter;
delete forBody;
if (loopCount<=0) {
root->trace();
TRACE("FOR Loop exceeded %d iterations at %s\n", TINYJS_LOOP_MAX_ITERATIONS, l->getPosition(l->tokenLastEnd).c_str());
throw new CScriptException("LOOP_ERROR");
}
} else if (l->tk==LEX_R_RETURN) {
l->match(LEX_R_RETURN);
CScriptVar *result = 0;
if (l->tk != ';')
result = base(execute);
if (execute) {
CScriptVar *resultVar = symbol_base->findChild(TINYJS_RETURN_VAR);
ASSERT(resultVar);
resultVar->copyValue(result);
execute = false;
}
CLEAN(result);
l->match(';');
} else if (l->tk==LEX_R_FUNCTION) {
CScriptVar *funcVar = parseFunctionDefinition();
if (execute) {
if (funcVar->name == TINYJS_TEMP_NAME)
TRACE("Functions defined at statement-level are meant to have a name");
else
symbol_base->addChildNoDup(funcVar);
} else
CLEAN(funcVar);
} else l->match(LEX_EOF);
}
/// Get the value of the given variable, or return 0
const string *CTinyJS::getVariable(const string &path) {
// traverse path
size_t prevIdx = 0;
size_t thisIdx = path.find('.');
if (thisIdx == string::npos) thisIdx = path.length();
CScriptVar *var = root;
while (var && prevIdx<path.length()) {
string el = path.substr(prevIdx, thisIdx-prevIdx);
var = var->findChild(el);
prevIdx = thisIdx+1;
thisIdx = path.find('.', prevIdx);
if (thisIdx == string::npos) thisIdx = path.length();
}
// return result
if (var)
return &var->getString();
else
return 0;
}
Reference in new issue View Git Blame Copy Permalink