[Avida-SVN] r1789 - development/source/script
brysonda at myxo.css.msu.edu
brysonda at myxo.css.msu.edu
Wed Jul 11 14:37:30 PDT 2007
Author: brysonda
Date: 2007-07-11 17:37:30 -0400 (Wed, 11 Jul 2007)
New Revision: 1789
Modified:
development/source/script/ASTree.cc
development/source/script/ASTree.h
development/source/script/AvidaScript.h
development/source/script/cLexer.l
development/source/script/cParser.cc
Log:
AS: Assignment and variable declaration nodes. Prefix token enum values to avoid future clashes. Add type enum.
Modified: development/source/script/ASTree.cc
===================================================================
--- development/source/script/ASTree.cc 2007-07-11 18:30:11 UTC (rev 1788)
+++ development/source/script/ASTree.cc 2007-07-11 21:37:30 UTC (rev 1789)
@@ -44,3 +44,11 @@
void cASTFunctionCall::Accept(cASTVisitor& visitor) { visitor.visitFunctionCall(*this); }
void cASTLiteral::Accept(cASTVisitor& visitor) { visitor.visitLiteral(*this); }
void cASTVariableReference::Accept(cASTVisitor& visitor) { visitor.visitVariableReference(*this); }
+
+
+cASTStatementList::~cASTStatementList()
+{
+ cASTNode* node = NULL;
+ tListIterator<cASTNode> it(m_nodes);
+ while ((node = it.Next())) delete node;
+}
Modified: development/source/script/ASTree.h
===================================================================
--- development/source/script/ASTree.h 2007-07-11 18:30:11 UTC (rev 1788)
+++ development/source/script/ASTree.h 2007-07-11 21:37:30 UTC (rev 1789)
@@ -28,9 +28,15 @@
#ifndef AvidaScript_h
#include "AvidaScript.h"
#endif
+#ifndef cString_h
+#include "cString.h"
+#endif
#ifndef defs_h
#include "defs.h"
#endif
+#ifndef tList_h
+#include "tList.h"
+#endif
class cASTVisitor;
@@ -67,10 +73,14 @@
class cASTAssignment : public cASTNode
{
private:
+ cString m_var;
+ cASTNode* m_expr;
public:
- cASTAssignment() { ; }
+ cASTAssignment(const cString& var) : m_var(var), m_expr(NULL) { ; }
+ void SetExpression(cASTNode* expr) { delete m_expr; m_expr = expr; }
+
void Accept(cASTVisitor& visitor);
};
@@ -81,10 +91,14 @@
class cASTStatementList : public cASTNode
{
private:
+ tList<cASTNode> m_nodes;
public:
cASTStatementList() { ; }
+ ~cASTStatementList();
+ void AddNode(cASTNode* n) { m_nodes.PushRear(n); }
+
void Accept(cASTVisitor& visitor);
};
@@ -144,10 +158,15 @@
class cASTVariableDefinition : public cASTNode
{
private:
+ ASType_t m_type;
+ cString m_var;
+ cASTNode* m_assign;
public:
- cASTVariableDefinition() { ; }
+ cASTVariableDefinition(ASType_t type, const cString& var) : m_type(type), m_var(var), m_assign(NULL) { ; }
+ void SetAssignment(cASTNode* assign) { delete m_assign; m_assign = assign; }
+
void Accept(cASTVisitor& visitor);
};
Modified: development/source/script/AvidaScript.h
===================================================================
--- development/source/script/AvidaScript.h 2007-07-11 18:30:11 UTC (rev 1788)
+++ development/source/script/AvidaScript.h 2007-07-11 21:37:30 UTC (rev 1789)
@@ -26,83 +26,84 @@
#define AvidaScript_h
typedef enum eASTokens {
- SUPPRESS = 1,
- ENDL,
- COMMA,
+ AS_TOKEN_SUPPRESS = 1,
+ AS_TOKEN_ENDL,
+ AS_TOKEN_COMMA,
- OP_BIT_NOT, // 4
- OP_BIT_AND,
- OP_BIT_OR,
+ AS_TOKEN_OP_BIT_NOT, // 4
+ AS_TOKEN_OP_BIT_AND,
+ AS_TOKEN_OP_BIT_OR,
- OP_LOGIC_NOT, // 7
- OP_LOGIC_AND,
- OP_LOGIC_OR,
+ AS_TOKEN_OP_LOGIC_NOT, // 7
+ AS_TOKEN_OP_LOGIC_AND,
+ AS_TOKEN_OP_LOGIC_OR,
- OP_ADD, // 10
- OP_SUB,
- OP_MUL,
- OP_DIV,
- OP_MOD,
+ AS_TOKEN_OP_ADD, // 10
+ AS_TOKEN_OP_SUB,
+ AS_TOKEN_OP_MUL,
+ AS_TOKEN_OP_DIV,
+ AS_TOKEN_OP_MOD,
- DOT, // 15
- ASSIGN,
- REF,
+ AS_TOKEN_DOT, // 15
+ AS_TOKEN_ASSIGN,
+ AS_TOKEN_REF,
- OP_EQ, // 18
- OP_LE,
- OP_GE,
- OP_LT,
- OP_GT,
- OP_NEQ,
+ AS_TOKEN_OP_EQ, // 18
+ AS_TOKEN_OP_LE,
+ AS_TOKEN_OP_GE,
+ AS_TOKEN_OP_LT,
+ AS_TOKEN_OP_GT,
+ AS_TOKEN_OP_NEQ,
- PREC_OPEN, // 24
- PREC_CLOSE,
+ AS_TOKEN_PREC_OPEN, // 24
+ AS_TOKEN_PREC_CLOSE,
- IDX_OPEN, // 26
- IDX_CLOSE,
+ AS_TOKEN_IDX_OPEN, // 26
+ AS_TOKEN_IDX_CLOSE,
- ARR_OPEN, // 28
- ARR_CLOSE,
- ARR_RANGE,
- ARR_EXPAN,
- ARR_WILD,
+ AS_TOKEN_ARR_OPEN, // 28
+ AS_TOKEN_ARR_CLOSE,
+ AS_TOKEN_ARR_RANGE,
+ AS_TOKEN_ARR_EXPAN,
+ AS_TOKEN_ARR_WILD,
- MAT_MODIFY, // 33
+ AS_TOKEN_MAT_MODIFY, // 33
- TYPE_ARRAY, // 34
- TYPE_CHAR,
- TYPE_FLOAT,
- TYPE_INT,
- TYPE_MATRIX,
- TYPE_STRING,
- TYPE_VOID,
+ AS_TOKEN_TYPE_ARRAY, // 34
+ AS_TOKEN_TYPE_CHAR,
+ AS_TOKEN_TYPE_FLOAT,
+ AS_TOKEN_TYPE_INT,
+ AS_TOKEN_TYPE_MATRIX,
+ AS_TOKEN_TYPE_STRING,
+ AS_TOKEN_TYPE_VOID,
- CMD_IF, // 41
- CMD_ELSE,
- CMD_ENDIF,
+ AS_TOKEN_CMD_IF, // 41
+ AS_TOKEN_CMD_ELSE,
+ AS_TOKEN_CMD_ENDIF,
- CMD_WHILE, // 44
- CMD_ENDWHILE,
+ AS_TOKEN_CMD_WHILE, // 44
+ AS_TOKEN_CMD_ENDWHILE,
- CMD_FOREACH, // 46
- CMD_ENDFOREACH,
+ AS_TOKEN_CMD_FOREACH, // 46
+ AS_TOKEN_CMD_ENDFOREACH,
- CMD_FUNCTION, // 48
- CMD_ENDFUNCTION,
+ AS_TOKEN_CMD_FUNCTION, // 48
+ AS_TOKEN_CMD_ENDFUNCTION,
- CMD_RETURN, // 50
+ AS_TOKEN_CMD_RETURN, // 50
- ID, // 51
+ AS_TOKEN_ID, // 51
- FLOAT, // 52
- INT,
- STRING,
- CHAR,
+ AS_TOKEN_FLOAT, // 52
+ AS_TOKEN_INT,
+ AS_TOKEN_STRING,
+ AS_TOKEN_CHAR,
- UNKNOWN, // 56
- INVALID
+ AS_TOKEN_UNKNOWN, // 56
+ AS_TOKEN_INVALID
} ASToken_t;
+
typedef enum eASParseErrors {
AS_PARSE_ERR_UNEXPECTED_TOKEN,
AS_PARSE_ERR_UNTERMINATED_EXPR,
@@ -110,7 +111,22 @@
AS_PARSE_ERR_EOF,
AS_PARSE_ERR_EMPTY,
AS_PARSE_ERR_INTERNAL,
+
AS_PARSE_ERR_UNKNOWN
} ASParseError_t;
+
+typedef enum eASTypes {
+ AS_TYPE_ARRAY = 0,
+ AS_TYPE_CHAR,
+ AS_TYPE_FLOAT,
+ AS_TYPE_INT,
+ AS_TYPE_MATRIX,
+ AS_TYPE_STRING,
+ AS_TYPE_VOID,
+ AS_TYPE_OBJECT_REF,
+
+ AS_TYPE_INVALID
+} ASType_t;
+
#endif
Modified: development/source/script/cLexer.l
===================================================================
--- development/source/script/cLexer.l 2007-07-11 18:30:11 UTC (rev 1788)
+++ development/source/script/cLexer.l 2007-07-11 21:37:30 UTC (rev 1789)
@@ -42,81 +42,81 @@
[ \t]+ /* ignore whitespace */
-; return SUPPRESS; // End-of-line
-\n return ENDL;
-, return COMMA;
+; return AS_TOKEN_SUPPRESS; // End-of-line
+\n return AS_TOKEN_ENDL;
+, return AS_TOKEN_COMMA;
-~ return OP_BIT_NOT; // Bitwise Operators
-& return OP_BIT_AND;
-\| return OP_BIT_OR;
+~ return AS_TOKEN_OP_BIT_NOT; // Bitwise Operators
+& return AS_TOKEN_OP_BIT_AND;
+\| return AS_TOKEN_OP_BIT_OR;
-! return OP_LOGIC_NOT; // Logic Operators
-&& return OP_LOGIC_AND;
-\|\| return OP_LOGIC_OR;
+! return AS_TOKEN_OP_LOGIC_NOT; // Logic Operators
+&& return AS_TOKEN_OP_LOGIC_AND;
+\|\| return AS_TOKEN_OP_LOGIC_OR;
-\+ return OP_ADD; // Arithmetic Operators
-- return OP_SUB;
-\* return OP_MUL;
-\/ return OP_DIV;
-% return OP_MOD;
+\+ return AS_TOKEN_OP_ADD; // Arithmetic Operators
+- return AS_TOKEN_OP_SUB;
+\* return AS_TOKEN_OP_MUL;
+\/ return AS_TOKEN_OP_DIV;
+% return AS_TOKEN_OP_MOD;
-\. return DOT;
-= return ASSIGN; // Assignment
-@ return REF;
+\. return AS_TOKEN_DOT;
+= return AS_TOKEN_ASSIGN; // Assignment
+@ return AS_TOKEN_REF;
-== return OP_EQ; // Relational Operators
-\<= return OP_LE;
-\>= return OP_GE;
-\< return OP_LT;
-\> return OP_GT;
-!= return OP_NEQ;
+== return AS_TOKEN_OP_EQ; // Relational Operators
+\<= return AS_TOKEN_OP_LE;
+\>= return AS_TOKEN_OP_GE;
+\< return AS_TOKEN_OP_LT;
+\> return AS_TOKEN_OP_GT;
+!= return AS_TOKEN_OP_NEQ;
-\( return PREC_OPEN; // Precedence Grouping
-\) return PREC_CLOSE;
+\( return AS_TOKEN_PREC_OPEN; // Precedence Grouping
+\) return AS_TOKEN_PREC_CLOSE;
-\[ return IDX_OPEN; // Index Grouping
-\] return IDX_CLOSE;
+\[ return AS_TOKEN_IDX_OPEN; // Index Grouping
+\] return AS_TOKEN_IDX_CLOSE;
-\{ return ARR_OPEN; // Array Definition Grouping
-\} return ARR_CLOSE;
-: return ARR_RANGE;
-\^ return ARR_EXPAN;
-\.\. return ARR_WILD;
+\{ return AS_TOKEN_ARR_OPEN; // Array Definition Grouping
+\} return AS_TOKEN_ARR_CLOSE;
+: return AS_TOKEN_ARR_RANGE;
+\^ return AS_TOKEN_ARR_EXPAN;
+\.\. return AS_TOKEN_ARR_WILD;
-\? return MAT_MODIFY; // Matrix Modifier
+\? return AS_TOKEN_MAT_MODIFY; // Matrix Modifier
-array return TYPE_ARRAY; // Built-in Types
-char return TYPE_CHAR;
-float return TYPE_FLOAT;
-int return TYPE_INT;
-matrix return TYPE_MATRIX;
-string return TYPE_STRING;
-void return TYPE_VOID;
+array return AS_TOKEN_TYPE_ARRAY; // Built-in Types
+char return AS_TOKEN_TYPE_CHAR;
+float return AS_TOKEN_TYPE_FLOAT;
+int return AS_TOKEN_TYPE_INT;
+matrix return AS_TOKEN_TYPE_MATRIX;
+string return AS_TOKEN_TYPE_STRING;
+void return AS_TOKEN_TYPE_VOID;
-if return CMD_IF; // If Blocks
-else return CMD_ELSE;
-endif return CMD_ENDIF;
+if return AS_TOKEN_CMD_IF; // If Blocks
+else return AS_TOKEN_CMD_ELSE;
+endif return AS_TOKEN_CMD_ENDIF;
-while return CMD_WHILE; // While Blocks
-endwhile return CMD_ENDWHILE;
+while return AS_TOKEN_CMD_WHILE; // While Blocks
+endwhile return AS_TOKEN_CMD_ENDWHILE;
-foreach return CMD_FOREACH; // Foreach Blocks
-endforeach return CMD_ENDFOREACH;
+foreach return AS_TOKEN_CMD_FOREACH; // Foreach Blocks
+endforeach return AS_TOKEN_CMD_ENDFOREACH;
-function return CMD_FUNCTION; // Function Blocks
-endfunction return CMD_ENDFUNCTION;
+function return AS_TOKEN_CMD_FUNCTION; // Function Blocks
+endfunction return AS_TOKEN_CMD_ENDFUNCTION;
-return return CMD_RETURN;
+return return AS_TOKEN_CMD_RETURN;
-([a-zA-Z]|_+[a-zA-Z])[a-zA-Z0-9_]* return ID; // Identifiers
+([a-zA-Z]|_+[a-zA-Z])[a-zA-Z0-9_]* return AS_TOKEN_ID; // Identifiers
-[0-9]*\.[0-9]+([eE][-+]?[0-9]+)? return FLOAT; // Literal Values
-[0-9]+ return INT;
-\"\" return STRING;
-\"([^"\\\n]|\\\"|\\\\|\\.)*\" return STRING;
-\'([^'\\\n]|\\\'|\\\\)\' return CHAR;
+[0-9]*\.[0-9]+([eE][-+]?[0-9]+)? return AS_TOKEN_FLOAT; // Literal Values
+[0-9]+ return AS_TOKEN_INT;
+\"\" return AS_TOKEN_STRING;
+\"([^"\\\n]|\\\"|\\\\|\\.)*\" return AS_TOKEN_STRING;
+\'([^'\\\n]|\\\'|\\\\)\' return AS_TOKEN_CHAR;
-. return UNKNOWN; // Unrecognized Tokens
+. return AS_TOKEN_UNKNOWN; // Unrecognized Tokens
Modified: development/source/script/cParser.cc
===================================================================
--- development/source/script/cParser.cc 2007-07-11 18:30:11 UTC (rev 1788)
+++ development/source/script/cParser.cc 2007-07-11 21:37:30 UTC (rev 1789)
@@ -196,14 +196,16 @@
#define PARSE_ERROR(x) reportError(AS_PARSE_ERR_ ## x, __LINE__)
#define PARSE_UNEXPECT() { if (currentToken()) { PARSE_ERROR(UNEXPECTED_TOKEN); } else { PARSE_ERROR(EOF); } }
+#define TOKEN(x) AS_TOKEN_ ## x
+
cParser::cParser(cASLibrary* library)
: m_library(library)
, m_filename("(unknown)")
, m_eof(false)
, m_success(true)
-, m_cur_tok(INVALID)
-, m_next_tok(INVALID)
+, m_cur_tok(TOKEN(INVALID))
+, m_next_tok(TOKEN(INVALID))
, m_cur_text(NULL)
, m_err_eof(false)
{
@@ -239,9 +241,9 @@
ASToken_t cParser::nextToken()
{
- if (m_next_tok != INVALID) {
+ if (m_next_tok != TOKEN(INVALID)) {
m_cur_tok = m_next_tok;
- m_next_tok = INVALID;
+ m_next_tok = TOKEN(INVALID);
} else {
m_cur_tok = (ASToken_t)m_lexer->yylex();
}
@@ -253,7 +255,7 @@
ASToken_t cParser::peekToken()
{
- if (m_next_tok == INVALID) {
+ if (m_next_tok == TOKEN(INVALID)) {
delete m_cur_text;
m_cur_text = new cString(m_lexer->YYText());
m_next_tok = (ASToken_t)m_lexer->yylex();
@@ -273,23 +275,23 @@
PARSE_TRACE("parseArrayUnpack");
cASTNode* au = NULL;
- if (nextToken() != ID) {
+ if (nextToken() != TOKEN(ID)) {
PARSE_ERROR(UNEXPECTED_TOKEN);
return au;
}
while (nextToken()) {
- if (currentToken() == COMMA) {
+ if (currentToken() == TOKEN(COMMA)) {
nextToken();
- if (currentToken() == ID) {
+ if (currentToken() == TOKEN(ID)) {
continue;
- } else if (currentToken() == ARR_WILD) {
+ } else if (currentToken() == TOKEN(ARR_WILD)) {
break;
} else {
PARSE_ERROR(UNEXPECTED_TOKEN);
break;
}
- } else if (currentToken() == ARR_WILD) {
+ } else if (currentToken() == TOKEN(ARR_WILD)) {
break;
} else {
PARSE_UNEXPECT();
@@ -306,7 +308,7 @@
cASTNode* al = NULL;
parseExpression();
- while (currentToken() == COMMA) {
+ while (currentToken() == TOKEN(COMMA)) {
parseExpression();
}
@@ -316,11 +318,12 @@
cASTNode* cParser::parseAssignment()
{
PARSE_TRACE("parseAssignment");
- cASTNode* an = NULL;
+ cASTAssignment* an = new cASTAssignment(currentText());
nextToken();
- parseExpression();
-
+ cASTNode* expr = parseExpression();
+ an->SetExpression(expr);
+
return an;
}
@@ -329,38 +332,40 @@
PARSE_TRACE("parseCallExpression");
cASTNode* ce = NULL;
+ nextToken();
+
bool eoe = false;
while (!eoe) {
switch (currentToken()) {
- case DOT:
- if (nextToken() != ID) {
+ case TOKEN(DOT):
+ if (nextToken() != TOKEN(ID)) {
PARSE_UNEXPECT();
return ce;
}
break;
- case PREC_OPEN:
- if (nextToken() != PREC_CLOSE) parseArgumentList();
- if (currentToken() != PREC_CLOSE) {
+ case TOKEN(PREC_OPEN):
+ if (nextToken() != TOKEN(PREC_CLOSE)) parseArgumentList();
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return ce;
}
switch (nextToken()) {
- case IDX_OPEN:
+ case TOKEN(IDX_OPEN):
do {
parseIndexExpression();
- } while (nextToken() == IDX_OPEN);
+ } while (nextToken() == TOKEN(IDX_OPEN));
break;
- case DOT:
+ case TOKEN(DOT):
continue;
default:
eoe = true;
}
break;
- case IDX_OPEN:
+ case TOKEN(IDX_OPEN):
do {
parseIndexExpression();
- } while (nextToken() == IDX_OPEN);
+ } while (nextToken() == TOKEN(IDX_OPEN));
default:
PARSE_UNEXPECT();
@@ -377,10 +382,10 @@
cASTNode* cb = NULL;
nextToken();
- if (currentToken() == ARR_OPEN) {
+ if (currentToken() == TOKEN(ARR_OPEN)) {
loose = true;
cb = parseLooseBlock();
- } else if (currentToken() == SUPPRESS || currentToken() == ENDL) {
+ } else if (currentToken() == TOKEN(SUPPRESS) || currentToken() == TOKEN(ENDL)) {
cb = parseStatementList();
} else {
PARSE_UNEXPECT();
@@ -414,8 +419,8 @@
while(true) {
switch (currentToken()) {
- case ARR_RANGE:
- case ARR_EXPAN:
+ case TOKEN(ARR_RANGE):
+ case TOKEN(ARR_EXPAN):
ASToken_t op = currentToken();
nextToken();
r = parseExprP1();
@@ -439,8 +444,8 @@
while(true) {
switch (currentToken()) {
- case OP_LOGIC_AND:
- case OP_LOGIC_OR:
+ case TOKEN(OP_LOGIC_AND):
+ case TOKEN(OP_LOGIC_OR):
ASToken_t op = currentToken();
nextToken();
r = parseExprP2();
@@ -464,8 +469,8 @@
while(true) {
switch (currentToken()) {
- case OP_BIT_AND:
- case OP_BIT_OR:
+ case TOKEN(OP_BIT_AND):
+ case TOKEN(OP_BIT_OR):
ASToken_t op = currentToken();
nextToken();
r = parseExprP3();
@@ -489,12 +494,12 @@
while(true) {
switch (currentToken()) {
- case OP_EQ:
- case OP_LE:
- case OP_GE:
- case OP_LT:
- case OP_GT:
- case OP_NEQ:
+ case TOKEN(OP_EQ):
+ case TOKEN(OP_LE):
+ case TOKEN(OP_GE):
+ case TOKEN(OP_LT):
+ case TOKEN(OP_GT):
+ case TOKEN(OP_NEQ):
ASToken_t op = currentToken();
nextToken();
r = parseExprP4();
@@ -518,8 +523,8 @@
while(true) {
switch (currentToken()) {
- case OP_ADD:
- case OP_SUB:
+ case TOKEN(OP_ADD):
+ case TOKEN(OP_SUB):
ASToken_t op = currentToken();
nextToken();
r = parseExprP5();
@@ -543,9 +548,9 @@
while(true) {
switch (currentToken()) {
- case OP_MUL:
- case OP_DIV:
- case OP_MOD:
+ case TOKEN(OP_MUL):
+ case TOKEN(OP_DIV):
+ case TOKEN(OP_MOD):
ASToken_t op = currentToken();
nextToken();
r = parseExprP6();
@@ -567,17 +572,17 @@
cASTNode* expr = NULL;
switch (currentToken()) {
- case FLOAT:
- case INT:
- case CHAR:
- case STRING:
+ case TOKEN(FLOAT):
+ case TOKEN(INT):
+ case TOKEN(CHAR):
+ case TOKEN(STRING):
expr = new cASTLiteral(currentToken());
break;
- case ID:
- if (peekToken() == PREC_OPEN) {
+ case TOKEN(ID):
+ if (peekToken() == TOKEN(PREC_OPEN)) {
nextToken();
- if (nextToken() != PREC_CLOSE) parseArgumentList();
- if (currentToken() != PREC_CLOSE) {
+ if (nextToken() != TOKEN(PREC_CLOSE)) parseArgumentList();
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return expr;
}
@@ -586,31 +591,31 @@
expr = new cASTVariableReference(); // @todo
}
break;
- case PREC_OPEN:
+ case TOKEN(PREC_OPEN):
nextToken();
expr = parseExpression();
if (!expr) PARSE_ERROR(NULL_EXPR);
- if (currentToken() != PREC_CLOSE) {
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return expr;
}
break;
- case MAT_MODIFY:
- if (nextToken() != ARR_OPEN) {
+ case TOKEN(MAT_MODIFY):
+ if (nextToken() != TOKEN(ARR_OPEN)) {
PARSE_UNEXPECT();
return expr;
}
- case ARR_OPEN:
- if (nextToken() != ARR_CLOSE) parseArgumentList();
- if (currentToken() != ARR_CLOSE) {
+ case TOKEN(ARR_OPEN):
+ if (nextToken() != TOKEN(ARR_CLOSE)) parseArgumentList();
+ if (currentToken() != TOKEN(ARR_CLOSE)) {
PARSE_UNEXPECT();
return expr;
}
break;
- case OP_BIT_NOT:
- case OP_LOGIC_NOT:
- case OP_SUB:
+ case TOKEN(OP_BIT_NOT):
+ case TOKEN(OP_LOGIC_NOT):
+ case TOKEN(OP_SUB):
ASToken_t op = currentToken();
expr = new cASTExpressionUnary(op, parseExpression());
if (!expr) PARSE_ERROR(NULL_EXPR);
@@ -629,16 +634,16 @@
cASTNode* cParser::parseExprP6_Index(cASTNode* l)
{
PARSE_TRACE("parseExprP6_Index");
- while (currentToken() == DOT || currentToken() == IDX_OPEN) {
- if (currentToken() == DOT) {
- if (nextToken() != ID) {
+ while (currentToken() == TOKEN(DOT) || currentToken() == TOKEN(IDX_OPEN)) {
+ if (currentToken() == TOKEN(DOT)) {
+ if (nextToken() != TOKEN(ID)) {
PARSE_UNEXPECT();
return l;
}
- if (peekToken() == PREC_OPEN) {
+ if (peekToken() == TOKEN(PREC_OPEN)) {
nextToken();
- if (nextToken() != PREC_CLOSE) parseArgumentList();
- if (currentToken() != PREC_CLOSE) {
+ if (nextToken() != TOKEN(PREC_CLOSE)) parseArgumentList();
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return l;
}
@@ -649,7 +654,7 @@
} else { // IDX_OPEN:
nextToken();
parseExpression();
- if (currentToken() != IDX_CLOSE) {
+ if (currentToken() != TOKEN(IDX_CLOSE)) {
PARSE_UNEXPECT();
return l;
}
@@ -667,15 +672,15 @@
cASTNode* fs = NULL;
switch (nextToken()) {
- case TYPE_ARRAY:
- case TYPE_CHAR:
- case TYPE_FLOAT:
- case TYPE_INT:
- case TYPE_MATRIX:
- case TYPE_STRING:
+ case TOKEN(TYPE_ARRAY):
+ case TOKEN(TYPE_CHAR):
+ case TOKEN(TYPE_FLOAT):
+ case TOKEN(TYPE_INT):
+ case TOKEN(TYPE_MATRIX):
+ case TOKEN(TYPE_STRING):
break;
- case ID:
- if (nextToken() != REF) {
+ case TOKEN(ID):
+ if (nextToken() != TOKEN(REF)) {
PARSE_UNEXPECT();
return fs;
}
@@ -686,7 +691,7 @@
return fs;
}
- if (nextToken() != PREC_OPEN) {
+ if (nextToken() != TOKEN(PREC_OPEN)) {
PARSE_UNEXPECT();
return fs;
}
@@ -694,14 +699,14 @@
nextToken();
parseExpression();
- if (currentToken() != PREC_CLOSE) {
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return fs;
}
bool loose = false;
parseCodeBlock(loose);
- if (!loose && currentToken() != CMD_ENDFOREACH) PARSE_UNEXPECT();
+ if (!loose && currentToken() != TOKEN(CMD_ENDFOREACH)) PARSE_UNEXPECT();
return fs;
}
@@ -713,7 +718,7 @@
bool loose = false;
parseCodeBlock(loose);
- if (!loose && currentToken() != CMD_ENDFUNCTION) {
+ if (!loose && currentToken() != TOKEN(CMD_ENDFUNCTION)) {
PARSE_UNEXPECT();
return fd;
}
@@ -727,16 +732,16 @@
cASTNode* fd = NULL;
switch (nextToken()) {
- case TYPE_ARRAY:
- case TYPE_CHAR:
- case TYPE_FLOAT:
- case TYPE_INT:
- case TYPE_MATRIX:
- case TYPE_STRING:
- case TYPE_VOID:
+ case TOKEN(TYPE_ARRAY):
+ case TOKEN(TYPE_CHAR):
+ case TOKEN(TYPE_FLOAT):
+ case TOKEN(TYPE_INT):
+ case TOKEN(TYPE_MATRIX):
+ case TOKEN(TYPE_STRING):
+ case TOKEN(TYPE_VOID):
break;
- case ID:
- if (peekToken() != REF) {
+ case TOKEN(ID):
+ if (peekToken() != TOKEN(REF)) {
nextToken();
PARSE_UNEXPECT();
return fd;
@@ -748,17 +753,17 @@
return fd;
}
- if (nextToken() != ID) {
+ if (nextToken() != TOKEN(ID)) {
PARSE_UNEXPECT();
return fd;
}
- if (nextToken() != PREC_OPEN) {
+ if (nextToken() != TOKEN(PREC_OPEN)) {
PARSE_UNEXPECT();
return fd;
}
- if (nextToken() != PREC_CLOSE) {
+ if (nextToken() != TOKEN(PREC_CLOSE)) {
if (declare) {
parseVarDeclareList();
} else {
@@ -766,7 +771,7 @@
}
}
- if (currentToken() != PREC_CLOSE) {
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return fd;
}
@@ -779,17 +784,17 @@
PARSE_TRACE("parseIDStatement");
cASTNode* is = NULL;
- switch (nextToken()) {
- case ASSIGN:
- parseAssignment();
+ switch (peekToken()) {
+ case TOKEN(ASSIGN):
+ is = parseAssignment();
break;
- case DOT:
- case IDX_OPEN:
- case PREC_OPEN:
- parseCallExpression();
+ case TOKEN(DOT):
+ case TOKEN(IDX_OPEN):
+ case TOKEN(PREC_OPEN):
+ is = parseCallExpression();
break;
- case REF:
- parseVarDeclare();
+ case TOKEN(REF):
+ is = parseVarDeclare();
break;
default:
@@ -805,7 +810,7 @@
PARSE_TRACE("parseIfStatement");
cASTNode* is = NULL;
- if (nextToken() != PREC_OPEN) {
+ if (nextToken() != TOKEN(PREC_OPEN)) {
PARSE_UNEXPECT();
return is;
}
@@ -813,20 +818,20 @@
nextToken();
parseExpression();
- if (currentToken() != PREC_CLOSE) {
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return is;
}
bool loose = false;
parseCodeBlock(loose);
- if (currentToken() == CMD_ELSE) {
+ if (currentToken() == TOKEN(CMD_ELSE)) {
parseCodeBlock(loose);
- if (!loose && currentToken() != CMD_ENDIF) {
+ if (!loose && currentToken() != TOKEN(CMD_ENDIF)) {
PARSE_UNEXPECT();
return is;
}
- } else if (!loose && currentToken() != CMD_ENDIF) {
+ } else if (!loose && currentToken() != TOKEN(CMD_ENDIF)) {
PARSE_UNEXPECT();
return is;
}
@@ -841,7 +846,7 @@
nextToken();
parseExpression();
- if (currentToken() != IDX_CLOSE) {
+ if (currentToken() != TOKEN(IDX_CLOSE)) {
PARSE_UNEXPECT();
}
@@ -853,7 +858,7 @@
PARSE_TRACE("parseLooseBlock");
nextToken();
cASTNode* sl = parseStatementList();
- if (currentToken() != ARR_CLOSE) {
+ if (currentToken() != TOKEN(ARR_CLOSE)) {
PARSE_UNEXPECT();
}
return sl;
@@ -865,10 +870,10 @@
cASTNode* rs = NULL;
switch (nextToken()) {
- case ARR_OPEN:
+ case TOKEN(ARR_OPEN):
parseArrayUnpack();
break;
- case CMD_FUNCTION:
+ case TOKEN(CMD_FUNCTION):
parseFunctionHeader();
break;
default:
@@ -889,88 +894,100 @@
return rs;
}
+
+#define CHECK_LINETERM() { if (!checkLineTerm(sl)) return sl; }
cASTNode* cParser::parseStatementList()
{
PARSE_TRACE("parseStatementList");
- cASTNode* sl = NULL;
+ cASTStatementList* sl = new cASTStatementList();
+
+ cASTNode* node = NULL;
-#define CHECK_LINETERM() { if (!checkLineTerm(sl)) return sl; }
while (nextToken()) {
switch (currentToken()) {
- case ARR_OPEN:
- parseLooseBlock();
+ case TOKEN(ARR_OPEN):
+ node = parseLooseBlock();
CHECK_LINETERM();
break;
- case CMD_IF:
- parseIfStatement();
+ case TOKEN(CMD_IF):
+ node = parseIfStatement();
CHECK_LINETERM();
break;
- case CMD_FOREACH:
- parseForeachStatement();
+ case TOKEN(CMD_FOREACH):
+ node = parseForeachStatement();
CHECK_LINETERM();
break;
- case CMD_FUNCTION:
- parseFunctionDefine();
+ case TOKEN(CMD_FUNCTION):
+ node = parseFunctionDefine();
CHECK_LINETERM();
break;
- case CMD_RETURN:
- parseReturnStatement();
+ case TOKEN(CMD_RETURN):
+ node = parseReturnStatement();
CHECK_LINETERM();
break;
- case CMD_WHILE:
- parseWhileStatement();
+ case TOKEN(CMD_WHILE):
+ node = parseWhileStatement();
CHECK_LINETERM();
break;
- case ENDL:
- break;
- case ID:
- parseIDStatement();
+ case TOKEN(ENDL):
+ continue;
+ case TOKEN(ID):
+ node = parseIDStatement();
CHECK_LINETERM();
break;
- case REF:
- parseRefStatement();
+ case TOKEN(REF):
+ node = parseRefStatement();
CHECK_LINETERM();
break;
- case SUPPRESS:
- break;
- case TYPE_ARRAY:
- case TYPE_CHAR:
- case TYPE_FLOAT:
- case TYPE_INT:
- case TYPE_MATRIX:
- case TYPE_STRING:
- parseVarDeclare();
+ case TOKEN(SUPPRESS):
+ continue;
+ case TOKEN(TYPE_ARRAY):
+ case TOKEN(TYPE_CHAR):
+ case TOKEN(TYPE_FLOAT):
+ case TOKEN(TYPE_INT):
+ case TOKEN(TYPE_MATRIX):
+ case TOKEN(TYPE_STRING):
+ node = parseVarDeclare();
CHECK_LINETERM();
break;
default:
return sl;
}
+
+ if (node == NULL) {
+ // Some error has occured, so terminate early
+ if (m_success) PARSE_ERROR(INTERNAL); // Should not receive a null response without an error flag
+ break;
+ }
+ sl->AddNode(node);
}
-#undef CHECK_LINETERM()
if (!currentToken()) m_eof = true;
return sl;
}
+#undef CHECK_LINETERM()
+
cASTNode* cParser::parseVarDeclare()
{
PARSE_TRACE("parseVarDeclare");
- cASTNode* vd = NULL;
+ cASTVariableDefinition* vd = NULL;
+ ASType_t vtype = AS_TYPE_INVALID;
switch (currentToken()) {
- case TYPE_ARRAY:
- case TYPE_CHAR:
- case TYPE_FLOAT:
- case TYPE_INT:
- case TYPE_MATRIX:
- case TYPE_STRING:
- break;
- case ID:
- if (nextToken() != REF) {
+ case TOKEN(TYPE_ARRAY): vtype = AS_TYPE_ARRAY; break;
+ case TOKEN(TYPE_CHAR): vtype = AS_TYPE_CHAR; break;
+ case TOKEN(TYPE_FLOAT): vtype = AS_TYPE_FLOAT; break;
+ case TOKEN(TYPE_INT): vtype = AS_TYPE_INT; break;
+ case TOKEN(TYPE_MATRIX): vtype = AS_TYPE_MATRIX; break;
+ case TOKEN(TYPE_STRING): vtype = AS_TYPE_STRING; break;
+ case TOKEN(ID):
+ if (nextToken() != TOKEN(REF)) {
PARSE_UNEXPECT();
return vd;
}
+ vtype = AS_TYPE_OBJECT_REF;
break;
default:
@@ -978,19 +995,23 @@
return vd;
}
- if (nextToken() != ID) {
+ if (nextToken() != TOKEN(ID)) {
PARSE_UNEXPECT();
return vd;
}
+ vd = new cASTVariableDefinition(vtype, currentText());
+
switch (nextToken()) {
- case ASSIGN:
+ case TOKEN(ASSIGN):
nextToken();
- parseExpression();
+ cASTNode* expr = parseExpression();
+ vd->SetAssignment(expr);
break;
- case PREC_OPEN:
- if (nextToken() != PREC_CLOSE) parseArgumentList();
- if (currentToken() != PREC_CLOSE) {
+ case TOKEN(PREC_OPEN):
+ // @todo - array/matrix size declaration
+ if (nextToken() != TOKEN(PREC_CLOSE)) parseArgumentList();
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return vd;
}
@@ -1009,7 +1030,7 @@
cASTNode* vl = NULL;
parseVarDeclare();
- while (currentToken() == COMMA) {
+ while (currentToken() == TOKEN(COMMA)) {
parseVarDeclare();
}
@@ -1019,9 +1040,9 @@
cASTNode* cParser::parseWhileStatement()
{
PARSE_TRACE("parseWhileStatement");
- cASTNode* ws = NULL;
+ cASTNode* ws = NULL;
- if (nextToken() != PREC_OPEN) {
+ if (nextToken() != TOKEN(PREC_OPEN)) {
PARSE_UNEXPECT();
return ws;
}
@@ -1029,14 +1050,14 @@
nextToken();
parseExpression();
- if (currentToken() != PREC_CLOSE) {
+ if (currentToken() != TOKEN(PREC_CLOSE)) {
PARSE_UNEXPECT();
return ws;
}
bool loose = false;
parseCodeBlock(loose);
- if (!loose && currentToken() != CMD_ENDWHILE) {
+ if (!loose && currentToken() != TOKEN(CMD_ENDWHILE)) {
PARSE_UNEXPECT();
return ws;
}
@@ -1048,10 +1069,10 @@
bool cParser::checkLineTerm(cASTNode* node)
{
PARSE_TRACE("checkLineTerm");
- if (currentToken() == SUPPRESS) {
+ if (currentToken() == TOKEN(SUPPRESS)) {
// @todo - mark output as suppressed
return true;
- } else if (currentToken() == ENDL) {
+ } else if (currentToken() == TOKEN(ENDL)) {
return true;
}
@@ -1097,3 +1118,11 @@
std::cerr << "parse error" << std::endl;
}
}
+
+#undef PARSE_DEBUG()
+#undef PARSE_TRACE()
+
+#undef PARSE_ERROR()
+#undef PARSE_UNEXPECT()
+
+#undef TOKEN()
More information about the Avida-cvs
mailing list