void parser_t::statement()
{
parsetree.push(NT_Statement);
switch(scanner.next_token())
{
case T_label:
label();
break;
case T_goto:
jump();
outSave += ";\n";
break;
case T_m:
assignments();
outSave += ";\n";
break;
case T_print:
print();
outSave += ";\n";
break;
default:
syntax_error(NT_Statement);
break;
}
parsetree.pop();
}
void parser_t::Assignment(){
parsetree.push(NT_Assignment);
switch( scanner.next_token() )
{
case T_opensquare:
cerr<<"m";
eat_token(T_opensquare);
cerr<<"[ ";
Expression();
scanner.next_token();
eat_token(T_closesquare);
cerr<<" ] ";
scanner.next_token();
eat_token(T_equals);
cerr<<" = ";
Expression();
cerr<<"; \n";
scanner.next_token();
break;
// case T_eof:
// parsetree.drawepsilon();
// break;
default:
syntax_error(NT_Assignment);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::TermP(){
parsetree.push(NT_TermP);
switch( scanner.next_token() )
{
case T_times:
eat_token(T_times);
cerr<<" * ";
Factor();
TermP();
break;
case T_divide:
eat_token(T_divide);
cerr<<" / ";
Factor();
TermP();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
parsetree.drawepsilon();
// syntax_error(NT_ExpressionP);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
// Jump_ -> "if" Expression | epsilon
void parser_t::Jump_(std::string label_name)
{
std::string exp;
parsetree.push(NT_Jump_);
switch(scanner.next_token()) {
case T_if:
// conditional jump
eat_token(T_if);
exp = Expression();
fprintf(stderr, "\tif (%s) goto label%s;", exp.c_str(), label_name.c_str());
break;
case T_m:
case T_label:
case T_goto:
case T_equals:
case T_print:
case T_eof:
fprintf(stderr, "\tgoto label%s;", label_name.c_str());
parsetree.drawepsilon();
// From follow set
break;
default:
syntax_error(NT_Jump_);
}
parsetree.pop();
}
void parser_t::MoreStatement(){
parsetree.push(NT_MoreStatement);
switch(scanner.next_token()){
case T_label:
case T_m:
case T_goto:
case T_print:
Statement();
MoreStatement();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
syntax_error(NT_MoreStatement);
break;
}
parsetree.pop();
}
//Here is an example
void parser_t::Start()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Start);
switch( scanner.next_token() )
{
case T_plus:
eat_token(T_plus);
Start();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
syntax_error(NT_Start);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::Statements()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Statements);
bool thereIsMore = true;
switch( scanner.next_token() )
{
case T_label:
case T_goto:
case T_m:
case T_print:
Statement();
Statements();
break;
case T_eof:
thereIsMore = false;
break;
default:
syntax_error(NT_Statements);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::Factor()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Factor);
switch( scanner.next_token() )
{
case T_num:
eat_token(T_num);
if(scanner.next_token()==T_power)
{
powBuffer=scanner.numberList[numberListSpot];
}
else
cerr << scanner.numberList[numberListSpot];
numberListSpot++;
break;
case T_m:
eat_token(T_m);
cerr << "m";
if (scanner.next_token() == T_opensquare)
{
eat_token(T_opensquare);
cerr << "[";
Expression();
if(scanner.next_token() == T_closesquare)
{
eat_token(T_closesquare);
cerr << "]";
}
else
syntax_error(NT_Factor);
}
else
syntax_error(NT_Factor);
break;
case T_openparen:
eat_token(T_openparen);
cerr << "(";
Expression();
if (scanner.next_token() == T_closeparen)
{
eat_token(T_closeparen);
cerr << ")";
}
else
syntax_error(NT_Factor);
break;
default:
syntax_error(NT_Factor);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::Jump()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Jump);
if(scanner.next_token() == T_goto)
{
eat_token(T_goto);
if(scanner.next_token() == T_num)
{
eat_token(T_num);
int labelNum = scanner.numberList[numberListSpot];
numberListSpot++;
JumpP(labelNum);
}
else
syntax_error(NT_Jump);
}
else
syntax_error(NT_Jump);
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::numend(string& expString)
{
parsetree.push(NT_NumEnd);
switch(scanner.next_token())
{
case T_openparen:
//cout <<"here";
eat_token(T_openparen);
expString += "(";
//cout<< "ga";
expString += expression();
//cout <<"wtfffff";
eat_token(T_closeparen);
expString += ")";
break;
case T_m:
eat_token(T_m);
eat_token(T_opensquare);
expString += "m[";
expString += expression();
eat_token(T_closesquare);
expString += "]";
break;
case T_num:
//cout <<"num found";
eat_token(T_num);
expString += scanner.numString();
break;
default:
syntax_error(NT_NumEnd);
break;
}
parsetree.pop();
}
void parser_t::Power()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Power);
switch( scanner.next_token() )
{
case T_num:
Factor();
PowerP();
break;
case T_m:
Factor();
PowerP();
break;
case T_openparen:
Factor();
PowerP();
break;
default:
syntax_error(NT_Power);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
bool parser_t::expImouto(string& expString)
{
parsetree.push(NT_Exp);
bool rr = false;
switch(scanner.next_token())
{
case T_power:
eat_token(T_power);
expString += ",";
numend(expString);
expString += ")";
rr = true;
break;
case T_eof:
parsetree.drawepsilon();
break;
case T_times:
case T_divide:
case T_plus:
case T_minus:
case T_closeparen:
case T_closesquare:
case T_label:
case T_goto:
case T_m:
case T_print:
parsetree.drawepsilon();
break;
default:
syntax_error(NT_Exp);
break;
}
parsetree.pop();
return rr;
}
void parser_t::expressionImouto(string& expString)
{
parsetree.push(NT_ExpressionImouto);
switch(scanner.next_token())
{
case T_plus:
eat_token(T_plus);
expString += "+";
furu(expString);
expressionImouto(expString);
break;
case T_minus:
eat_token(T_minus);
expString += "-";
furu(expString);
expressionImouto(expString);
break;
case T_eof:
parsetree.drawepsilon();
break;
case T_closeparen:
case T_closesquare:
case T_label:
case T_goto:
case T_m:
case T_print:
parsetree.drawepsilon();
break;
default:
syntax_error(NT_ExpressionImouto);
}
parsetree.pop();
}
void parser_t::jumpImouto()
{
parsetree.push(NT_JumpImouto);
switch(scanner.next_token())
{
case T_if:
eat_token(T_if);
outSave += "if(";
outSave += expression();
outSave += ")";
break;
case T_eof:
parsetree.drawepsilon();
break;
case T_label:
case T_goto:
case T_m:
case T_print:
break;
default:
syntax_error(NT_JumpImouto);
break;
}
parsetree.pop();
}
int parser_t::Rel(int v)
{
parsetree.push(NT_Rel);
switch( scanner.next_token() )
{
case T_num:
v = RelP(Expr(v));
break;
case T_lt:
eat_token(T_lt);
if (v < Expr(v)) v = 1;
else v = 0;
break;
case T_gt:
eat_token(T_gt);
if (v > Expr(v)) v = 1;
else v = 0;
break;
case T_eq:
eat_token(T_eq);
if (v == Expr(v)) v = 1;
else v = 0;
break;
case T_openparen:
v = RelP(Expr(v));
break;
default:
syntax_error(NT_Rel);
break;
}
parsetree.pop();
return v;
}
void parser_t::Statements()
{
parsetree.push(NT_Statements);
Statement();
Derivestate();
parsetree.pop();
}
int parser_t::Expr(int v)
{
parsetree.push(NT_Expr);
switch (scanner.next_token())
{
case T_num:
v = ExprP(Term(v));
break;
case T_plus:
eat_token(T_plus);
v += Term(v);
v = ExprP(v);
break;
case T_minus:
eat_token(T_minus);
v -= Term(v);
v = ExprP(v);
break;
case T_openparen:
eat_token(T_openparen);
v = ExprP(v);
eat_token(T_closeparen);
break;
default:
syntax_error(NT_Expr);
break;
}
parsetree.pop();
return v;
}
void parser_t::Statement(){
parsetree.push(NT_Statement);
switch(scanner.next_token())
{
case T_eof:
parsetree.drawepsilon();
break;
case T_m:
cerr<<"m";
Assignment();
break;
case T_label:
cerr<<"L";
Label();
break;
case T_goto:
cerr<<"goto";
Jump();
break;
case T_print:
cerr<<"printf()";
Print();
break;
default:
syntax_error(NT_Statement);
break;
}
parsetree.pop();
}
//Here is an example
void parser_t::Start()
{
//push this non-terminal onto the parse tree.
//the parsetree class is just for drawing the finished
//parse tree, and should in should have no effect the actual
//parsing of the data
parsetree.push(NT_Start);
fprintf(stderr, "int main()\n");
fprintf(stderr, "{\n");
fprintf(stderr, "\tint m[101];\n");
fprintf(stderr, "\n");
switch( scanner.next_token() )
{
case T_label:
case T_goto:
case T_m:
case T_print:
Statements();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
syntax_error(NT_Start);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
fprintf(stderr, "}\n");
}
void parser_t::Derivestate(){
parsetree.push(NT_Derivestate);
switch(scanner.next_token())
{
case T_label:
Statement();
Derivestate();
break;
case T_goto:
Statement();
Derivestate();
break;
case T_m:
Statement();
Derivestate();
break;
case T_print:
Statement();
Derivestate();
break;
case T_eof:
eat_token(scanner.next_token());
// parsetree.drawepsilon();
// cout<<"done"<<endl;
break;
default:
syntax_error(NT_Derivestate);
break;
}
parsetree.pop();
}
void parser_t::Statement()
{
parsetree.push(NT_Statement);
switch( scanner.next_token() )
{
case T_label:
Label();
break;
case T_goto:
Jump();
break;
case T_m:
Assignment();
break;
case T_print:
Print();
break;
default:
syntax_error(NT_Statement);
}
fprintf( stderr, "\n");
parsetree.pop();
}
void parser_t::Print(){
parsetree.push(NT_Print);
if(scanner.next_token()==T_print)
eat_token(T_print);
Expression();
parsetree.pop();
}
std::string parser_t::Expression__(std::string firstExpression)
{
std::string result;
std::string secondExpression;
std::ostringstream stream;
parsetree.push(NT_Expression__);
switch( scanner.next_token() )
{
case T_times:
eat_token(T_times);
secondExpression = Expression();
stream << firstExpression << " * " << secondExpression;
result = stream.str();
break;
case T_divide:
eat_token(T_divide);
secondExpression = Expression();
stream << firstExpression << " / " << secondExpression;
result = stream.str();
break;
case T_power:
eat_token(T_power);
secondExpression = Expression();
stream << "pow(" << firstExpression << ", " << secondExpression << ")";
result = stream.str();
break;
default:
syntax_error(NT_Expression__);
}
parsetree.pop();
return result;
}
void parser_t::T()
{
parsetree.push(NT_T);
F();
Expression2();
parsetree.pop();
}
void parser_t::Jump(){
int temp;
parsetree.push(NT_Jump);
eat_token(T_goto);
//cerr<<"goto ";
scanner.next_token();
temp = scanner.get_num();
eat_token(T_num);
scanner.next_token();
if(scanner.next_token()== T_if){
eat_token(T_if);
// cerr<<"if( ";
//scanner.next_token();
Expression();
cerr<<" );\n";
cerr<<"goto L";
cerr<<temp;
cerr<<"; \n";
}
else{
cerr<<"goto L";
cerr<<temp;
cerr<<"; \n";
}
parsetree.pop();
}
void parser_t::Term()
{
parsetree.push(NT_Term);
Factor();
TermPrime();
parsetree.pop();
}
void parser_t::ExpressionP(){
parsetree.push(NT_ExpressionP);
switch( scanner.next_token() )
{
case T_plus:
eat_token(T_plus);
cerr<<" + ";
Term();
ExpressionP();
break;
case T_minus:
eat_token(T_minus);
cerr<< " - ";
Term();
ExpressionP();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
parsetree.drawepsilon();
// syntax_error(NT_ExpressionP);
break;
}
//now that we are done with List, we can pop it from the data
//stucture that is tracking it for drawing the parse tree
parsetree.pop();
}
void parser_t::Assignment()
{
parsetree.push(NT_Assignment);
if(scanner.next_token() == T_m)
{
eat_token(T_m);
}
else{syntax_error(NT_Assignment);}
if(scanner.next_token()==T_opensquare)
{
eat_token(T_opensquare);
}
else{syntax_error(NT_Assignment);}
Expression();
if(scanner.next_token() == T_closesquare)
{
eat_token(T_closesquare);
}
else{syntax_error(NT_Assignment);}
if(scanner.next_token() == T_equals)
{
eat_token(T_equals);
}
else{syntax_error(NT_Assignment);}
Expression();
parsetree.pop();
}
void parser_t::FactorP(){
int temp = scanner.get_num();
parsetree.push(NT_FactorP);
switch(scanner.next_token()){
case T_power:
eat_token(T_power);
Exp();
FactorP();
break;
case T_eof:
parsetree.drawepsilon();
break;
default:
parsetree.drawepsilon();
// syntax_error(NT_ExpressionP);
break;
}
parsetree.pop();
}
void parser_t::Factor()
{
parsetree.push(NT_Factor);
if(scanner.next_token() == T_num)
{
current = current + scanner.get_token_value();
// printf("%s\n", current.c_str());
eat_token(T_num);
}
else if(scanner.next_token() == T_m)
{
eat_token(T_m);
eat_token(T_opensquare);
current = current + "m[";
Expression();
eat_token(T_closesquare);
current = current + "]";
}
else { syntax_error(NT_Factor); }
parsetree.pop();
}