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(); }
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(); }
//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(); }
//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::LabelStatements() { parsetree.push(NT_LabelStatements); switch(scanner.next_token()) { case T_m: case T_print: LabelStatement(); LabelStatements(); break; case T_goto: case T_label: case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_LabelStatement); break; } parsetree.pop(); }
void parser_t::Statements() { parsetree.push(NT_Statements); if(scanner.next_token() != T_eof){ Statement(); Statements(); } else parsetree.drawepsilon(); parsetree.pop(); }
void parser_t::Expression1(){ parsetree.push(NT_Expression1); //WRITEME: you will need to put the rest of the procedures here switch(scanner.next_token()){ case T_eof: parsetree.drawepsilon(); //eat_token(T_eof); break; case T_plus: //cerr<<"+"; eat_token(T_plus); T(); Expression1(); break; case T_minus: //cerr<<"-"; eat_token(T_minus); T(); Expression1(); break; case T_label: parsetree.drawepsilon(); break; case T_goto: parsetree.drawepsilon(); break; case T_if: parsetree.drawepsilon(); break; case T_m: parsetree.drawepsilon(); break; case T_print: parsetree.drawepsilon(); break; case T_closesquare: parsetree.drawepsilon(); break; case T_closeparen: parsetree.drawepsilon(); break; default: syntax_error(NT_Expression1); break; } parsetree.pop(); }
void parser_t::furuImouto(string& expString) { parsetree.push(NT_MultDivImouto); switch(scanner.next_token()) { case T_times: eat_token(T_times); expString += "*"; exp(expString); furuImouto(expString); break; case T_divide: eat_token(T_divide); expString += "/"; exp(expString); furuImouto(expString); break; case T_eof: parsetree.drawepsilon(); break; 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_MultDivImouto); break; } parsetree.pop(); }
//WRITEME: you will need to put the rest of the procedures here void parser_t::Statements() { token_type watch = scanner.next_token(); parsetree.push(NT_Statements); if((watch == T_label) || (watch == T_goto) || (watch == T_m)||(watch == T_print)){ Statement(); Statements(); }else if(watch == T_eof){ parsetree.drawepsilon(); }else{ syntax_error(NT_Statements); } parsetree.pop(); }
void parser_t::StatementsPrime() { parsetree.push(NT_StatementsPrime); switch(scanner.next_token()) { case T_eof: parsetree.drawepsilon(); break; default: Statement(); StatementsPrime(); } parsetree.pop(); }
void parser_t::ExpressionP() { //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_ExpressionPrime); switch( scanner.next_token() ) { case T_label: parsetree.drawepsilon(); break; case T_goto: parsetree.drawepsilon(); break; case T_print: parsetree.drawepsilon(); break; case T_m: parsetree.drawepsilon(); break; case T_closeparen: parsetree.drawepsilon(); break; case T_closesquare: parsetree.drawepsilon(); break; 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: syntax_error(NT_ExpressionPrime); 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::JumpIf(){ parsetree.push(NT_JumpIf); if(scanner.next_token() == T_if){ code_printf("if("); eat_token(T_if); Expression(); code_printf(")\n\t\t"); } else parsetree.drawepsilon(); parsetree.pop(); }
void parser_t::Power(){ parsetree.push(NT_Power); switch(scanner.next_token()){ case T_power: code_printf(", "); eat_token(T_power); Factor(); code_printf(")"); break; default: code_printf(", 1)"); parsetree.drawepsilon(); } parsetree.pop(); }
void parser_t::Statement() { //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_Statement); switch( scanner.next_token() ) { case T_m: eat_token(T_m); Assignment(); break; case T_label: Label(); //eat_token(T_label); scanner.next_token(); break; case T_goto: //eat_token(T_goto); Jump(); scanner.next_token(); break; //COME BACK TO FIX WHAT PRINT prints out ~!~!~!~!~!~!~!~!~!~!~!~!~!~~!!~~!!~! case T_print: //eat_token(T_print); Print(); scanner.next_token(); break; case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_Statement); 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 //scanner.next_token(); parsetree.pop(); }
void parser_t::RTerm(){ parsetree.push(NT_RTerm); switch(scanner.next_token()){ case T_times: code_printf(" * "); eat_token(T_times); Term(); break; case T_divide: code_printf(" / "); eat_token(T_divide); Term(); break; default: parsetree.drawepsilon(); } parsetree.pop(); }
void parser_t::RExpression(){ parsetree.push(NT_RExpression); switch(scanner.next_token()){ case T_plus: code_printf(" + "); eat_token(T_plus); Expression(); break; case T_minus: code_printf(" - "); eat_token(T_minus); Expression(); break; default: parsetree.drawepsilon(); } parsetree.pop(); }
void parser_t::Q(){ parsetree.push(NT_Q); switch(scanner.next_token()){ case T_openparen: // cerr<<"("; eat_token(T_openparen); Expression(); if(scanner.next_token()==T_closeparen){ //cerr<<")"; eat_token(T_closeparen); } else syntax_error(NT_Q); break; case T_m: //cerr<<"m"; eat_token(T_m); if(scanner.next_token()==T_opensquare) {//cerr<<"["; eat_token(T_opensquare); Expression(); } else syntax_error(NT_Q); if(scanner.next_token() ==T_closesquare) {//cerr<<"]"; eat_token(T_closesquare); } else syntax_error(NT_Q); break; case T_num: eat_token(T_num); break; case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_Q); break; } parsetree.pop(); }
void parser_t::Exp(){ parsetree.push(NT_Exp); switch (scanner.next_token()){ case T_openparen: eat_token(T_openparen); cerr<<" ( "; Expression(); //scanner.next_token(); eat_token(T_closeparen); cerr<< " ) "; break; case T_m: eat_token(T_m); cerr<<"m"; scanner.next_token(); eat_token(T_opensquare); cerr<<"[ "; Expression(); //scanner.next_token(); eat_token(T_closesquare); cerr<<" ]"; break; case T_num: eat_token(T_num); cerr<<scanner.get_num(); break; case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_Exp); break; } parsetree.pop(); }
void parser_t::TermPrime() { parsetree.push(NT_TermPrime); switch(scanner.next_token()) { case T_times: eat_token(T_times); current = current + "*"; // printf("%s\n", current.c_str()); Power(); TermPrime(); break; case T_divide: eat_token(T_divide); current = current + "/"; Power(); TermPrime(); break; //Follow Set of TermPrime case T_plus: case T_minus: case T_closesquare: case T_closeparen: case T_eof: case T_label: case T_goto: case T_m: case T_print: parsetree.drawepsilon(); break; // Otherwise throw syntax error default: syntax_error(NT_TermPrime); break; } parsetree.pop(); }
int parser_t::List(int v) { switch( scanner.next_token() ) { case T_semicolon: eat_token(T_semicolon); fprintf(stderr, "%d\n", v); v = -1; break; default: break; } switch( scanner.next_token() ) { case T_eof: parsetree.drawepsilon(); return v; default: break; } parsetree.push(NT_List); switch( scanner.next_token() ) { case T_num: v = List(Rel(v)); break; case T_openparen: v = List(Rel(v)); break; default: syntax_error(NT_List); break; } parsetree.pop(); return v; }
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_plus: eat_token(T_plus); secondExpression = Expression(); stream << firstExpression << " + " << secondExpression; result = stream.str(); break; case T_minus: eat_token(T_minus); secondExpression = Expression(); stream << firstExpression << " - " << secondExpression; result = stream.str(); break; case T_times: case T_divide: case T_power: // Times and divide and power result = Expression__(firstExpression); break; default: result = firstExpression; parsetree.drawepsilon(); // Follow set } parsetree.pop(); string s(result); return s; }
void parser_t::ExpressionPrime() { parsetree.push(NT_ExpPrime); switch(scanner.next_token()) { case T_plus: eat_token(T_plus); current = current + "+ "; Term(); ExpressionPrime(); break; case T_minus: eat_token(T_minus); current = current + "-"; Term(); ExpressionPrime(); break; // All included in the follow set of ExpPrime case T_closesquare: case T_closeparen: case T_eof: case T_label: case T_goto: case T_m: case T_print: parsetree.drawepsilon(); break; // Otherwise throw syntax error default: syntax_error(NT_ExpPrime); 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 outSave = ""; maxArray = 0; cerr << "#include <stdio.h>\n#include <math.h>\nint main(void)\n{\nint m[101];\n"; parsetree.push(NT_Start); switch( scanner.next_token() ) { case T_plus: eat_token(T_plus); Start(); break; 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; } cerr << outSave; //statements(); //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(); cerr << "}\n"; }
void parser_t::TermPrime() { parsetree.push(NT_TermPrime); switch(scanner.next_token()) { case T_times: eat_token(T_times); Factor(); TermPrime(); break; case T_divide: eat_token(T_divide); Factor(); TermPrime(); break; case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_TermPrime); } parsetree.pop(); }
void parser_t::ExpressionRight() { parsetree.push(NT_ExpressionRight); switch (scanner.next_token()) { case T_plus: scanner.eat_token(T_plus); cerr_buffer.push_back("+"); Term(); ExpressionRight(); break; case T_minus: scanner.eat_token(T_minus); cerr_buffer.push_back("-"); Term(); ExpressionRight(); break; default: parsetree.drawepsilon(); break; } parsetree.pop(); }
string parser_t::AnotherForward(string s) { token_type watch = scanner.next_token(); parsetree.push(NT_AnotherForward); switch(watch){ case T_if: eat_token(T_if); s = Expression(s); break; case T_eof: case T_label: case T_goto: case T_m: case T_print: parsetree.drawepsilon(); break; default: syntax_error(NT_AnotherForward); break; } parsetree.pop(); return s; }
void parser_t::TermRight() { parsetree.push(NT_TermRight); switch (scanner.next_token()) { case T_times: scanner.eat_token(T_times); cerr_buffer.push_back("*"); ExponentialTerm(); TermRight(); break; case T_divide: scanner.eat_token(T_divide); cerr_buffer.push_back("/"); ExponentialTerm(); TermRight(); break; default: parsetree.drawepsilon(); 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 c_code_pre = "#include <math.h>\n#include <stdio.h>\n";//" int pow(int *num, count) { int i; int result = num[0]; for(i=1; i<count; i++) { result = pow(result, num[i]); } return result; }"; c_code_main = "int main() {\n int m[101];\n "; parsetree.push(NT_Start); 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 the parsing is done, print out the code to stderr // c_code_main = current; c_code_main = c_code_main + "return 0; }"; fprintf(stderr, "%s\n%s", c_code_pre.c_str(), c_code_main.c_str()); //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::ExpressionPrime() { parsetree.push(NT_ExpressionPrime); switch(scanner.next_token()) { case T_plus: eat_token(T_plus); Term(); ExpressionPrime(); break; case T_minus: eat_token(T_minus); Term(); ExpressionPrime(); break; case T_eof: parsetree.drawepsilon(); break; default: syntax_error(NT_ExpressionPrime); break; } parsetree.pop(); }
void parser_t::Secondjump(){ parsetree.push(NT_Secondjump); switch(scanner.next_token()) { case T_eof: parsetree.drawepsilon(); // break; //eat_token(T_eof); break; case T_if: eat_token(T_if); //cerr<<"if"; Expression(); break; case T_label: parsetree.drawepsilon(); break; case T_goto: parsetree.drawepsilon(); break; case T_m: parsetree.drawepsilon(); break; case T_print: parsetree.drawepsilon(); break; case T_closesquare: parsetree.drawepsilon(); break; case T_closeparen: parsetree.drawepsilon(); break; default: syntax_error(NT_Secondjump); break; } parsetree.pop(); }