bool parse(scanner_t& scanner, skip_t& skip_p) const
	{
		scanner.save();
		if (!stub.parse(scanner, skip_p))
			scanner.rollback();

		return true;
	}

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();
}

//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();
}

//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();
}