parser.cpp

Full support for extended regular expressions (those with intersection and complement); Support for

				
				n->expr1=(NonterminalExpressionC *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->expr2=(NonterminalExpressionC *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 39: {	// expression-c -> expression-c "&" expression-c
				NonterminalExpressionC_Conjunction *n=new NonterminalExpressionC_Conjunction;
				
				n->expr1=(NonterminalExpressionC *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->expr2=(NonterminalExpressionC *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 40: {	// expression-c -> "~" expression-c
				NonterminalExpressionC_Complement *n=new NonterminalExpressionC_Complement;
				
				garbage.push_back(symbol_stack[rule_start]);
				n->expr=(NonterminalExpressionC *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 41: {	// expression-c -> "(" expression-c ")"
				NonterminalExpressionC_InParentheses *n=new NonterminalExpressionC_InParentheses;
				
				garbage.push_back(symbol_stack[rule_start]);
				n->expr=(NonterminalExpressionC *)symbol_stack[rule_start+1];
				garbage.push_back(symbol_stack[rule_start+2]);
				
				new_symbol=n;
				} break;
			case 42: {	// expression-c -> "true"
				NonterminalExpressionC_Constant *n=new NonterminalExpressionC_Constant;
				
				n->true_or_false=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 43: {	// expression-c -> "false"
				NonterminalExpressionC_Constant *n=new NonterminalExpressionC_Constant;
				
				n->true_or_false=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 44: {	// pair-of-expressions -> expression
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				
				n->lookahead=NULL;
				n->not_eof=NULL;
				n->eof=NULL;
				new_symbol=n;
				} break;
			case 45: {	// pair-of-expressions -> expression "/" expression
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->lookahead=(NonterminalExpression *)symbol_stack[rule_start+2];
				
				n->not_eof=NULL;
				n->eof=NULL;
				new_symbol=n;
				} break;
			case 46: {	// pair-of-expressions -> expression "/" expression "~" "eof"
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->lookahead=(NonterminalExpression *)symbol_stack[rule_start+2];
				n->not_eof=(TerminalNot *)symbol_stack[rule_start+3];
				n->eof=(TerminalKwEof *)symbol_stack[rule_start+4];
				
				new_symbol=n;
				} break;
			case 47: {	// pair-of-expressions -> expression "/" expression "eof"
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->lookahead=(NonterminalExpression *)symbol_stack[rule_start+2];
				n->eof=(TerminalKwEof *)symbol_stack[rule_start+3];
				
				n->not_eof=NULL;
				new_symbol=n;
				} break;
			case 48: {	// pair-of-expressions -> expression "/" "~" "eof"
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->not_eof=(TerminalNot *)symbol_stack[rule_start+2];
				n->eof=(TerminalKwEof *)symbol_stack[rule_start+3];
				
				n->lookahead=NULL;
				new_symbol=n;
				} break;
			case 49: {	// pair-of-expressions -> expression "/" "eof"
				NonterminalPairOfExpressions *n=new NonterminalPairOfExpressions;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->eof=(TerminalKwEof *)symbol_stack[rule_start+2];
				
				n->lookahead=NULL;
				n->not_eof=NULL;
				new_symbol=n;
				} break;
			case 50: {	// start-conditions-expression -> start-conditions-expression-IteratorI
				NonterminalStartConditionsExpressionList *n=new NonterminalStartConditionsExpressionList;
				
				NonterminalStartConditionsExpression::IteratorI *it2_i=(NonterminalStartConditionsExpression::IteratorI *)symbol_stack[rule_start];
				for(unsigned i=0; i<it2_i->body_a.size(); i++)
				{
					n->names.push_back(it2_i->body_a[i]->names);
					if(i==it2_i->body_b.size()) break;
				}
				
				new_symbol=n;
				} break;
			case 51: {	// start-conditions-expression -> "*"
				NonterminalStartConditionsExpressionAsterisk *n=new NonterminalStartConditionsExpressionAsterisk;
				
				n->a1=(TerminalLoneAsterisk *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 52: {	// action -> id ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->return_value=(Terminal *)symbol_stack[rule_start];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				n->kw=NULL;
				new_symbol=n;
				} break;
			case 53: {	// action -> str ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->return_value=(Terminal *)symbol_stack[rule_start];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				n->kw=NULL;
				new_symbol=n;
				} break;
			case 54: {	// action -> num ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->return_value=(Terminal *)symbol_stack[rule_start];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				n->kw=NULL;
				new_symbol=n;
				} break;
			case 55: {	// action -> hexnum ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->return_value=(Terminal *)symbol_stack[rule_start];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				n->kw=NULL;
				new_symbol=n;
				} break;
			case 56: {	// action -> cpp-code
				NonterminalActionCodeII *n=new NonterminalActionCodeII;
				
				n->code=(TerminalCode *)symbol_stack[rule_start];
				
				n->semicolon=NULL;
				new_symbol=n;
				} break;
			case 57: {	// action -> cpp-code ";"
				NonterminalActionCodeII *n=new NonterminalActionCodeII;
				
				n->code=(TerminalCode *)symbol_stack[rule_start];
				n->semicolon=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 58: {	// action -> "return" id ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->kw=(TerminalKwReturn *)symbol_stack[rule_start];
				n->return_value=(Terminal *)symbol_stack[rule_start+1];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 59: {	// action -> "return" str ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->kw=(TerminalKwReturn *)symbol_stack[rule_start];
				n->return_value=(Terminal *)symbol_stack[rule_start+1];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 60: {	// action -> "return" num ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->kw=(TerminalKwReturn *)symbol_stack[rule_start];
				n->return_value=(Terminal *)symbol_stack[rule_start+1];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 61: {	// action -> "return" hexnum ";"
				NonterminalActionReturn *n=new NonterminalActionReturn;
				
				n->kw=(TerminalKwReturn *)symbol_stack[rule_start];
				n->return_value=(Terminal *)symbol_stack[rule_start+1];
				n->a6=(TerminalSemicolon *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 62: {	// action -> "skip" ";"
				NonterminalActionSkip *n=new NonterminalActionSkip;
				
				n->kw=(TerminalKwSkip *)symbol_stack[rule_start];
				n->a2=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 63: {	// S-BodyI -> rule-statement
				NonterminalS::BodyI *body_n=new NonterminalS::BodyI;
				
				body_n->statements=(Nonterminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 64: {	// S-BodyI -> action-statement
				NonterminalS::BodyI *body_n=new NonterminalS::BodyI;
				
				body_n->statements=(Nonterminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 65: {	// S-BodyI -> start-conditions-statement
				NonterminalS::BodyI *body_n=new NonterminalS::BodyI;
				
				body_n->statements=(Nonterminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 66: {	// S-BodyI -> option-statement
				NonterminalS::BodyI *body_n=new NonterminalS::BodyI;
				
				body_n->statements=(Nonterminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 67: {	// S-BodyI -> invalid-statement
				NonterminalS::BodyI *body_n=new NonterminalS::BodyI;
				
				body_n->statements=(Nonterminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 68: {	// S-IteratorI -> S-BodyI
				NonterminalS::IteratorI *it=new NonterminalS::IteratorI;
				it->body.push_back((NonterminalS::BodyI *)symbol_stack[rule_start]);
				new_symbol=it;
				} break;
			case 69: {	// S-IteratorI -> S-IteratorI S-BodyI
				NonterminalS::IteratorI *it=(NonterminalS::IteratorI *)symbol_stack[rule_start];
				it->body.push_back((NonterminalS::BodyI *)symbol_stack[rule_start+1]);
				new_symbol=it;
				} break;
			case 70: {	// start-conditions-statement-BodyIa -> id
				NonterminalStartConditionsStatement::BodyIa *body_n=new NonterminalStartConditionsStatement::BodyIa;
				
				body_n->names=(TerminalId *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 71: {	// start-conditions-statement-BodyIb -> ","
				NonterminalStartConditionsStatement::BodyIb *body_n=new NonterminalStartConditionsStatement::BodyIb;
				
				garbage.push_back(symbol_stack[rule_start]);
				
				new_symbol=body_n;
				} break;
			case 72: {	// start-conditions-statement-IteratorI -> start-conditions-statement-BodyIa
				NonterminalStartConditionsStatement::IteratorI *it=new NonterminalStartConditionsStatement::IteratorI;
				it->body_a.push_back((NonterminalStartConditionsStatement::BodyIa *)symbol_stack[rule_start]);
				new_symbol=it;
				} break;
			case 73: {	// start-conditions-statement-IteratorI -> start-conditions-statement-IteratorI start-conditions-statement-BodyIb start-conditions-statement-BodyIa
				NonterminalStartConditionsStatement::IteratorI *it=(NonterminalStartConditionsStatement::IteratorI *)symbol_stack[rule_start];
				it->body_b.push_back((NonterminalStartConditionsStatement::BodyIb *)symbol_stack[rule_start+1]);
				it->body_a.push_back((NonterminalStartConditionsStatement::BodyIa *)symbol_stack[rule_start+2]);
				new_symbol=it;
				} break;
			case 74: {	// option-statement-BodyIa -> id
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 75: {	// option-statement-BodyIa -> str
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 76: {	// option-statement-BodyIa -> num
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 77: {	// option-statement-BodyIa -> hexnum
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 78: {	// option-statement-BodyIa -> cpp-code
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 79: {	// option-statement-BodyIa -> "true"
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 80: {	// option-statement-BodyIa -> "false"
				NonterminalOptionStatement::BodyIa *body_n=new NonterminalOptionStatement::BodyIa;
				
				body_n->right=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 81: {	// option-statement-BodyIb -> ","
				NonterminalOptionStatement::BodyIb *body_n=new NonterminalOptionStatement::BodyIb;
				
				body_n->a10=(TerminalComma *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 82: {	// option-statement-IteratorI -> option-statement-BodyIa
				NonterminalOptionStatement::IteratorI *it=new NonterminalOptionStatement::IteratorI;
				it->body_a.push_back((NonterminalOptionStatement::BodyIa *)symbol_stack[rule_start]);
				new_symbol=it;
				} break;
			case 83: {	// option-statement-IteratorI -> option-statement-IteratorI option-statement-BodyIb option-statement-BodyIa
				NonterminalOptionStatement::IteratorI *it=(NonterminalOptionStatement::IteratorI *)symbol_stack[rule_start];
				it->body_b.push_back((NonterminalOptionStatement::BodyIb *)symbol_stack[rule_start+1]);
				it->body_a.push_back((NonterminalOptionStatement::BodyIa *)symbol_stack[rule_start+2]);
				new_symbol=it;
				} break;
			case 84: {	// start-conditions-expression-BodyIa -> id
				NonterminalStartConditionsExpression::BodyIa *body_n=new NonterminalStartConditionsExpression::BodyIa;
				
				body_n->names=(TerminalId *)symbol_stack[rule_start];
				
				new_symbol=body_n;
				} break;
			case 85: {	// start-conditions-expression-BodyIb -> ","
				NonterminalStartConditionsExpression::BodyIb *body_n=new NonterminalStartConditionsExpression::BodyIb;
				
				garbage.push_back(symbol_stack[rule_start]);
				
				new_symbol=body_n;
				} break;
			case 86: {	// start-conditions-expression-IteratorI -> start-conditions-expression-BodyIa
				NonterminalStartConditionsExpression::IteratorI *it=new NonterminalStartConditionsExpression::IteratorI;
				it->body_a.push_back((NonterminalStartConditionsExpression::BodyIa *)symbol_stack[rule_start]);
				new_symbol=it;
				} break;
			case 87: {	// start-conditions-expression-IteratorI -> start-conditions-expression-IteratorI start-conditions-expression-BodyIb start-conditions-expression-BodyIa
				NonterminalStartConditionsExpression::IteratorI *it=(NonterminalStartConditionsExpression::IteratorI *)symbol_stack[rule_start];
				it->body_b.push_back((NonterminalStartConditionsExpression::BodyIb *)symbol_stack[rule_start+1]);
				it->body_a.push_back((NonterminalStartConditionsExpression::BodyIa *)symbol_stack[rule_start+2]);
				new_symbol=it;
				} break;
			}
			
			for(int i=0; i<rule_length; i++)
			{
				symbol_stack.pop_back();
				state_stack.pop_back();
			}
			int nn=rules[rule_number].nn;
			symbol_stack.push_back(new_symbol);
			int new_state=access_goto_table(state_stack[state_stack.size()-1], nn);
			state_stack.push_back(new_state);
		}
		else if(lr_action.is_accept())
		{
			NonterminalS *result = dynamic_cast<NonterminalS *>(symbol_stack.back());