1#ifndef _RSGTOKEN_HPP
2#define _RSGTOKEN_HPP
3/*-------------------------------------------------------------------------
4 * drawElements Quality Program Random Shader Generator
5 * ----------------------------------------------------
6 *
7 * Copyright 2014 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Token class.
24 *//*--------------------------------------------------------------------*/
25
26#include "rsgDefs.hpp"
27
28#include <vector>
29
30namespace rsg
31{
32
33class Token
34{
35public:
36	enum Type
37	{
38		IDENTIFIER,
39		STRUCT,
40		INVARIANT,
41		PRECISION,
42		VOID,
43		BREAK,
44		CONTINUE,
45		DO,
46		WHILE,
47		ELSE,
48		FOR,
49		IF,
50		DISCARD,
51		RETURN,
52		INC_OP,
53		DEC_OP,
54		LEFT_PAREN,
55		RIGHT_PAREN,
56		LEFT_BRACKET,	// [
57		RIGHT_BRACKET,	// ]
58		LEFT_BRACE,		// {
59		RIGHT_BRACE,	// }
60		DOT,
61		COMMA,
62		COLON,
63		SEMICOLON,
64		MINUS,
65		PLUS,
66		MUL,
67		DIV,
68		MOD,
69		QUESTION,
70		BOOL,
71		BVEC2,
72		BVEC3,
73		BVEC4,
74		INT,
75		IVEC2,
76		IVEC3,
77		IVEC4,
78		FLOAT,
79		VEC2,
80		VEC3,
81		VEC4,
82		MAT2,
83		MAT3,
84		MAT4,
85		SAMPLER2D,
86		SAMPLERCUBE,
87		FLOAT_LITERAL,
88		INT_LITERAL,
89		BOOL_LITERAL,
90		EQUAL,
91		MUL_ASSIGN,
92		DIV_ASSIGN,
93		ADD_ASSIGN,
94		SUB_ASSIGN,
95		CMP_LT,
96		CMP_GT,
97		CMP_LE,
98		CMP_GE,
99		CMP_EQ,
100		CMP_NE,
101		LOGICAL_AND,
102		LOGICAL_OR,
103		LOGICAL_NOT,
104		LOGICAL_XOR,
105		ATTRIBUTE,
106		UNIFORM,
107		VARYING,
108		CONST,
109		FLAT,
110		HIGH_PRECISION,
111		MEDIUM_PRECISION,
112		LOW_PRECISION,
113		IN,
114		OUT,
115		INOUT,
116		LAYOUT,
117		LOCATION,
118
119		// Formatting only
120		INDENT_INC,
121		INDENT_DEC,
122		NEWLINE,
123
124		TYPE_LAST
125	};
126
127					Token			(void);
128					Token			(Type type);
129					Token			(const char* identifier);
130					Token			(float value);
131					Token			(int value);
132					Token			(bool value);
133					Token			(const Token& other);
134
135					~Token			(void);
136
137	inline bool		operator==		(Type type) const	{ return m_type == type;	}
138	inline bool		operator!=		(Type type) const	{ return m_type != type;	}
139
140	bool			operator==		(const Token& other) const;
141	bool			operator!=		(const Token& other) const;
142
143	Token&			operator=		(const Token& other);
144
145	inline Type		getType			(void) const		{ return m_type;			}
146
147	const char*		getIdentifier	(void) const;
148	float			getFloat		(void) const;
149	int				getInt			(void) const;
150	bool			getBool			(void) const;
151
152private:
153	Type			m_type;
154	union
155	{
156		char*			identifier;
157		float			floatValue;
158		int				intValue;
159		bool			boolValue;
160	} m_arg;
161};
162
163
164inline Token::Token (void)
165	: m_type(TYPE_LAST)
166{
167	m_arg.identifier = DE_NULL;
168}
169
170inline Token::Token (Type type)
171	: m_type(type)
172{
173	DE_ASSERT(type != IDENTIFIER);
174}
175
176inline Token::Token (float value)
177	: m_type(FLOAT_LITERAL)
178{
179	m_arg.floatValue = value;
180}
181
182inline Token::Token (int value)
183	: m_type(INT_LITERAL)
184{
185	m_arg.intValue = value;
186}
187
188inline Token::Token (bool value)
189	: m_type(BOOL_LITERAL)
190{
191	m_arg.boolValue = value;
192}
193
194inline bool Token::operator== (const Token& other) const
195{
196	return !(*this != other);
197}
198
199inline const char* Token::getIdentifier (void) const
200{
201	DE_ASSERT(m_type == IDENTIFIER);
202	return m_arg.identifier;
203}
204
205inline float Token::getFloat (void) const
206{
207	DE_ASSERT(m_type == FLOAT_LITERAL);
208	return m_arg.floatValue;
209}
210
211inline int Token::getInt (void) const
212{
213	DE_ASSERT(m_type == INT_LITERAL);
214	return m_arg.intValue;
215}
216
217inline bool Token::getBool (void) const
218{
219	DE_ASSERT(m_type == BOOL_LITERAL);
220	return m_arg.boolValue;
221}
222
223class TokenStream
224{
225public:
226							TokenStream		(void);
227							~TokenStream	(void);
228
229	int						getSize			(void) const	{ return (int)m_numTokens;	}
230	const Token&			operator[]		(int ndx) const	{ return m_tokens[ndx];		}
231
232	TokenStream&			operator<<		(const Token& token);
233
234private:
235	enum
236	{
237		ALLOC_SIZE = 64
238	};
239
240	std::vector<Token>		m_tokens;
241	size_t					m_numTokens;
242};
243
244inline TokenStream& TokenStream::operator<< (const Token& token)
245{
246	if (m_tokens.size() == m_numTokens)
247		m_tokens.resize(m_numTokens+ALLOC_SIZE);
248
249	m_tokens[m_numTokens]	 = token;
250	m_numTokens				+= 1;
251
252	return *this;
253}
254
255} // rsg
256
257#endif // _RSGTOKEN_HPP
258