mojoshader_lexer.re
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
28
/*!max:re2c */
#define RET(t) do { update_state(s, eoi, cursor, token); return 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; } }
35
36
37
38
static uchar sentinel[YYMAXFILL];
static void update_state(IncludeState *s, int eoi,
const uchar *cur, const uchar *tok)
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
56
57
58
59
60
} // update_state
Token preprocessor_internal_lexer(IncludeState *s)
{
const uchar *cursor = (const uchar *) s->source;
const uchar *token;
61
const uchar *matchptr;
62
const uchar *limit = cursor + s->bytes_left;
64
int saw_newline = 0;
65
66
scanner_loop:
67
if (YYLIMIT == YYCURSOR) YYFILL(1);
68
69
70
token = cursor;
/*!re2c
71
ANY = [\000-\377];
72
ANYLEGAL = [a-zA-Z0-9_/'*=+%^&|!#<>()[{}.,~^:;? \t\v\f\r\n\-\]\\];
73
74
75
76
77
78
79
80
81
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]*;
82
NEWLINE = ("\r\n" | "\r" | "\n");
83
84
85
86
WHITESPACE = [ \t\v\f]+;
*/
/*!re2c
87
88
"\\" [ \t\v\f]* NEWLINE { s->line++; goto scanner_loop; }
89
90
91
92
93
94
"/*" { goto multilinecomment; }
"//" { goto singlelinecomment; }
L (L|D)* { RET(TOKEN_IDENTIFIER); }
("0" [xX] H+ IS?) | ("0" D+ IS?) | (D+ IS?) |
95
(['] (ESC|ANY\[\r\n\\'])* ['])
96
97
98
99
100
{ RET(TOKEN_INT_LITERAL); }
(D+ E FS?) | (D* "." D+ E? FS?) | (D+ "." D* E? FS?)
{ RET(TOKEN_FLOAT_LITERAL); }
101
(["] (ESC|ANY\[\r\n\\"])* ["])
102
{ RET(TOKEN_STRING_LITERAL); }
104
105
106
107
108
109
110
111
112
113
114
115
">>=" { 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); }
116
117
118
119
120
121
122
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
">>" { 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('?'); }
150
151
"\000" { if (eoi) { RET(TOKEN_EOI); } goto bad_chars; }
152
153
154
155
156
157
158
159
160
161
162
163
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); }
164
WHITESPACE { if (s->report_whitespace) RET(' '); goto scanner_loop; }
165
NEWLINE { s->line++; RET('\n'); }
166
ANY { goto bad_chars; }
167
168
169
*/
multilinecomment:
170
if (YYLIMIT == YYCURSOR) YYFILL(1);
171
matchptr = cursor;
172
173
// The "*\/" is just to avoid screwing up text editor syntax highlighting.
/*!re2c
174
175
176
"*\/" {
if (saw_newline)
RET('\n');
177
178
else if (s->report_whitespace)
RET(' ');
179
180
181
182
goto scanner_loop;
}
NEWLINE {
s->line++;
183
token = matchptr;
184
185
186
saw_newline = 1;
goto multilinecomment;
}
187
188
189
190
191
"\000" {
if (eoi)
RET(TOKEN_INCOMPLETE_COMMENT);
goto multilinecomment;
}
192
ANY { goto multilinecomment; }
193
194
195
*/
singlelinecomment:
196
if (YYLIMIT == YYCURSOR) YYFILL(1);
197
matchptr = cursor;
199
NEWLINE { s->line++; token = matchptr; RET('\n'); }
200
"\000" { if (eoi) { RET(TOKEN_EOI); } goto singlelinecomment; }
201
ANY { goto singlelinecomment; }
202
203
204
*/
bad_chars:
205
if (YYLIMIT == YYCURSOR) YYFILL(1);
207
ANYLEGAL { cursor--; RET(TOKEN_BAD_CHARS); }
208
209
210
211
212
213
214
215
216
217
218
219
"\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;
}
220
ANY { goto bad_chars; }
221
222
223
224
225
226
227
*/
assert(0 && "Shouldn't hit this code");
RET(TOKEN_UNKNOWN);
} // preprocessor_internal_lexer
// end of mojoshader_lexer_preprocessor.re (or .c) ...