dolphout.cpp

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

/* A lexical analyzer generated by Dolphin */

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

const char *DolphinLexicalAnalyzer::dolphin_copyright_notice=
	"A lexical analyzer generated by Dolphin 0.2.9 (13 March, 2002).\n"
	"Dolphin is (C) Alexander Okhotin <[e-mail]>, 1999-2002.\n";

const int DolphinLexicalAnalyzer::alphabet_cardinality;
const int DolphinLexicalAnalyzer::number_of_symbol_classes;
const int DolphinLexicalAnalyzer::number_of_start_conditions;
const int DolphinLexicalAnalyzer::number_of_dfa_states;
const int DolphinLexicalAnalyzer::size_of_table_of_lines;
const int DolphinLexicalAnalyzer::number_of_actions;

Whale::Terminal *DolphinLexicalAnalyzer::get_token()
{
	if(lexeme)
		clear_lexeme();
	
	unsigned char state=initial_dfa_states_for_start_conditions[start_condition];
	int start_pos=0, accepting_pos=0, action_to_call=0;
	append=false;
	
	for(int pos=start_pos;; pos++)
	{
		bool eof_reached_right_now=false;
		
		int recognized_action=states[state].action_upon_accept;
		
		if(buffer.size()==pos)
		{
			if(eof_reached)
				eof_reached_right_now=true;
			else
			{
				char c;
				input_stream.get(c);
				
				if(input_stream.eof())
				{
					eof_reached=true;
					eof_reached_right_now=true;
				}
				else
				{
					buffer.push_back(c);
				}
			}
		}
		
		if(eof_reached_right_now)
		{
			if(pos==start_pos)
			{
				if(lexeme==NULL)
				{
					number_of_characters_in_lexeme=0;
					lexeme=new char[1];
					lexeme[0]=0;
				}
				
				
	if(start_condition==CPP_CODE)
	{
		cout << "End of file encountered while reading code starting "
			<< "at line " << line() << " column " << column() << ".\n";
		set_start_condition(MAIN);
		return make_token<Whale::TerminalError>();
	}
	else
		return make_token<Whale::TerminalEOF>();

			}
		}
		else
		{
			unsigned int c=(unsigned char)buffer[pos];
			state=states[state].access_transition(symbol_to_symbol_class[c]);
		}
		
		if(recognized_action)
		{
			accepting_pos=pos;
			action_to_call=recognized_action;
		}
		
		if(!state || eof_reached_right_now)
		{
			if(action_to_call==0)	// if it is a lexical error,
				accepting_pos=start_pos+1; // then eat one character.
			
			if(lexeme)
				delete[] lexeme;
			number_of_characters_in_lexeme=accepting_pos;
			lexeme=new char[number_of_characters_in_lexeme+1];
			copy(buffer.begin(), buffer.begin()+number_of_characters_in_lexeme, lexeme);
			lexeme[number_of_characters_in_lexeme]=0;
			
			switch(action_to_call)
			{
			case 0:
				
	if(start_condition==CPP_CODE)
		cout << "Lexical error in code starting at line " << line()
			<< " column " << column() << ".\n";
	else
		cout << "Lexical error at line " << line()
			<< " column " << column() << ".\n";
	
	return make_token<Whale::TerminalError>();

				break;
			case 1:
				 
				break;
			case 4:
				return make_token<Whale::TerminalKwReturn>();
			case 5:
				return make_token<Whale::TerminalKwSkip>();
			case 6:
				return make_token<Whale::TerminalKwAppend>();
			case 7:
				return make_token<Whale::TerminalKwCondition>();
			case 8:
				return make_token<Whale::TerminalKwRange>();
			case 9:
				return make_token<Whale::TerminalKwContains>();
			case 10:
				return make_token<Whale::TerminalKwEof>();
			case 11:
				return make_token<Whale::TerminalKwError>();
			case 12:
				return make_token<Whale::TerminalKwIn>();
			case 13:
				return make_token<Whale::TerminalKwTrue>();
			case 14:
				return make_token<Whale::TerminalKwFalse>();
			case 15:
				return make_token<Whale::TerminalKwStartConditions>();
			case 16:
				return make_token<Whale::TerminalE>();
			case 17:
				return make_token<Whale::TerminalArrow>();
			case 18:
				return make_token<Whale::TerminalSemicolon>();
			case 19:
				return make_token<Whale::TerminalComma>();
			case 20:
				return make_token<Whale::TerminalOr>();
			case 21:
				return make_token<Whale::TerminalAnd>();
			case 22:
				return make_token<Whale::TerminalNot>();
			case 23:
				return make_token<Whale::TerminalSharpSign>();
			case 24:
				return make_token<Whale::TerminalCommercialAt>();
			case 25:
				return make_token<Whale::TerminalSlash>();
			case 26:
				return make_token<Whale::TerminalTwoDots>();
			case 27:
				return make_token<Whale::TerminalLess>();
			case 28:
				return make_token<Whale::TerminalGreater>();
			case 29:
				return make_token<Whale::TerminalLessOrEqual>();
			case 30:
				return make_token<Whale::TerminalGreaterOrEqual>();
			case 31:
				return make_token<Whale::TerminalEqual>();
			case 32:
				return make_token<Whale::TerminalNotEqual>();
			case 33:
				return make_token<Whale::TerminalLeftParenthesis>();
			case 34:
				return make_token<Whale::TerminalRightParenthesis>();
			case 35:
				return make_token<Whale::TerminalLeftBracket>();
			case 36:
				return make_token<Whale::TerminalRightBracket>();
			case 37:
				return make_token<Whale::TerminalLoneAsterisk>();
			case 38:
				return make_token<Whale::TerminalLonePlus>();
			case 39:
				return make_token<Whale::TerminalImplication>();
			case 40:
				return make_token<Whale::TerminalAssign>();
			case 41:
				return make_token<Whale::TerminalString>();
			case 42:
				
	cout << "Unterminated string at line " << line()
		<< " column " << column() << ".\n";
	
	return make_token<Whale::TerminalError>();

				break;
			case 43:
				return make_token<Whale::TerminalNumber>();
			case 44:
				return make_token<Whale::TerminalHexNumber>();
			case 45:
				return make_token<Whale::TerminalId>();
			case 46:
				return make_token<Whale::TerminalCode>();
			case 47:
				
	set_start_condition(CPP_CODE);
	brace_count=1;
	append=true;

				break;
			case 48:
				 brace_count++; append=true; 
				break;
			case 49:
				
	brace_count--;
	if(brace_count==0)
	{
		set_start_condition(MAIN);
		return make_token<Whale::TerminalCode>();
	}
	else
		append=true;

				break;
			case 50:
				 append=true; 
				break;
			}
			
			if(append)
				start_pos=number_of_characters_in_lexeme;
			else
			{
				clear_lexeme();
				start_pos=0;
			}
			
			pos=start_pos-1;
			state=initial_dfa_states_for_start_conditions[start_condition];
			accepting_pos=0;
			action_to_call=0;
		}
	}
}

void DolphinLexicalAnalyzer::clear_lexeme()
{
	for(int i=0; i<number_of_characters_in_lexeme; i++)
		internal_position_counter(buffer[i]);
	
	buffer.erase(buffer.begin(), buffer.begin()+number_of_characters_in_lexeme);
	
	if(lexeme)
	{
		delete[] lexeme;
		lexeme=NULL;
	}
}


void DolphinLexicalAnalyzer::insert_characters(const char *s)
{
	int i;
	for(i=0; s[i]; i++);
	buffer.insert(buffer.begin(), s, s+i);
}

const unsigned char DolphinLexicalAnalyzer::table_of_lines[DolphinLexicalAnalyzer::size_of_table_of_lines]={
	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
	  0,   0,   0, 120,   0,   0,  18,  18,   0,   0,   0,   0,
	  0,   0,  18,  18,   0,   0,   0,  18,  18,  18,  18,  18,
	 18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,  18,
	 18,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
	  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,