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();
}
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::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;
}
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::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()
{
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::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();
}
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::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::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::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();
}
//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::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();
}
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::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();
}
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::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();
}
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::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();
}
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::Print(){
parsetree.push(NT_Print);
if(scanner.next_token()==T_print)
eat_token(T_print);
Expression();
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();
}
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::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::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();
}