symbolentry.cpp

compiler principle how to ananilyze

// SymbolEntry.cpp: implementation of the SymbolEntry class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SymbolEntry.h"


const char* SymbolEntry::p_ARROW			= "->";
const char* SymbolEntry::p_EPSILON			= "epsilon";
const char* SymbolEntry::p_ALTER			= "|";
const char* SymbolEntry::p_DELIMITER		= ";";
const char* SymbolEntry::p_REVERSE_SLASH	= "\\";
const char* SymbolEntry::p_SINGLE_QUOTE		= "'";
const char* SymbolEntry::p_LEFT_BRACKET		= "[";
const char* SymbolEntry::p_RIGHT_BRACKET	= "]";


// token_type			token_kind						    lexeme
// -------------------------------------------------------------------------------------------
// VN					V: Non-terminal symbol					[A-Za-z][A-Za-z_0-9]*
// VT					V: terminal symbol						\'Escape\' | 'epsilon' 
//	Escape -> NoEscapeChar Escape | '\\\\' Escape | '\\\'' Escape | epsilon;
//	NoEscapeChar -> [^\'];

// GN					GT(GrammarTitle): GrammarName			[A-Za-z][A-Za-z_0-9]*

// ALTER				KEYWORD: meta-symbol					|		
// ARROW				KEYWORD: meta-symbol					->
// DELIMITER			KEYWORD: meta-symbol					;
// EPSILON				KEYWORD: meta-symbol					epsilon
// LEFT_BRACKET			KEYWORD: meta-symbol					[
// RIGHT_BRACKET		KEYWORD: meta-symbol					]
//--------------------------------------------------------------------------------------------

void SymbolEntry::setTokenType(int atoken_type) {

	token_type = atoken_type;

	switch(token_type) {

		case SymbolEntry::VN:
		case SymbolEntry::VT:
			token_kind = SymbolEntry::V;
			break;

		case SymbolEntry::GN:
			token_kind = SymbolEntry::GT;
			break;

		default:
			token_kind = SymbolEntry::KEYWORD;
			break;
		}
}

SymbolEntry::SymbolEntry(const string& alexeme, int atoken_type):
	lexeme(alexeme) {
	setTokenType(atoken_type);
}

bool SymbolEntry::operator !=(const SymbolEntry& se) const {

	return token_type != se.token_type ||
		   (lexeme.compare(se.lexeme) != 0);
}

// token_type			token_kind						    lexeme
// -------------------------------------------------------------------------------------------
// VN					V: Non-terminal symbol					[A-Za-z][A-Za-z_0-9]*
// VT					V: terminal symbol						\'Escape\' | 'epsilon'
//Escape -> NoEscapeChar Escape | '\\\\' Escape | '\\\'' Escape | epsilon;
//NoEscapeChar -> [^\'];

// GN					GT(GrammarTitle): GrammarName			[A-Za-z][A-Za-z_0-9]*

// ALTER				KEYWORD: meta-symbol					|		
// ARROW				KEYWORD: meta-symbol					->
// DELIMITER			KEYWORD: meta-symbol					;
// EPSILON				KEYWORD: meta-symbol					epsilon
// LEFT_BRACKET			KEYWORD: meta-symbol					[
// RIGHT_BRACKET		KEYWORD: meta-symbol					]
//--------------------------------------------------------------------------------------------

string SymbolEntry::display() const {

	switch(token_type) {
	case SymbolEntry::VN:
	case SymbolEntry::GN:
	case SymbolEntry::ALTER:
	case SymbolEntry::ARROW:
	case SymbolEntry::DELIMITER:
	case SymbolEntry::EPSILON:
	case SymbolEntry::LEFT_BRACKET:
	case SymbolEntry::RIGHT_BRACKET:
				
		return lexeme;
	
	case SymbolEntry::VT: {
		string str;
		str += SymbolEntry::c_SINGLE_QUOTE;

		int i= 0;
		int size = lexeme.size();
		for(; i< size; ++i) {
			if (lexeme[i] == SymbolEntry::c_SINGLE_QUOTE || 
				lexeme[i] == SymbolEntry::c_REVERSE_SLASH) 
				str += SymbolEntry::c_REVERSE_SLASH;

			str += lexeme[i];
		}
		str += SymbolEntry::c_SINGLE_QUOTE;
		return str;
	}

	default:
		error("SymbolEntry::display..unknown token_type :" + iToString(token_type));
		return "";

	}//switch

}

string SymbolEntry::toStr() const {
	
	string str = display();
	str += "\t";
	switch(token_type) {
	case SymbolEntry::VN:
		str += "VN: V";
		break;

	case SymbolEntry::VT:
		str += "VT: V";
		break;

	case SymbolEntry::GN:
		str += "GN: GT";
		break;

	case SymbolEntry::ALTER:
		str += "ALTER: KEYWORD";
		break;

	case SymbolEntry::ARROW:
		str += "ARROW: KEYWORD";
		break;

	case SymbolEntry::DELIMITER:
		str += "DELIMITER: KEYWORD";
		break;

	case SymbolEntry::EPSILON:
		str += "EPSILON: KEYWORD";
		break;

	case SymbolEntry::LEFT_BRACKET:
		str += "LEFT_BRACKET: KEYWORD";
		break;

	case SymbolEntry::RIGHT_BRACKET:
		str += "RIGHT_BRACKET: KEYWORD";
		break;
	}

	str += "\t";
	
	VLocationSet::const_iterator i = locations.begin();
	VLocationSet::const_iterator e = locations.end();
	for(; i != e; ++i) {
		str += (*i).toStr();
		if ((i + 1) != e)
			str += " ";
	}

	return str;

}