string parser_t::Jump(string s) { token_type watch = scanner.next_token(); parsetree.push(NT_Jump); if(watch == T_goto){ eat_token(T_goto); s = Forward(s); }else{ syntax_error(NT_Jump); } watch = scanner.next_token(); switch(watch){ case T_eof: case T_label: case T_goto: case T_m: case T_print: break; default: syntax_error(NT_Jump); break; } parsetree.pop(); return s; }
string parser_t::Assignment(string s) { token_type watch = scanner.next_token(); parsetree.push(NT_Assignment); if(watch == T_m){ s.append("m"); eat_token(T_m); s.append("["); eat_token(T_opensquare); s = Expression(s); s.append("]"); eat_token(T_closesquare); s.append("="); eat_token(T_equals); s = Expression(s); }else{ syntax_error(NT_Print); } watch = scanner.next_token(); switch(watch){ case T_eof: case T_label: case T_goto: case T_m: case T_print: break; default: syntax_error(NT_Print); break; } parsetree.pop(); return s; }
string parser_t::Label(string s) { token_type watch = scanner.next_token(); parsetree.push(NT_Label); if(watch == T_label){ s.append("L"); eat_token(T_label); eat_token(T_num); char buf[100]; snprintf(buf, 100, "%d", scanner.nextNumber); s.append(buf); s.append(":"); eat_token(T_colon); }else{ syntax_error(NT_Label); } watch = scanner.next_token(); switch(watch){ case T_eof: case T_label: case T_goto: case T_m: case T_print: break; default: syntax_error(NT_Label); break; } parsetree.pop(); return s; }
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::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::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::Factor(){ token_type token; parsetree.push(NT_Factor); code_printf("intPow("); switch(token = scanner.next_token()){ case T_openparen: eat_token(T_openparen); code_printf("("); Expression(); code_printf(")"); eat_token(T_closeparen); break; case T_m: code_printf("m["); eat_token(T_m); eat_token(T_opensquare); Expression(); eat_token(T_closesquare); code_printf("]"); break; case T_num: code_printf("%d",scanner.get_num()); eat_token(T_num); break; default: syntax_error(NT_Factor); /* fprintf(stderr, "%d Invalid factor: %s\n", scanner.get_line(), token_to_string(token)); assert(0); */ } Power(); 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::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::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::Statement() { string s; token_type watch = scanner.next_token(); parsetree.push(NT_Statement); if(watch == T_label){ s = Label(s); }else if(watch == T_goto){ s = Jump(s); }else if(watch == T_m){ s = Assignment(s); }else if(watch == T_print){ s = Print(s); }else{ syntax_error(NT_Statement); } cerr<<s<<";"<<endl; watch = scanner.next_token(); switch(watch){ case T_eof: case T_label: case T_goto: case T_m: case T_print: break; default: syntax_error(NT_Statement); break; } 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::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::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(); }
void parser_t::Jump() { parsetree.push(NT_Jump); if(scanner.next_token() == T_goto) { eat_token(T_goto); scanner.next_token(); std::string tmp = scanner.get_token_value(); eat_token(T_num); //If there's an if statement, handle it it. if(scanner.next_token() == T_if) { eat_token(T_if); current = current + "if("; Expression(); current = current + " != 0) { "; current = current + "goto L" + tmp + "; }\n "; } else { current = current + " goto L" + tmp + ";\n "; } } else { syntax_error(NT_Jump); } parsetree.pop(); }
void parser_t::Label() { parsetree.push(NT_Label); if(scanner.next_token() == T_label) { eat_token(T_label); current = c_code_main; scanner.next_token(); current = current + "\n L" + scanner.get_token_value() + ":\n "; // printf("current:\n%s\n", current.c_str()); eat_token(T_num); eat_token(T_colon); LabelStatements(); // printf("current:\n%s\n", current.c_str()); c_code_main = current; current = c_code_main; printf("%s\n", c_code_main.c_str()); } else { syntax_error(NT_Label); } parsetree.pop(); }
bool parse(scanner_t& scanner, skip_t& skip_p) const { scanner.save(); if (!stub.parse(scanner, skip_p)) scanner.rollback(); return true; }
//call this syntax error when you are trying to parse the //non-terminal nt, but you fail to find a token that you need //to make progress. You should call this as soon as you can know //there is a syntax_error. void parser_t::syntax_error(nonterm_type nt) { printf("syntax error: found %s in parsing %s - line %d\n", token_to_string( scanner.next_token()), nonterm_to_string(nt), scanner.get_line() ); exit(1); }
void parser_t::Label() { parsetree.push(NT_Label); scanner.eat_token(T_label); scanner.eat_token(T_num); scanner.eat_token(T_colon); cerr_buffer.push_back("L" + scanner.get_number() + ":\n"); parsetree.pop(); }
bool parse(scanner_t& scanner, skip_t& skip_p) const { scanner.save(); if (lhs.parse(scanner, skip_p) || rhs.parse(scanner, skip_p)) { scanner.commit(); return true; } scanner.rollback(); return false; }
bool parse(scanner_t& scanner, skip_t&) const { for (int readChar = scanner.readAhead(); readChar != -1; readChar = scanner.readAhead()) { if (!isSkipCharacter(readChar)) break; scanner.skip(1); } return true; }
//WRITEME: you will need to put the rest of the procedures here void parser_t::Statements() { parsetree.push(NT_Statements); Statement(); if (scanner.next_token() != T_eof) { Statements(); } else { scanner.eat_token(T_eof); parsetree.drawepsilon(); } parsetree.pop(); }
void parser_t::Jump(){ parsetree.push(NT_Jump); if(scanner.next_token()==T_goto) eat_token(T_goto); else syntax_error(NT_Jump); if(scanner.next_token()==T_num){ eat_token(T_num); Secondjump(); } else syntax_error(NT_Jump); parsetree.pop(); }
void parser_t::BracketTerm() { parsetree.push(NT_BracketTerm); switch (scanner.next_token()) { case T_openparen: scanner.eat_token(T_openparen); cerr_buffer.push_back("("); Expression(); scanner.eat_token(T_closeparen); cerr_buffer.push_back(")"); break; case T_m: scanner.eat_token(T_m); scanner.eat_token(T_opensquare); cerr_buffer.push_back("m["); Expression(); scanner.eat_token(T_closesquare); cerr_buffer.push_back("]"); break; case T_num: scanner.eat_token(T_num); cerr_buffer.push_back(scanner.get_number()); break; default: syntax_error(NT_BracketTerm); } parsetree.pop(); }
bool parse(scanner_t& scanner, skip_t& ) const { scanner.save(); const int value = scanner.read(); if (value != -1 && traits_type::to_char_type(value) == character) { scanner.commit(); return true; } scanner.rollback(); return false; }
void parser_t::Assignment() { parsetree.push(NT_Assignment); scanner.eat_token(T_m); scanner.eat_token(T_opensquare); cerr_buffer.push_back("m["); Expression(); scanner.eat_token(T_closesquare); scanner.eat_token(T_equals); cerr_buffer.push_back("]="); Expression(); cerr_buffer.push_back(";\n"); 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(); }
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::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(); }
bool parse(scanner_t& scanner, skip_t& skip_p) const { scanner.save(); const int input = scanner.read(); if (input != -1 && traits_type::to_char_type(input) >= small && traits_type::to_char_type(input) <= large) { scanner.commit(); return true; } scanner.rollback(); return false; }