token.cpp

来自「compiler principle how to ananilyze」· C++ 代码 · 共 170 行

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

#include "stdafx.h"
#include "Token.h"
#include "SymbolTable.h"

extern SymbolTable symbol_table;

// (type,value)			meaning						    lexeme
//============================================================================================
// 1)  from SymbolEntry
// (VN,index)			V: Non-terminal symbol			[A-Z] [A-Za-z_0-9]*
// (VT,index)			V: terminal symbol				\'Escape\' | 'epsilon'
//	Escape -> NoEscapeChar Escape | '\\\\' Escape | '\\\'' Escape | epsilon;
//	NoEscapeChar -> [^\'];

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

// (ALTER,index)		KEYWORD: meta-symbol			|		
// (ARROW,index)		KEYWORD: meta-symbol			->
// (DELIMITER,index)	KEYWORD: meta-symbol			;
// (EPSILON,index)		KEYWORD: meta-symbol			epsilon
//--------------------------------------------------------------------------------------------
// 2) lexer using (DONE, NONE) to notify the parser ending of the token stream
// (tDONE, tNONE)		EOF								EOF
//--------------------------------------------------------------------------------------------
// 3) Token objects' initial value
//--------------------------------------------------------------------------------------------
// (tEMPTY, tNONE)		Token objects' initial value 

string Token::toStr() const {
	string a ("(");
	switch(type) {
	
	case SymbolEntry::VN:
		a += "VN"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;
		
	case SymbolEntry::GN:
		a += "GN"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::VT:
		a += "VT"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;
	
	case SymbolEntry::ALTER:
		a += "key-ALTER"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::ARROW:
		a += "key-ARROW"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::DELIMITER:
		a += "key-DELIMITER"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::EPSILON:
		a += "key-EPSILON"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::LEFT_BRACKET:
		a += "key-LEFT_BRACKET"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case SymbolEntry::RIGHT_BRACKET:
		a += "key-RIGHT_BRACKET"; a+= " , ";
		if (value >= 0)
			a += symbol_table.getLexeme(value);		//value is index to SymbolTable
		a += ")";
		break;

	case Token::tDONE:
		a += "tDONE"; a+= " , ";
		a += "EOF";
		a += ")";
		break;

	case Token::tEMPTY:
		a += "tEMPTY"; a+= " , ";
		a += "tNONE";
		a += ")";
		break;

	}

	return a;
}

Token::Token(): type(Token::tEMPTY), value(Token::tNONE) {}

Token::Token(int atype, int avalue):
  type(atype), value(avalue)
{}

// (type,value)			meaning						    lexeme
//============================================================================================
// 1)  from SymbolEntry
// (VN,index)			V: Non-terminal symbol			[A-Za-z][A-Za-z_0-9]*
// (VT,index)			V: terminal symbol				\'Escape\' | 'epsilon'
//	Escape -> NoEscapeChar Escape | '\\\\' Escape | '\\\'' Escape | epsilon;
//	NoEscapeChar -> [^\'];

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

// (ALTER,index)			KEYWORD: meta-symbol			|		
// (ARROW,index)			KEYWORD: meta-symbol			->
// (DELIMITER,index)		KEYWORD: meta-symbol			;
// (EPSILON,index)			KEYWORD: meta-symbol			epsilon
// (LEFT_BRACKET,index)		KEYWORD: meta-symbol			[
// (RIGHT_BRACKET,index)	KEYWORD: meta-symbol			]
//--------------------------------------------------------------------------------------------
// 2) lexer using (DONE, NONE) to notify the parser ending of the token stream
// (tDONE, tNONE)		EOF								EOF
//--------------------------------------------------------------------------------------------
// 3) Token objects' initial value
//--------------------------------------------------------------------------------------------
// (tEMPTY, tNONE)		Token objects' initial value 

bool Token::operator ==(const Token& tk) const {
	if (this == &tk) return true;

	switch(tk.type) {

	case SymbolEntry::ALTER:
	case SymbolEntry::ARROW:
	case SymbolEntry::DELIMITER:
	case SymbolEntry::EPSILON:
	case SymbolEntry::LEFT_BRACKET:
	case SymbolEntry::RIGHT_BRACKET:
	case Token::tDONE:
	case Token::tEMPTY:
		return type == tk.type;
		
	default:
		return type == tk.type && value == tk.value;
	}
}

bool Token::operator !=(const Token& tk) const {
	return !((*this) == tk);
}