/
mojoshader_lexer.re
241 lines (214 loc) · 7.75 KB
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
/**
* MojoShader; generate shader programs from bytecode of compiled
* Direct3D shaders.
*
* Please see the file LICENSE.txt in the source's root directory.
*
* This file written by Ryan C. Gordon.
*/
// This was originally based on examples/pp-c.re from re2c: http://re2c.org/
// re2c is public domain code.
//
// You build mojoshader_lexer_preprocessor.c from the .re file with re2c...
// re2c -is -o mojoshader_lexer_preprocessor.c mojoshader_lexer_preprocessor.re
//
// Changes to the lexer are done to the .re file, not the C code!
//
// Please note that this isn't a perfect C lexer, since it is used for both
// HLSL and shader assembly language, and follows the quirks of Microsoft's
// tools.
#define __MOJOSHADER_INTERNAL__ 1
#include "mojoshader_internal.h"
typedef unsigned char uchar;
27
/*!max:re2c */
28
#define RET(t) do { return update_state(s, eoi, cursor, token, t); } while (0)
29
30
31
32
#define YYCTYPE uchar
#define YYCURSOR cursor
#define YYLIMIT limit
#define YYMARKER s->lexer_marker
33
#define YYFILL(n) { if ((n) == 1) { cursor = sentinel; limit = cursor + YYMAXFILL; eoi = 1; } }
34
35
36
static uchar sentinel[YYMAXFILL];
37
38
static Token update_state(IncludeState *s, int eoi, const uchar *cur,
const uchar *tok, const Token val)
39
{
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
if (eoi)
{
s->bytes_left = 0;
s->source = (const char *) s->source_base + s->orig_length;
if ( (tok >= sentinel) && (tok < (sentinel+YYMAXFILL)) )
s->token = s->source;
else
s->token = (const char *) tok;
} // if
else
{
s->bytes_left -= (unsigned int) (cur - ((const uchar *) s->source));
s->source = (const char *) cur;
s->token = (const char *) tok;
} // else
55
s->tokenlen = (unsigned int) (s->source - s->token);
56
57
s->tokenval = val;
return val;
58
59
} // update_state
60
Token preprocessor_lexer(IncludeState *s)
61
62
{
const uchar *cursor = (const uchar *) s->source;
63
const uchar *token = cursor;
64
const uchar *matchptr;
65
const uchar *limit = cursor + s->bytes_left;
66
int eoi = 0;
67
int saw_newline = 0;
68
69
/*!re2c
70
ANY = [\000-\377];
71
ANYLEGAL = [a-zA-Z0-9_/'*=+%^&|!#<>()[{}.,~^:;? \t\v\f\r\n\-\]\\];
72
73
74
75
76
77
78
79
80
O = [0-7];
D = [0-9];
L = [a-zA-Z_];
H = [a-fA-F0-9];
E = [Ee] [+-]? D+;
FS = [fFlL];
IS = [uUlL]*;
ESC = [\\] ([abfnrtv?'"\\] | "x" H+ | O+);
PP = "#" [ \t]*;
81
NEWLINE = ("\r\n" | "\r" | "\n");
82
83
84
WHITESPACE = [ \t\v\f]+;
*/
85
86
87
88
89
90
91
92
// preprocessor directives are only valid at start of line.
if (s->tokenval == ((Token) '\n'))
goto ppdirective; // may jump back to scanner_loop.
scanner_loop:
if (YYLIMIT == YYCURSOR) YYFILL(1);
token = cursor;
93
/*!re2c
94
95
"\\" [ \t\v\f]* NEWLINE { s->line++; goto scanner_loop; }
96
97
98
99
100
101
"/*" { goto multilinecomment; }
"//" { goto singlelinecomment; }
L (L|D)* { RET(TOKEN_IDENTIFIER); }
("0" [xX] H+ IS?) | ("0" D+ IS?) | (D+ IS?) |
102
(['] (ESC|ANY\[\r\n\\'])* ['])
103
104
105
106
107
{ RET(TOKEN_INT_LITERAL); }
(D+ E FS?) | (D* "." D+ E? FS?) | (D+ "." D* E? FS?)
{ RET(TOKEN_FLOAT_LITERAL); }
108
(["] (ESC|ANY\[\r\n\\"])* ["])
109
{ RET(TOKEN_STRING_LITERAL); }
110
111
112
113
114
115
116
117
118
119
120
121
122
">>=" { RET(TOKEN_RSHIFTASSIGN); }
"<<=" { RET(TOKEN_LSHIFTASSIGN); }
"+=" { RET(TOKEN_ADDASSIGN); }
"-=" { RET(TOKEN_SUBASSIGN); }
"*=" { RET(TOKEN_MULTASSIGN); }
"/=" { RET(TOKEN_DIVASSIGN); }
"%=" { RET(TOKEN_MODASSIGN); }
"^=" { RET(TOKEN_XORASSIGN); }
"&=" { RET(TOKEN_ANDASSIGN); }
"|=" { RET(TOKEN_ORASSIGN); }
"++" { RET(TOKEN_INCREMENT); }
"--" { RET(TOKEN_DECREMENT); }
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
">>" { RET(TOKEN_RSHIFT); }
"<<" { RET(TOKEN_LSHIFT); }
"&&" { RET(TOKEN_ANDAND); }
"||" { RET(TOKEN_OROR); }
"<=" { RET(TOKEN_LEQ); }
">=" { RET(TOKEN_GEQ); }
"==" { RET(TOKEN_EQL); }
"!=" { RET(TOKEN_NEQ); }
"##" { RET(TOKEN_HASHHASH); }
"(" { RET('('); }
")" { RET(')'); }
"[" { RET('['); }
"]" { RET(']'); }
"." { RET('.'); }
"," { RET(','); }
"&" { RET('&'); }
"!" { RET('!'); }
"~" { RET('~'); }
"-" { RET('-'); }
"+" { RET('+'); }
"*" { RET('*'); }
"/" { RET('/'); }
"%" { RET('%'); }
"<" { RET('<'); }
">" { RET('>'); }
"^" { RET('^'); }
"|" { RET('|'); }
":" { RET(':'); }
";" { RET(';'); }
"{" { RET('{'); }
"}" { RET('}'); }
"=" { RET('='); }
"?" { RET('?'); }
157
158
"\000" { if (eoi) { RET(TOKEN_EOI); } goto bad_chars; }
159
WHITESPACE { if (s->report_whitespace) RET(' '); goto scanner_loop; }
160
NEWLINE { s->line++; RET('\n'); }
161
ANY { goto bad_chars; }
162
163
164
*/
multilinecomment:
165
if (YYLIMIT == YYCURSOR) YYFILL(1);
166
matchptr = cursor;
167
168
// The "*\/" is just to avoid screwing up text editor syntax highlighting.
/*!re2c
169
170
171
"*\/" {
if (saw_newline)
RET('\n');
172
173
else if (s->report_whitespace)
RET(' ');
174
175
176
177
goto scanner_loop;
}
NEWLINE {
s->line++;
178
token = matchptr;
179
180
181
saw_newline = 1;
goto multilinecomment;
}
182
183
184
185
186
"\000" {
if (eoi)
RET(TOKEN_INCOMPLETE_COMMENT);
goto multilinecomment;
}
187
ANY { goto multilinecomment; }
188
189
190
*/
singlelinecomment:
191
if (YYLIMIT == YYCURSOR) YYFILL(1);
192
matchptr = cursor;
193
/*!re2c
194
NEWLINE { s->line++; token = matchptr; RET('\n'); }
195
"\000" { if (eoi) { RET(TOKEN_EOI); } goto singlelinecomment; }
196
ANY { goto singlelinecomment; }
197
198
*/
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
ppdirective:
if (YYLIMIT == YYCURSOR) YYFILL(1);
/*!re2c
PP "include" { RET(TOKEN_PP_INCLUDE); }
PP "line" { RET(TOKEN_PP_LINE); }
PP "define" { RET(TOKEN_PP_DEFINE); }
PP "undef" { RET(TOKEN_PP_UNDEF); }
PP "if" { RET(TOKEN_PP_IF); }
PP "ifdef" { RET(TOKEN_PP_IFDEF); }
PP "ifndef" { RET(TOKEN_PP_IFNDEF); }
PP "else" { RET(TOKEN_PP_ELSE); }
PP "elif" { RET(TOKEN_PP_ELIF); }
PP "endif" { RET(TOKEN_PP_ENDIF); }
PP "error" { RET(TOKEN_PP_ERROR); }
WHITESPACE { goto ppdirective; }
ANY { cursor=(const uchar*)s->source; goto scanner_loop; }
*/
217
bad_chars:
218
if (YYLIMIT == YYCURSOR) YYFILL(1);
219
/*!re2c
220
ANYLEGAL { cursor--; RET(TOKEN_BAD_CHARS); }
221
222
223
224
225
226
227
228
229
230
231
232
"\000" {
if (eoi)
{
assert( !((token >= sentinel) &&
(token < sentinel+YYMAXFILL)) );
eoi = 0;
cursor = (uchar *) s->source_base + s->orig_length;
RET(TOKEN_BAD_CHARS); // next call will be EOI.
}
goto bad_chars;
}
233
ANY { goto bad_chars; }
234
235
236
237
*/
assert(0 && "Shouldn't hit this code");
RET(TOKEN_UNKNOWN);
238
} // preprocessor_lexer
239
240
// end of mojoshader_lexer_preprocessor.re (or .c) ...