attero
/
sencha-lang
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Formatting.

functions
Justyna Ilczuk 2012-12-28 15:40:54 +01:00
parent 2d649a149b
commit 0e6bdecf2a
1 changed files with 267 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

583
Sencha-lang/Parser.cpp
View File

@ -4,33 +4,26 @@
Parser::Parser(Context * context) Parser::Parser(Context * context)
{ {
this->context = context; this->context = context;
error_message = "***ERRORS DURING PARSING***\n"; error_message = "***ERRORS DURING PARSING***\n";
position_in_stream = 0; position_in_stream = 0;
in_statement = false; in_statement = false;
program = static_cast<ProgramNode *>(tree.root); program = static_cast<ProgramNode *>(tree.root);
} }
Parser::~Parser() Parser::~Parser()
{ {
//dtor
} }
void Parser::erase_all() void Parser::erase_all()
{ {
/*tree.delete_all_children();
tree.root = new ProgramNode();
*/
error_message = "***ERRORS DURING PARSING***\n"; error_message = "***ERRORS DURING PARSING***\n";
position_in_stream = 0; position_in_stream = 0;
in_statement = false; in_statement = false;
this->token_stream = vector<Token>(); this->token_stream = vector<Token>();
delete program; delete program;
program = new ProgramNode(); program = new ProgramNode();
} }
string Parser::show_tokens() string Parser::show_tokens()
{ {
@ -53,79 +46,74 @@ void Parser::add_tokens(vector<Token> tokens)
void Parser::error(string s) void Parser::error(string s)
{ {
error_message += s ; error_message += s ;
} }
bool Parser::read_next() bool Parser::read_next()
{ {
if(position_in_stream < token_stream.size()) if(position_in_stream < token_stream.size())
{ {
current_token = token_stream[position_in_stream]; current_token = token_stream[position_in_stream];
tok_value = current_token.get_value(); tok_value = current_token.get_value();
position_in_stream++; position_in_stream++;
return true; return true;
} }
else else
{ {
current_token = Token(t_invalid_token, ""); current_token = Token(t_invalid_token, "");
tok_value = current_token.get_value(); tok_value = current_token.get_value();
return false; return false;
} }
} }
void Parser::interpret() void Parser::interpret()
{ {
read_next(); read_next();
while(tok_value!= "") while(tok_value!= "")
{ {
program->add_statement(statement()); program->add_statement(statement());
} }
} }
bool Parser::peek(string s) bool Parser::peek(string s)
{ {
return tok_value == s; return tok_value == s;
} }
bool Parser::accept(string s) bool Parser::accept(string s)
{ {
if(peek(s)) if(peek(s))
{ {
read_next(); read_next();
return true; return true;
} }
else return false; else return false;
} }
bool Parser::expect(string s) bool Parser::expect(string s)
{ {
if(!accept(s)) if(!accept(s))
{ {
string error_message = "Error: expected "; string error_message = "Error: expected ";
error_message += s; error_message += s;
error_message += " but received: " + tok_value + "\n"; error_message += " but received: " + tok_value + "\n";
error(error_message);
error(error_message); return false;
return false; }
} else return true;
else return true;
} }
bool Parser::is_type() bool Parser::is_type()
{ {
if(tok_value == "def" || tok_value == "string" || tok_value == "num")
if(tok_value == "def" || tok_value == "string" || tok_value == "num") {
{ read_next();
read_next(); return true;
return true; }
} else
{
else return false;
{ }
return false;
}
} }
bool Parser::is_function_name() bool Parser::is_function_name()
@ -139,129 +127,105 @@ bool Parser::is_function_name()
{ {
return false; return false;
} }
} }
ASTStatement * Parser::statement() ASTStatement * Parser::statement()
{ {
BasicStatement * stat = new BasicStatement(); BasicStatement * stat = new BasicStatement();
if(accept("{"))
{
while(!accept("}"))
{
stat->children.push_back( statement());
}
}
else if(is_type())
{
DeclarationStatement * declaration = new DeclarationStatement(context);
std::string identifier = tok_value;
read_next();
declaration->add_name(identifier);
if(accept("="))
{
ASTExpression * ae = expr();
declaration->add_right_value(ae);
accept(";");
}
if(expect("("))
{
int argc = 0;
while(tok_value != ")")
{
argc++;
is_type();
declaration->add_argument(tok_value);
read_next();
if(peek(")"))
{
break;
}
expect(",");
}
expect(")");
if(!accept(";"))
{
declaration->add_body(statement());
}
}
delete stat;
return declaration;
}
else if(accept("if"))
{
IfNode * ifStatement = new IfNode();
ifStatement->add_condition(expr());
ifStatement->add_body(statement());
if(accept("else"))
{
ifStatement->add_else_block(statement());
}
delete stat;
return ifStatement;
}
else if(accept("repeat"))
{
RepeatStatement * repeat = new RepeatStatement();
repeat->add_iteration_number(expr()->evaluate());
repeat->add_body(statement());
delete stat;
return repeat;
}
else if(accept("while"))
{
WhileNode * while_node = new WhileNode();
while_node->add_condition(expr());
while_node->add_body(statement());
delete stat;
return while_node;
}
else if(accept("return"))
{
if(!peek(";"))
{
stat->add_expression(expr());
}
expect(";");
return stat;
}
else
{
stat->add_expression(expr());
while(!expect(";") && tok_value != "") read_next();
return stat;
if(accept("{")) }
{ return stat;
while(!accept("}"))
{
stat->children.push_back( statement());
}
}
else if(is_type())
{
DeclarationStatement * declaration = new DeclarationStatement(context);
std::string identifier = tok_value;
read_next();
declaration->add_name(identifier);
if(accept("="))
{
ASTExpression * ae = expr();
declaration->add_right_value(ae);
accept(";");
}
if(expect("("))
{
int argc = 0;
while(tok_value != ")")
{
argc++;
is_type();
declaration->add_argument(tok_value);
read_next();
if(peek(")"))
{
break;
}
expect(",");
}
expect(")");
if(!accept(";"))
{
declaration->add_body(statement());
}
}
delete stat;
return declaration;
}
else if(accept("if"))
{
IfNode * ifStatement = new IfNode();
ifStatement->add_condition(expr());
ifStatement->add_body(statement());
if(accept("else"))
{
ifStatement->add_else_block(statement());
}
delete stat;
return ifStatement;
}
else if(accept("repeat"))
{
RepeatStatement * repeat = new RepeatStatement();
repeat->add_iteration_number(expr()->evaluate());
repeat->add_body(statement());
//similar stuff
delete stat;
return repeat;
}
else if(accept("while"))
{
WhileNode * while_node = new WhileNode();
while_node->add_condition(expr());
while_node->add_body(statement());
delete stat;
return while_node;
}
else if(accept("return"))
{
if(!peek(";"))
{
stat->add_expression(expr());
}
expect(";");
return stat;
}
else
{
stat->add_expression(expr());
while(!expect(";") && tok_value != "") read_next();
return stat;
}
return stat;
} }
ASTExpression * Parser::prim_expr() ASTExpression * Parser::prim_expr()
{ {
if(current_token.get_type() == t_integer) if(current_token.get_type() == t_integer)
{ {
ConstantExpression * ce; ConstantExpression * ce;
@ -288,13 +252,11 @@ ASTExpression * Parser::prim_expr()
ConstantExpression * ce; ConstantExpression * ce;
if(tok_value == "true") if(tok_value == "true")
{ {
ce = new ConstantExpression( SenchaObject(true)); ce = new ConstantExpression( SenchaObject(true));
read_next(); read_next();
} }
else if (tok_value == "false") else if (tok_value == "false")
{ {
ce = new ConstantExpression(SenchaObject(false)); ce = new ConstantExpression(SenchaObject(false));
read_next(); read_next();
} }
@ -323,8 +285,7 @@ ASTExpression * Parser::prim_expr()
error(error_message); error(error_message);
read_next(); read_next();
return new IncorrectExpression(error_message); return new IncorrectExpression(error_message);
} }
} }
ASTExpression * Parser::postfix_expr() ASTExpression * Parser::postfix_expr()
@ -335,191 +296,181 @@ ASTExpression * Parser::postfix_expr()
PostfixExpression * function_call = new PostfixExpression( context); PostfixExpression * function_call = new PostfixExpression( context);
function_call->set_name(name); function_call->set_name(name);
if(accept("(")) if(accept("("))
{ {
if(!accept(")")) if(!accept(")"))
{ {
function_call->add_argument(expr()); function_call->add_argument(expr());
while(accept(",")) while(accept(","))
{ {
function_call->add_argument(expr()); function_call->add_argument(expr());
} }
expect(")"); expect(")");
} }
return function_call;
return function_call; }
}
} }
return prim_expr(); return prim_expr();
} }
ASTExpression * Parser::mul_expr() ASTExpression * Parser::mul_expr()
{ {
BasicExpression * be = new BasicExpression(); BasicExpression * be = new BasicExpression();
be->set_left_operand(postfix_expr()); be->set_left_operand(postfix_expr());
if(peek("*") || peek("/")) if(peek("*") || peek("/"))
{ {
if(accept("*")) if(accept("*"))
{ {
be->set_operator("*"); be->set_operator("*");
} else if(accept("/")) } else if(accept("/"))
{ {
be->set_operator("/"); be->set_operator("/");
}
be->set_right_operand(mul_expr());
}
else
{
ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]);
delete be;
return ae;
}
}
be->set_right_operand(mul_expr());
}
else
{
ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]);
delete be;
return ae;
}
return be; return be;
} }
ASTExpression * Parser::add_expr() ASTExpression * Parser::add_expr()
{ {
BasicExpression * be = new BasicExpression(); BasicExpression * be = new BasicExpression();
be->set_left_operand(mul_expr()); be->set_left_operand(mul_expr());
if(peek("+") || peek("-")) if(peek("+") || peek("-"))
{ {
if(accept("+")) if(accept("+"))
{ {
be->set_operator("+"); be->set_operator("+");
} }
else if(accept("-")) else if(accept("-"))
{ {
be->set_operator("-"); be->set_operator("-");
} }
be->set_right_operand(add_expr()); be->set_right_operand(add_expr());
} }
else else
{ {
ASTExpression * ae; ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]); ae = static_cast<ASTExpression *>(be->children[0]);
delete be; delete be;
return ae; return ae;
} }
return be;
return be;
} }
ASTExpression * Parser::rel_expr() ASTExpression * Parser::rel_expr()
{ {
BasicExpression * be = new BasicExpression(); BasicExpression * be = new BasicExpression();
be->set_left_operand(add_expr()); be->set_left_operand(add_expr());
if(peek("<") || peek(">")) if(peek("<") || peek(">"))
{ {
if(accept("<")) if(accept("<"))
{ {
be->set_operator("<"); be->set_operator("<");
} }
else if (accept(">")) else if (accept(">"))
{ {
be->set_operator(">"); be->set_operator(">");
} }
be->set_right_operand(rel_expr()); be->set_right_operand(rel_expr());
} }
else else
{ {
ASTExpression * ae; ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]); ae = static_cast<ASTExpression *>(be->children[0]);
delete be; delete be;
return ae; return ae;
} }
return be;
return be;
} }
ASTExpression * Parser::eq_expr() ASTExpression * Parser::eq_expr()
{ {
BasicExpression * be = new BasicExpression(); BasicExpression * be = new BasicExpression();
be->set_left_operand(rel_expr()); be->set_left_operand(rel_expr());
if(peek("==") || peek("!=")) if(peek("==") || peek("!="))
{ {
if(accept("==")) if(accept("=="))
{ {
be->set_operator("=="); be->set_operator("==");
} }
else if(accept("!=")) else if(accept("!="))
{ {
be->set_operator("!="); be->set_operator("!=");
} }
be->set_right_operand(eq_expr()); be->set_right_operand(eq_expr());
} }
else else
{ {
ASTExpression * ae; ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]); ae = static_cast<ASTExpression *>(be->children[0]);
delete be; delete be;
return ae; return ae;
} }
return be;
return be;
} }
ASTExpression * Parser::log_expr() ASTExpression * Parser::log_expr()
{ {
BasicExpression * be = new BasicExpression(); BasicExpression * be = new BasicExpression();
be->set_left_operand(eq_expr()); be->set_left_operand(eq_expr());
if(peek("and") || peek("or")) if(peek("and") || peek("or"))
{ {
if(accept("and")) if(accept("and"))
{ {
be->set_operator("&&"); be->set_operator("&&");
} }
else if(accept("or")) else if(accept("or"))
{ {
be->set_operator("||"); be->set_operator("||");
} }
be->set_right_operand(log_expr()); be->set_right_operand(log_expr());
} }
else else
{ {
ASTExpression * ae; ASTExpression * ae;
ae = static_cast<ASTExpression *>(be->children[0]); ae = static_cast<ASTExpression *>(be->children[0]);
delete be; delete be;
return ae; return ae;
} }
return be;
return be;
} }
ASTExpression * Parser::expr() ASTExpression * Parser::expr()
{ {
Assignment * assignment = new Assignment( context); Assignment * assignment = new Assignment( context);
auto name = tok_value; auto name = tok_value;
ASTExpression * left = log_expr(); ASTExpression * left = log_expr();
if(accept("="))
if(accept("=")) {
{ ASTExpression * right = expr();
ASTExpression * right = expr();
assignment->add_lvalue(left); assignment->add_lvalue(left);
assignment->add_rvalue(right); assignment->add_rvalue(right);
assignment->set_name(name); assignment->set_name(name);
return assignment; return assignment;
} }
else
else {
{ delete assignment;
delete assignment; return left;
return left; }
}
} }