dolphout.h

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

/* A lexical analyzer generated by Dolphin */

#ifndef __LEXICAL_ANALYZER_GENERATED_BY_DOLPHIN__DOLPHOUT_H

#define __LEXICAL_ANALYZER_GENERATED_BY_DOLPHIN__DOLPHOUT_H

#include <iostream>
#include <vector>
#include <typeinfo>

class DolphinLexicalAnalyzer;

namespace Whale { class Terminal; }

class DolphinLexicalAnalyzer
{
	static const char *dolphin_copyright_notice;
	
public:
	static const int alphabet_cardinality=256;
	static const int number_of_symbol_classes=53;
	static const int number_of_start_conditions=2;
	static const int number_of_dfa_states=136;
	static const int size_of_table_of_lines=1484;
	static const int number_of_actions=50;
	
	enum StartCondition { MAIN=0, CPP_CODE };
	
protected:
	struct StateData
	{
		int exception_location; // -1 for none
		unsigned char exception_data;
		const unsigned char *transitions;
		int action_upon_accept;
		
		unsigned char access_transition(int input_symbol) const
		{
			if(input_symbol==exception_location)
				return exception_data;
			else
				return transitions[input_symbol];
		}
	};
	
	static const int symbol_to_symbol_class[alphabet_cardinality];
	static const unsigned char table_of_lines[size_of_table_of_lines];
	static const StateData states[number_of_dfa_states+1];
	static const unsigned char initial_dfa_states_for_start_conditions[number_of_start_conditions];
	
	std::istream &input_stream;
	std::vector<char> buffer;
	StartCondition start_condition;
	bool eof_reached;
	bool append;
	
	char *lexeme;
	int number_of_characters_in_lexeme;
	int current_line, current_column, current_offset;
	int tab_size;
	
	void clear_lexeme();
	
	template<class T> Whale::Terminal *make_token()
	{
		Whale::Terminal *t=new T;
		t->line=line();
		t->column=column();
		t->text=capture_lexeme();
		return t;
	}
	void internal_position_counter(char c)
	{
		if(c=='\n')
		{
			current_line++;
			current_column=1;
		}
		else if(c=='\t')
			current_column+=tab_size-(current_column-1)%tab_size;
		else
			current_column++;
		
		current_offset++;
	}
	
public:
	
	 int brace_count; 
	DolphinLexicalAnalyzer(std::istream &stream_supplied) : input_stream(stream_supplied)
	{
		start_condition=MAIN;
		lexeme=NULL;
		number_of_characters_in_lexeme=0;
		eof_reached=false;
		current_line=1;
		current_column=1;
		current_offset=0;
		set_tab_size(8);
		
		 brace_count=0; 
	}
	~DolphinLexicalAnalyzer() { if(lexeme) delete[] lexeme; }
	void set_start_condition(StartCondition new_start_condition) { start_condition=new_start_condition; }
	StartCondition get_start_condition() const { return start_condition; }
	Whale::Terminal *get_token();
	const char *get_lexeme() const { return lexeme; }
	char *capture_lexeme() { char *s=lexeme; lexeme=NULL; clear_lexeme(); return s; }
	int get_lexeme_length() const { return number_of_characters_in_lexeme; }
	int line() const { return current_line; }
	int column() const { return current_column; }
	int offset() const { return current_offset; }
	void set_tab_size(int n) { tab_size=n; }
	int get_tab_size() const { return tab_size; }
	void insert_characters(const char *);
	const char *copyright_notice() { return dolphin_copyright_notice; }
};

#endif