Excel_formula_parser_cpp/Token.cpp at master · lishen2/Excel_formula_parser_cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
#include "Token.h"

namespace ExcelFormula
{

	Token::Token():
		m_value(),
		m_type(Unknown),
		m_subtype(Nothing){}

	Token::Token(const char* szValue, TokenType type):
	m_value(szValue),
	m_type(type),
	m_subtype(Nothing) {}

	Token::Token(const char* szValue, TokenType type, TokenSubtype subtype):
		m_value(szValue),
		m_type(type),
		m_subtype(subtype) {}

	bool Token::operator==(Token& token) {
		if (token.getType() == getType()
				&& token.getSubtype() == getSubtype()
				&& token.getStrValue().compare(getStrValue()) == 0)
			return true;
		else
			return false;
	}

	//! return printable string
	const string Token::getPrintableString()
	{
		string printableStr = m_value + " ";

		switch(m_type)
		{
			case Operand:
				printableStr += "<Operand>";
				break;
			case Function:
				printableStr += "<Function>";
				break;
			case Subexpression:
				printableStr += "<Subexpression>";
				break;
			case Argument:
				printableStr += "<Argument>";
				break;
			case OperatorPrefix:
				printableStr += "<OperatorPrefix>";
				break;
			case OperatorInfix:
				printableStr += "<OperatorInfix>";
				break;
			case OperatorPostfix:
				printableStr += "<OperatorPostfix>";
				break;
			case Whitespace:
				printableStr += "<Whitespace>";
				break;
			case Unknown:
				printableStr += "<Unknown>";
				break;
		}//token type switch

		printableStr += " ";

		switch(m_subtype)
		{
			case Nothing:
				printableStr += "<Nothing>";
				break;
			case Start:
				printableStr += "<Start>";
				break;
			case Stop:
				printableStr += "<Stop>";
				break;
			case Text:
				printableStr += "<Text>";
				break;
			case Number:
				printableStr += "<Number>";
				break;
			case Logical:
				printableStr += "<Logical>";
				break;
			case Error:
				printableStr += "<Error>";
				break;
			case Range:
				printableStr += "<Range>";
				break;
			case Math:
				printableStr += "<Math>";
				break;
			case Concatenation:
				printableStr += "<Concatenation>";
				break;
			case Intersection:
				printableStr += "<Intersection>";
				break;
			case Union:
				printableStr += "<Union>";
				break;
		}//token subtype switch
		return printableStr;
	} //func  getPrintableStr

	Token* Token::clone()
	{
		return TokenAllocer::getToken(getValue(), getType(), getSubtype());
	}

	Token* TokenAllocer::getToken()
	{
		return new Token();
	}

	Token* TokenAllocer::getToken(const char* szValue, Token::TokenType type)
	{
		return new Token(szValue, type);
	}

	Token* TokenAllocer::getToken(const char* szValue, Token::TokenType type,
			Token::TokenSubtype subtype)
	{
		return new Token(szValue, type, subtype);
	}

	void TokenAllocer::freeToken(Token* pToken)
	{
		delete pToken;
	}

}//namespace