parser.cpp

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

/* An SLR(1) parser generated by Whale */

#include "parser.h"
using namespace std;
using namespace Whale;

const char *Whale::Parser::whale_copyright_notice=
	"An SLR(1) parser generated by Whale 0.3.2 (17 April, 2002).\n"
	"(C) Alexander Okhotin <[e-mail]>, 1999-2002.\n"
	"(C) Vladimir Prus <[e-mail]>, 2000-2002.\n";

Whale::Terminal::~Terminal()
{
	delete[] text;
}

Whale::Nonterminal::~Nonterminal()
{
	for(Symbol *s=first_child; s;)
	{
		Symbol *current=s;
		s=s->next_sibling;
		delete current;
	}
}

NonterminalS *Whale::Parser::parse()
{
	initialize();
	for(;;)
	{
		int state=state_stack[state_stack.size()-1];
		LRAction lr_action=access_action_table(state, input_symbol->number());
		if(lr_action.is_shift() && input_symbol->number()!=error_terminal_number)
		{
			int new_state=lr_action.shift_state();
			symbol_stack.push_back(input_symbol);
			state_stack.push_back(new_state);
			input_symbol=lexical_analyzer.get_token();
		}
		else if(lr_action.is_reduce())
		{
			int rule_number=lr_action.reduce_rule();
			int rule_length=rules[rule_number].length;
			int rule_start=symbol_stack.size()-rule_length;
			Nonterminal *new_symbol;
			
			switch(rule_number)
			{
			case 1: {	// S -> S-IteratorI
				NonterminalS *n=new NonterminalS;
				
				NonterminalS::IteratorI *it_i=(NonterminalS::IteratorI *)symbol_stack[rule_start];
				for(unsigned i=0; i<it_i->body.size(); i++)
				{
					n->statements.push_back(it_i->body[i]->statements);
				}
				
				new_symbol=n;
				} break;
			case 2: {	// rule-statement -> id "->" expression ";"
				NonterminalRuleStatement *n=new NonterminalRuleStatement;
				
				n->left=(TerminalId *)symbol_stack[rule_start];
				n->arrow=(TerminalArrow *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpression *)symbol_stack[rule_start+2];
				garbage.push_back(symbol_stack[rule_start+3]);
				
				new_symbol=n;
				} break;
			case 3: {	// action-statement -> pair-of-expressions "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+1];
				n->action=(NonterminalAction *)symbol_stack[rule_start+2];
				
				n->a4=NULL;
				n->start_conditions=NULL;
				n->a6=NULL;
				new_symbol=n;
				} break;
			case 4: {	// action-statement -> pair-of-expressions "<" start-conditions-expression ">" "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->a4=(TerminalLess *)symbol_stack[rule_start+1];
				n->start_conditions=(NonterminalStartConditionsExpression *)symbol_stack[rule_start+2];
				n->a6=(TerminalGreater *)symbol_stack[rule_start+3];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+4];
				n->action=(NonterminalAction *)symbol_stack[rule_start+5];
				
				new_symbol=n;
				} break;
			case 5: {	// action-statement -> "eof" "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+1];
				n->action=(NonterminalAction *)symbol_stack[rule_start+2];
				
				n->a4=NULL;
				n->start_conditions=NULL;
				n->a6=NULL;
				new_symbol=n;
				} break;
			case 6: {	// action-statement -> "eof" "<" start-conditions-expression ">" "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->a4=(TerminalLess *)symbol_stack[rule_start+1];
				n->start_conditions=(NonterminalStartConditionsExpression *)symbol_stack[rule_start+2];
				n->a6=(TerminalGreater *)symbol_stack[rule_start+3];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+4];
				n->action=(NonterminalAction *)symbol_stack[rule_start+5];
				
				new_symbol=n;
				} break;
			case 7: {	// action-statement -> "error" "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+1];
				n->action=(NonterminalAction *)symbol_stack[rule_start+2];
				
				n->a4=NULL;
				n->start_conditions=NULL;
				n->a6=NULL;
				new_symbol=n;
				} break;
			case 8: {	// action-statement -> "error" "<" start-conditions-expression ">" "==>" action
				NonterminalActionStatement *n=new NonterminalActionStatement;
				
				n->expr=(Symbol *)symbol_stack[rule_start];
				n->a4=(TerminalLess *)symbol_stack[rule_start+1];
				n->start_conditions=(NonterminalStartConditionsExpression *)symbol_stack[rule_start+2];
				n->a6=(TerminalGreater *)symbol_stack[rule_start+3];
				n->arrow=(TerminalImplication *)symbol_stack[rule_start+4];
				n->action=(NonterminalAction *)symbol_stack[rule_start+5];
				
				new_symbol=n;
				} break;
			case 9: {	// start-conditions-statement -> "start_conditions" start-conditions-statement-IteratorI ";"
				NonterminalStartConditionsStatement *n=new NonterminalStartConditionsStatement;
				
				n->a1=(TerminalKwStartConditions *)symbol_stack[rule_start];
				NonterminalStartConditionsStatement::IteratorI *it2_i=(NonterminalStartConditionsStatement::IteratorI *)symbol_stack[rule_start+1];
				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;
				}
				n->a4=(TerminalSemicolon *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 10: {	// option-statement -> id "=" option-statement-IteratorI ";"
				NonterminalOptionStatement *n=new NonterminalOptionStatement;
				
				n->left=(TerminalId *)symbol_stack[rule_start];
				n->a2=(TerminalAssign *)symbol_stack[rule_start+1];
				NonterminalOptionStatement::IteratorI *it2_i=(NonterminalOptionStatement::IteratorI *)symbol_stack[rule_start+2];
				for(unsigned i=0; i<it2_i->body_a.size(); i++)
				{
					n->right.push_back(it2_i->body_a[i]->right);
					if(i==it2_i->body_b.size()) break;
					n->a10.push_back(it2_i->body_b[i]->a10);
				}
				n->a11=(TerminalSemicolon *)symbol_stack[rule_start+3];
				
				new_symbol=n;
				} break;
			case 11: {	// invalid-statement -> error ";"
				NonterminalInvalidStatement *n=new NonterminalInvalidStatement;
				
				n->a1=(TerminalError *)symbol_stack[rule_start];
				n->a2=(TerminalSemicolon *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 12: {	// expression -> expression expression
				NonterminalExpressionConcatenation *n=new NonterminalExpressionConcatenation;
				
				n->expr1=(NonterminalExpression *)symbol_stack[rule_start];
				n->expr2=(NonterminalExpression *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 13: {	// expression -> expression "|" expression
				NonterminalExpressionDisjunction *n=new NonterminalExpressionDisjunction;
				
				n->expr1=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->expr2=(NonterminalExpression *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 14: {	// expression -> expression "&" expression
				NonterminalExpressionConjunction *n=new NonterminalExpressionConjunction;
				
				n->expr1=(NonterminalExpression *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->expr2=(NonterminalExpression *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 15: {	// expression -> expression "*"
				NonterminalExpressionIteration *n=new NonterminalExpressionIteration;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				n->sign=(Terminal *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 16: {	// expression -> expression "+"
				NonterminalExpressionIteration *n=new NonterminalExpressionIteration;
				
				n->expr=(NonterminalExpression *)symbol_stack[rule_start];
				n->sign=(Terminal *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 17: {	// expression -> expression-s
				NonterminalExpressionSymbol *n=new NonterminalExpressionSymbol;
				
				n->expr=(NonterminalExpressionS *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 18: {	// expression -> expression-s ".." expression-s
				NonterminalExpressionRange *n=new NonterminalExpressionRange;
				
				n->first_expr=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->range_kw=(Terminal *)symbol_stack[rule_start+1];
				n->last_expr=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 19: {	// expression -> "~" expression
				NonterminalExpressionComplement *n=new NonterminalExpressionComplement;
				
				garbage.push_back(symbol_stack[rule_start]);
				n->expr=(NonterminalExpression *)symbol_stack[rule_start+1];
				
				new_symbol=n;
				} break;
			case 20: {	// expression -> "(" expression ")"
				NonterminalExpressionInParentheses *n=new NonterminalExpressionInParentheses;
				
				garbage.push_back(symbol_stack[rule_start]);
				n->expr=(NonterminalExpression *)symbol_stack[rule_start+1];
				garbage.push_back(symbol_stack[rule_start+2]);
				
				new_symbol=n;
				} break;
			case 21: {	// expression -> "[" expression "]"
				NonterminalExpressionOmittable *n=new NonterminalExpressionOmittable;
				
				garbage.push_back(symbol_stack[rule_start]);
				n->expr=(NonterminalExpression *)symbol_stack[rule_start+1];
				garbage.push_back(symbol_stack[rule_start+2]);
				
				new_symbol=n;
				} break;
			case 22: {	// expression -> "#"
				NonterminalExpressionSharpSign *n=new NonterminalExpressionSharpSign;
				
				n->op=(TerminalSharpSign *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 23: {	// expression -> "e"
				NonterminalExpressionEpsilon *n=new NonterminalExpressionEpsilon;
				
				garbage.push_back(symbol_stack[rule_start]);
				
				new_symbol=n;
				} break;
			case 24: {	// expression -> "condition" "(" expression-c ")"
				NonterminalExpressionCondition *n=new NonterminalExpressionCondition;
				
				garbage.push_back(symbol_stack[rule_start]);
				garbage.push_back(symbol_stack[rule_start+1]);
				n->condition=(NonterminalExpressionC *)symbol_stack[rule_start+2];
				garbage.push_back(symbol_stack[rule_start+3]);
				
				new_symbol=n;
				} break;
			case 25: {	// expression -> "range" "(" expression-s "," expression-s ")"
				NonterminalExpressionRange *n=new NonterminalExpressionRange;
				
				n->range_kw=(Terminal *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->first_expr=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				garbage.push_back(symbol_stack[rule_start+3]);
				n->last_expr=(NonterminalExpressionS *)symbol_stack[rule_start+4];
				garbage.push_back(symbol_stack[rule_start+5]);
				
				new_symbol=n;
				} break;
			case 26: {	// expression -> "contains" "(" expression ")"
				NonterminalExpressionContains *n=new NonterminalExpressionContains;
				
				n->a1=(TerminalKwContains *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->expr=(NonterminalExpression *)symbol_stack[rule_start+2];
				garbage.push_back(symbol_stack[rule_start+3]);
				
				new_symbol=n;
				} break;
			case 27: {	// expression-s -> id
				NonterminalExpressionS *n=new NonterminalExpressionS;
				
				n->symbol=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 28: {	// expression-s -> str
				NonterminalExpressionS *n=new NonterminalExpressionS;
				
				n->symbol=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 29: {	// expression-s -> num
				NonterminalExpressionS *n=new NonterminalExpressionS;
				
				n->symbol=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 30: {	// expression-s -> hexnum
				NonterminalExpressionS *n=new NonterminalExpressionS;
				
				n->symbol=(Terminal *)symbol_stack[rule_start];
				
				new_symbol=n;
				} break;
			case 31: {	// expression-c -> expression-s "<" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 32: {	// expression-c -> expression-s ">" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 33: {	// expression-c -> expression-s "<=" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 34: {	// expression-c -> expression-s ">=" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 35: {	// expression-c -> expression-s "==" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 36: {	// expression-c -> expression-s "!=" expression-s
				NonterminalExpressionC_Comparison *n=new NonterminalExpressionC_Comparison;
				
				n->left=(NonterminalExpressionS *)symbol_stack[rule_start];
				n->comparison_operator=(Terminal *)symbol_stack[rule_start+1];
				n->right=(NonterminalExpressionS *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 37: {	// expression-c -> expression-s "in" id
				NonterminalExpressionC_In *n=new NonterminalExpressionC_In;
				
				n->c=(NonterminalExpressionS *)symbol_stack[rule_start];
				garbage.push_back(symbol_stack[rule_start+1]);
				n->symbol=(TerminalId *)symbol_stack[rule_start+2];
				
				new_symbol=n;
				} break;
			case 38: {	// expression-c -> expression-c "|" expression-c
				NonterminalExpressionC_Disjunction *n=new NonterminalExpressionC_Disjunction;