/
mojoshader_parser_hlsl.lemon
579 lines (488 loc) · 36 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
* 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 is a Lemon Parser grammar for HLSL. It is based on an ANSI C YACC
// grammar by Jeff Lee: http://www.lysator.liu.se/c/ANSI-C-grammar-y.html
// Lemon is here: http://www.hwaci.com/sw/lemon/ ... the source is included
// with MojoShader, and built with the library, so you don't have to track
// down the dependency.
// HLSL syntax is described, informally, here:
// http://msdn.microsoft.com/en-us/library/bb509615(VS.85).aspx
%name ParseHLSL
22
23
// Some shift-reduce conflicts are basically unavoidable, but if the final
// conflict count matches this value, we consider it known and acceptable.
24
%expect 2
25
26
27
%start_symbol shader
%token_prefix TOKEN_HLSL_
28
%token_type { TokenData }
29
30
31
%extra_argument { Context *ctx }
%include {
32
33
34
#ifndef __MOJOSHADER_HLSL_COMPILER__
#error Do not compile this file directly.
#endif
35
}
36
37
%syntax_error {
38
// !!! FIXME: make this a proper fail() function.
39
fail(ctx, "Syntax error");
40
41
}
42
%parse_failure {
43
// !!! FIXME: make this a proper fail() function.
44
fail(ctx, "Giving up. Parser is hopelessly lost...");
45
46
47
}
%stack_overflow {
48
// !!! FIXME: make this a proper fail() function.
49
fail(ctx, "Giving up. Parser stack overflow");
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
}
// operator precedence (matches C spec)...
%left COMMA.
%right ASSIGN ADDASSIGN SUBASSIGN MULASSIGN DIVASSIGN MODASSIGN LSHIFTASSIGN
RSHIFTASSIGN ANDASSIGN ORASSIGN XORASSIGN.
%right QUESTION.
%left OROR.
%left ANDAND.
%left OR.
%left XOR.
%left AND.
%left EQL NEQ.
%left LT LEQ GT GEQ.
%left LSHIFT RSHIFT.
%left PLUS MINUS.
%left STAR SLASH PERCENT.
%right TYPECAST EXCLAMATION COMPLEMENT MINUSMINUS PLUSPLUS.
%left DOT LBRACKET RBRACKET LPAREN RPAREN.
71
72
73
74
// bump up the precedence of ELSE, to avoid shift/reduce conflict on the
// usual "dangling else ambiguity" ...
%right ELSE.
75
76
77
// The rules...
78
shader ::= compilation_units(B). { assert(ctx->ast == NULL); REVERSE_LINKED_LIST(CompilationUnit, B); ctx->ast = B; }
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
%type compilation_units { CompilationUnit * }
%destructor compilation_units { delete_compilation_unit(ctx, $$); }
compilation_units(A) ::= compilation_unit(B). { A = B; }
compilation_units(A) ::= compilation_units(B) compilation_unit(C). { if (C) { C->next = B; A = C; } }
%type compilation_unit { CompilationUnit * }
%destructor compilation_unit { delete_compilation_unit(ctx, $$); }
compilation_unit(A) ::= variable_declaration(B). { A = new_global_variable(ctx, B); }
compilation_unit(A) ::= function_signature(B) SEMICOLON. { A = new_function(ctx, B, NULL); }
compilation_unit(A) ::= function_signature(B) statement_block(C). { A = new_function(ctx, B, C); }
compilation_unit(A) ::= typedef(B). { A = new_global_typedef(ctx, B); }
compilation_unit(A) ::= struct_declaration(B) SEMICOLON. { A = new_global_struct(ctx, B); }
//compilation_unit(A) ::= error SEMICOLON. { A = NULL; } // !!! FIXME: research using the error nonterminal
%type typedef { Typedef * }
%destructor typedef { delete_typedef(ctx, $$); }
// !!! FIXME: should CONST be here, or in datatype?
97
98
typedef(A) ::= TYPEDEF CONST datatype(B) scalar_or_array(C). { A = new_typedef(ctx, 1, B, C); add_usertype(ctx, C->identifier); }
typedef(A) ::= TYPEDEF datatype(B) scalar_or_array(C). { A = new_typedef(ctx, 0, B, C); add_usertype(ctx, C->identifier); }
99
100
101
102
103
104
105
106
107
108
109
110
%type function_signature { FunctionSignature * }
%destructor function_signature { delete_function_signature(ctx, $$); }
function_signature(A) ::= function_storageclass(B) function_details(C) semantic(D). { A = C; A->storage_class = B; A->semantic = D; }
function_signature(A) ::= function_storageclass(B) function_details(C). { A = C; A->storage_class = B; }
function_signature(A) ::= function_details(B) semantic(C). { A = B; A->semantic = C; }
function_signature(A) ::= function_details(B). { A = B; }
%type function_details { FunctionSignature * }
%destructor function_details { delete_function_signature(ctx, $$); }
function_details(A) ::= datatype(B) IDENTIFIER(C) LPAREN function_arguments(D) RPAREN. { A = new_function_signature(ctx, B, C.string, D); }
function_details(A) ::= VOID IDENTIFIER(B) LPAREN function_arguments(C) RPAREN. { A = new_function_signature(ctx, NULL, B.string, C); }
111
112
113
114
115
116
117
// !!! FIXME: there is a "target" storage class that is the name of the
// !!! FIXME: platform that this function is meant for...but I don't know
// !!! FIXME: what tokens are valid here.
// !!! FIXME: Also, the docs say "one of" inline or target, but I bet you can
// !!! FIXME: specify both.
118
119
120
121
122
123
124
%type function_storageclass { FunctionStorageClass }
//function_storageclass(A) ::= target(B). { A = B; }
function_storageclass(A) ::= INLINE. { A = FNSTORECLS_INLINE; }
%type function_arguments { FunctionArguments * }
%destructor function_arguments { delete_function_args(ctx, $$); }
function_arguments(A) ::= VOID. { A = NULL; }
125
function_arguments(A) ::= function_argument_list(B). { REVERSE_LINKED_LIST(FunctionArguments, B); A = B; }
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
157
158
159
160
161
function_arguments(A) ::= . { A = NULL; }
%type function_argument_list { FunctionArguments * }
%destructor function_argument_list { delete_function_args(ctx, $$); }
function_argument_list(A) ::= function_argument(B). { A = B; }
function_argument_list(A) ::= function_argument_list(B) COMMA function_argument(C). { C->next = B; A = C; }
// !!! FIXME: this is pretty unreadable.
%type function_argument { FunctionArguments * }
%destructor function_argument { delete_function_args(ctx, $$); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) interpolation_mod(F) initializer(G). { A = new_function_arg(ctx, B, C, D.string, E, F, G); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) interpolation_mod(F). { A = new_function_arg(ctx, B, C, D.string, E, F, NULL); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) initializer(F). { A = new_function_arg(ctx, B, C, D.string, E, INTERPMOD_NONE, F); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E). { A = new_function_arg(ctx, B, C, D.string, E, INTERPMOD_NONE, NULL); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) interpolation_mod(E) initializer(F). { A = new_function_arg(ctx, B, C, D.string, NULL, E, F); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) interpolation_mod(E). { A = new_function_arg(ctx, B, C, D.string, NULL, E, NULL); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) initializer(E). { A = new_function_arg(ctx, B, C, D.string, NULL, INTERPMOD_NONE, E); }
function_argument(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D). { A = new_function_arg(ctx, B, C, D.string, NULL, INTERPMOD_NONE, NULL); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) semantic(D) interpolation_mod(E) initializer(F). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, D, E, F); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) semantic(D) interpolation_mod(E). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, D, E, NULL); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) semantic(D) initializer(E). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, D, INTERPMOD_NONE, E); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) semantic(D). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, D, INTERPMOD_NONE, NULL); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) interpolation_mod(D) initializer(E). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, NULL, D, E); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) interpolation_mod(D). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, NULL, D, NULL); }
function_argument(A) ::= datatype(B) IDENTIFIER(C) initializer(D). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, NULL, INTERPMOD_NONE, D); }
function_argument(A) ::= datatype(B) IDENTIFIER(C). { A = new_function_arg(ctx, INPUTMOD_NONE, B, C.string, NULL, INTERPMOD_NONE, NULL); }
%type input_modifier { InputModifier }
input_modifier(A) ::= IN. { A = INPUTMOD_IN; }
input_modifier(A) ::= INOUT. { A = INPUTMOD_INOUT; }
input_modifier(A) ::= OUT. { A = INPUTMOD_OUT; }
input_modifier(A) ::= IN OUT. { A = INPUTMOD_INOUT; }
input_modifier(A) ::= OUT IN. { A = INPUTMOD_INOUT; }
input_modifier(A) ::= UNIFORM. { A = INPUTMOD_UNIFORM; }
%type semantic { const char * }
162
semantic(A) ::= COLON IDENTIFIER(B). { A = B.string; }
163
164
// DX10 only?
165
166
167
168
169
170
171
172
173
%type interpolation_mod { InterpolationModifier }
interpolation_mod(A) ::= LINEAR. { A = INTERPMOD_LINEAR; }
interpolation_mod(A) ::= CENTROID. { A = INTERPMOD_CENTROID; }
interpolation_mod(A) ::= NOINTERPOLATION. { A = INTERPMOD_NOINTERPOLATION; }
interpolation_mod(A) ::= NOPERSPECTIVE. { A = INTERPMOD_NOPERSPECTIVE; }
interpolation_mod(A) ::= SAMPLE. { A = INTERPMOD_SAMPLE; }
%type variable_declaration { VariableDeclaration * }
%destructor variable_declaration { delete_variable_declaration(ctx, $$); }
174
175
176
variable_declaration(A) ::= variable_attribute_list(B) datatype(C) variable_declaration_details_list(D) SEMICOLON. { REVERSE_LINKED_LIST(VariableDeclaration, D); A = D; A->attributes = B; A->datatype = C; }
variable_declaration(A) ::= datatype(B) variable_declaration_details_list(C) SEMICOLON. { REVERSE_LINKED_LIST(VariableDeclaration, C); A = C; A->datatype = B; }
variable_declaration(A) ::= struct_declaration(B) variable_declaration_details_list(C) SEMICOLON. { REVERSE_LINKED_LIST(VariableDeclaration, C); A = C; A->anonymous_datatype = B; }
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
%type variable_attribute_list { int }
variable_attribute_list(A) ::= variable_attribute(B). { A = B; }
variable_attribute_list(A) ::= variable_attribute_list(B) variable_attribute(C). { A = B | C; }
%type variable_attribute { int }
variable_attribute(A) ::= EXTERN. { A = VARATTR_EXTERN; }
variable_attribute(A) ::= NOINTERPOLATION. { A = VARATTR_NOINTERPOLATION; }
variable_attribute(A) ::= SHARED. { A = VARATTR_SHARED; }
variable_attribute(A) ::= STATIC. { A = VARATTR_STATIC; }
variable_attribute(A) ::= UNIFORM. { A = VARATTR_UNIFORM; }
variable_attribute(A) ::= VOLATILE. { A = VARATTR_VOLATILE; }
variable_attribute(A) ::= CONST. { A = VARATTR_CONST; }
variable_attribute(A) ::= ROWMAJOR. { A = VARATTR_ROWMAJOR; }
variable_attribute(A) ::= COLUMNMAJOR. { A = VARATTR_COLUMNMAJOR; }
%type variable_declaration_details_list { VariableDeclaration * }
%destructor variable_declaration_details_list { delete_variable_declaration(ctx, $$); }
variable_declaration_details_list(A) ::= variable_declaration_details(B). { A = B; }
variable_declaration_details_list(A) ::= variable_declaration_details_list(B) COMMA variable_declaration_details(C). { A = C; A->next = B; }
%type variable_declaration_details { VariableDeclaration * }
%destructor variable_declaration_details { delete_variable_declaration(ctx, $$); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) annotations(D) initializer(E) variable_lowlevel(F). { A = new_variable_declaration(ctx, B, C, D, E, F); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) annotations(D) initializer(E). { A = new_variable_declaration(ctx, B, C, D, E, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) annotations(D) variable_lowlevel(E). { A = new_variable_declaration(ctx, B, C, D, NULL, E); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) annotations(D). { A = new_variable_declaration(ctx, B, C, D, NULL, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) initializer(D) variable_lowlevel(E). { A = new_variable_declaration(ctx, B, C, NULL, D, E); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) initializer(D). { A = new_variable_declaration(ctx, B, C, NULL, D, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C) variable_lowlevel(D). { A = new_variable_declaration(ctx, B, C, NULL, NULL, D); }
variable_declaration_details(A) ::= scalar_or_array(B) semantic(C). { A = new_variable_declaration(ctx, B, C, NULL, NULL, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) annotations(C) initializer(D) variable_lowlevel(E). { A = new_variable_declaration(ctx, B, NULL, C, D, E); }
variable_declaration_details(A) ::= scalar_or_array(B) annotations(C) initializer(D). { A = new_variable_declaration(ctx, B, NULL, C, D, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) annotations(C) variable_lowlevel(D). { A = new_variable_declaration(ctx, B, NULL, C, NULL, D); }
variable_declaration_details(A) ::= scalar_or_array(B) annotations(C). { A = new_variable_declaration(ctx, B, NULL, C, NULL, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) initializer(C) variable_lowlevel(D). { A = new_variable_declaration(ctx, B, NULL, NULL, C, D); }
variable_declaration_details(A) ::= scalar_or_array(B) initializer(C). { A = new_variable_declaration(ctx, B, NULL, NULL, C, NULL); }
variable_declaration_details(A) ::= scalar_or_array(B) variable_lowlevel(C). { A = new_variable_declaration(ctx, B, NULL, NULL, NULL, C); }
variable_declaration_details(A) ::= scalar_or_array(B). { A = new_variable_declaration(ctx, B, NULL, NULL, NULL, NULL); }
216
217
218
// !!! FIXME: we don't handle full sampler declarations at the moment.
219
220
221
%type struct_declaration { StructDeclaration * }
%destructor struct_declaration { delete_struct_declaration(ctx, $$); }
222
struct_declaration(A) ::= struct_intro(B) LBRACE struct_member_list(C) RBRACE. { REVERSE_LINKED_LIST(StructMembers, C); A = new_struct_declaration(ctx, B, C); }
223
224
225
226
// This has to be separate from struct_declaration so that the struct is in the usertypemap when parsing its members.
%type struct_intro { const char * }
struct_intro(A) ::= STRUCT IDENTIFIER(B). { A = B.string; add_usertype(ctx, A); }
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
%type struct_member_list { StructMembers * }
%destructor struct_member_list { delete_struct_member(ctx, $$); }
struct_member_list(A) ::= struct_member(B). { A = B; }
struct_member_list(A) ::= struct_member_list(B) struct_member(C). { A = C; A->next = B; }
%type struct_member { StructMembers * }
%destructor struct_member { delete_struct_member(ctx, $$); }
struct_member(A) ::= interpolation_mod(B) struct_member_details(C). { StructMembers *i = C; A = C; while (i) { i->interpolation_mod = B; i = i->next; } }
struct_member(A) ::= struct_member_details(B). { A = B; }
%type struct_member_details { StructMembers * }
%destructor struct_member_details { delete_struct_member(ctx, $$); }
struct_member_details(A) ::= datatype(B) struct_member_item_list(C) SEMICOLON. { StructMembers *i = C; A = C; while (i) { i->datatype = B; i = i->next; } }
%type struct_member_item_list { StructMembers * }
%destructor struct_member_item_list { delete_struct_member(ctx, $$); }
struct_member_item_list(A) ::= scalar_or_array(B). { A = new_struct_member(ctx, B, NULL); }
struct_member_item_list(A) ::= scalar_or_array(B) semantic(C). { A = new_struct_member(ctx, B, C); }
struct_member_item_list(A) ::= struct_member_item_list(B) COMMA IDENTIFIER(C). { A = new_struct_member(ctx, new_scalar_or_array(ctx, C.string, 0, NULL), NULL); A->next = B; A->semantic = B->semantic; }
%type variable_lowlevel { VariableLowLevel * }
%destructor variable_lowlevel { delete_variable_lowlevel(ctx, $$); }
variable_lowlevel(A) ::= packoffset(B) register(C). { A = new_variable_lowlevel(ctx, B, C); }
variable_lowlevel(A) ::= register(B) packoffset(C). { A = new_variable_lowlevel(ctx, C, B); }
variable_lowlevel(A) ::= packoffset(B). { A = new_variable_lowlevel(ctx, B, NULL); }
variable_lowlevel(A) ::= register(B). { A = new_variable_lowlevel(ctx, NULL, B); }
// !!! FIXME: I sort of hate this type name.
%type scalar_or_array { ScalarOrArray * }
%destructor scalar_or_array { delete_scalar_or_array(ctx, $$); }
scalar_or_array(A) ::= IDENTIFIER(B) LBRACKET RBRACKET. { A = new_scalar_or_array(ctx, B.string, 1, NULL); }
scalar_or_array(A) ::= IDENTIFIER(B) LBRACKET expression(C) RBRACKET. { A = new_scalar_or_array(ctx, B.string, 1, C); }
scalar_or_array(A) ::= IDENTIFIER(B). { A = new_scalar_or_array(ctx, B.string, 0, NULL); }
%type packoffset { PackOffset * }
%destructor packoffset { delete_pack_offset(ctx, $$); }
packoffset(A) ::= COLON PACKOFFSET LPAREN IDENTIFIER(B) DOT IDENTIFIER(C) RPAREN. { A = new_pack_offset(ctx, B.string, C.string); }
packoffset(A) ::= COLON PACKOFFSET LPAREN IDENTIFIER(B) RPAREN. { A = new_pack_offset(ctx, B.string, NULL); }
// !!! FIXME: can take a profile, like ": register(ps_5_0, s)"
// !!! FIXME: IDENTIFIER is wrong: "s[2]" works, apparently. Use scalar_or_array instead?
// !!! FIXME: (these might be SM4 features)
%type register { const char * }
register(A) ::= COLON REGISTER LPAREN IDENTIFIER(B) RPAREN. { A = B.string; }
%type annotations { Annotations * }
%destructor annotations { delete_annotation(ctx, $$); }
275
annotations(A) ::= LT annotation_list(B) GT. { REVERSE_LINKED_LIST(Annotations, B); A = B; }
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
%type annotation_list { Annotations * }
%destructor annotation_list { delete_annotation(ctx, $$); }
annotation_list(A) ::= annotation(B). { A = B; }
annotation_list(A) ::= annotation_list(B) annotation(C). { A = C; A->next = B; }
// !!! FIXME: can this take a USERTYPE if we typedef'd a scalar type?
%type annotation { Annotations * }
%destructor annotation { delete_annotation(ctx, $$); }
annotation(A) ::= datatype_scalar(B) initializer(C) SEMICOLON. { A = new_annotation(ctx, B, C); }
%type initializer_block_list { Expression * }
%destructor initializer_block_list { delete_expr(ctx, $$); }
initializer_block_list(A) ::= expression(B). { A = B; }
initializer_block_list(A) ::= LBRACE initializer_block_list(B) RBRACE. { A = B; }
291
initializer_block_list(A) ::= initializer_block_list(B) COMMA initializer_block_list(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
%type initializer_block { Expression * }
%destructor initializer_block { delete_expr(ctx, $$); }
initializer_block(A) ::= LBRACE initializer_block_list(B) RBRACE. { A = B; }
%type initializer { Expression * }
%destructor initializer { delete_expr(ctx, $$); }
initializer(A) ::= ASSIGN initializer_block(B). { A = B; }
initializer(A) ::= ASSIGN expression(B). { A = B; }
%type intrinsic_datatype { const char * }
intrinsic_datatype(A) ::= datatype_vector(B). { A = B; }
intrinsic_datatype(A) ::= datatype_matrix(B). { A = B; }
intrinsic_datatype(A) ::= datatype_scalar(B). { A = B; }
intrinsic_datatype(A) ::= datatype_sampler(B). { A = B; }
%type datatype { const char * }
datatype(A) ::= intrinsic_datatype(B). { A = B; }
datatype(A) ::= USERTYPE(B). { A = B.string; }
%type datatype_sampler { const char * }
313
314
315
316
317
318
319
320
datatype_sampler(A) ::= SAMPLER. { A = stringcache_fmt(ctx->strcache, "s1"); }
datatype_sampler(A) ::= SAMPLER1D. { A = stringcache_fmt(ctx->strcache, "s1"); }
datatype_sampler(A) ::= SAMPLER2D. { A = stringcache_fmt(ctx->strcache, "s2"); }
datatype_sampler(A) ::= SAMPLER3D. { A = stringcache_fmt(ctx->strcache, "s3"); }
datatype_sampler(A) ::= SAMPLERCUBE. { A = stringcache_fmt(ctx->strcache, "sc"); }
datatype_sampler(A) ::= SAMPLER_STATE. { A = stringcache_fmt(ctx->strcache, "ss"); }
datatype_sampler(A) ::= SAMPLERSTATE. { A = stringcache_fmt(ctx->strcache, "ss"); }
datatype_sampler(A) ::= SAMPLERCOMPARISONSTATE. { A = stringcache_fmt(ctx->strcache, "sS"); }
321
322
%type datatype_scalar { const char * }
323
324
325
326
327
328
329
330
331
332
datatype_scalar(A) ::= BOOL. { A = stringcache_fmt(ctx->strcache, "b"); }
datatype_scalar(A) ::= INT. { A = stringcache_fmt(ctx->strcache, "i"); }
datatype_scalar(A) ::= UINT. { A = stringcache_fmt(ctx->strcache, "u"); }
datatype_scalar(A) ::= HALF. { A = stringcache_fmt(ctx->strcache, "h"); }
datatype_scalar(A) ::= FLOAT. { A = stringcache_fmt(ctx->strcache, "f"); }
datatype_scalar(A) ::= DOUBLE. { A = stringcache_fmt(ctx->strcache, "d"); }
datatype_scalar(A) ::= STRING. { A = stringcache_fmt(ctx->strcache, "S"); } // this is for the effects framework, not HLSL.
datatype_scalar(A) ::= SNORM FLOAT. { A = stringcache_fmt(ctx->strcache, "Fs"); }
datatype_scalar(A) ::= UNORM FLOAT. { A = stringcache_fmt(ctx->strcache, "Fu"); }
datatype_scalar(A) ::= BUFFER LT datatype_scalar(B) GT. { A = stringcache_fmt(ctx->strcache, "B%s", B); }
333
334
335
336
337
338
// !!! FIXME: MSDN suggests that the matrix ones are just typedefs inserted
// !!! FIXME: before parsing begins, like:
// !!! FIXME: typedef matrix <bool,4,3> bool4x3;
// !!! FIXME: ...maybe we can rip these out of the grammar and just create
// !!! FIXME: them at startup?
339
%type datatype_vector { const char * }
340
datatype_vector(A) ::= VECTOR LT datatype_scalar(B) COMMA INT_CONSTANT(C) GT. { A = stringcache_fmt(ctx->strcache, "v%d%s", (int) C.i64, B); }
341
342
%type datatype_matrix { const char * }
343
datatype_matrix(A) ::= MATRIX LT datatype_scalar(B) COMMA INT_CONSTANT(C) COMMA INT_CONSTANT(D) GT. { A = stringcache_fmt(ctx->strcache, "m%d%d%s", (int) C.i64, (int) D.i64, B); }
344
345
346
347
%type statement_block { Statement * }
%destructor statement_block { delete_statement(ctx, $$); }
statement_block(A) ::= LBRACE RBRACE. { A = new_empty_statement(ctx); }
348
statement_block(A) ::= LBRACE statement_list(B) RBRACE. { REVERSE_LINKED_LIST(Statement, B); A = B; }
349
350
351
352
%type statement_list { Statement * }
%destructor statement_list { delete_statement(ctx, $$); }
statement_list(A) ::= statement(B). { A = B; }
353
statement_list(A) ::= statement_list(B) statement(C). { A = C; A->next = B; }
354
355
// These are for Shader Model 4 and Xbox 360 only, apparently.
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
// !!! FIXME: ...so we ignore them for now.
// !!! FIXME: can these stack? "[isolate][unused]{}" or something?
%type statement_attribute { int }
statement_attribute(A) ::= ISOLATE. { A = 0; } // !!! FIXME
statement_attribute(A) ::= MAXINSTRUCTIONCOUNT LPAREN INT_CONSTANT RPAREN. { A = 0; } // !!! FIXME
statement_attribute(A) ::= NOEXPRESSIONOPTIMIZATIONS. { A = 0; } // !!! FIXME
statement_attribute(A) ::= REMOVEUNUSEDINPUTS. { A = 0; } // !!! FIXME
statement_attribute(A) ::= UNUSED. { A = 0; } // !!! FIXME
statement_attribute(A) ::= XPS. { A = 0; } // !!! FIXME
%type statement { Statement * }
%destructor statement { delete_statement(ctx, $$); }
statement(A) ::= BREAK SEMICOLON. { A = new_break_statement(ctx); }
statement(A) ::= CONTINUE SEMICOLON. { A = new_continue_statement(ctx); }
statement(A) ::= DISCARD SEMICOLON. { A = new_discard_statement(ctx); }
statement(A) ::= LBRACKET statement_attribute(B) RBRACKET statement_block(C). { A = C; /* !!! FIXME: A->attributes = B;*/ B = 0; }
statement(A) ::= variable_declaration(B). { A = new_vardecl_statement(ctx, B); }
statement(A) ::= struct_declaration(B) SEMICOLON. { A = new_struct_statement(ctx, B); }
statement(A) ::= do_intro(B) DO statement(C) WHILE LPAREN expression(D) RPAREN SEMICOLON. { A = new_do_statement(ctx, B, C, D); }
statement(A) ::= while_intro(B) LPAREN expression(C) RPAREN statement(D). { A = new_while_statement(ctx, B, C, D); }
statement(A) ::= if_intro(B) LPAREN expression(C) RPAREN statement(D). { A = new_if_statement(ctx, B, C, D, NULL); }
statement(A) ::= if_intro(B) LPAREN expression(C) RPAREN statement(D) ELSE statement(E). { A = new_if_statement(ctx, B, C, D, E); }
378
statement(A) ::= switch_intro(B) LPAREN expression(C) RPAREN LBRACE switch_case_list(D) RBRACE. { REVERSE_LINKED_LIST(SwitchCases, D); A = new_switch_statement(ctx, B, C, D); }
379
380
381
382
383
384
385
386
387
388
389
390
391
statement(A) ::= typedef(B). { A = new_typedef_statement(ctx, B); }
statement(A) ::= SEMICOLON. { A = new_empty_statement(ctx); }
statement(A) ::= expression(B) SEMICOLON. { A = new_expr_statement(ctx, B); }
statement(A) ::= RETURN SEMICOLON. { A = new_return_statement(ctx, NULL); }
statement(A) ::= RETURN expression(B) SEMICOLON. { A = new_return_statement(ctx, B); }
statement(A) ::= statement_block(B). { A = B; }
statement(A) ::= for_statement(B). { A = B; }
//statement(A) ::= error SEMICOLON. { A = NULL; } // !!! FIXME: research using the error nonterminal
%type while_intro { int64 }
while_intro(A) ::= LBRACKET UNROLL LPAREN INT_CONSTANT(B) RPAREN RBRACKET WHILE. { A = (B.i64 < 0) ? 0 : B.i64; }
while_intro(A) ::= LBRACKET UNROLL RBRACKET WHILE. { A = -1; }
while_intro(A) ::= LBRACKET LOOP RBRACKET WHILE. { A = 0; }
392
while_intro(A) ::= WHILE. { A = -2; }
393
394
395
396
397
398
399
400
401
%type for_statement { Statement * }
%destructor for_statement { delete_statement(ctx, $$); }
for_statement(A) ::= for_intro(B) for_details(C). { A = C; ((ForStatement *) A)->unroll = B; }
%type for_intro { int64 }
for_intro(A) ::= LBRACKET UNROLL LPAREN INT_CONSTANT(B) RPAREN RBRACKET FOR. { A = (B.i64 < 0) ? 0 : B.i64; }
for_intro(A) ::= LBRACKET UNROLL RBRACKET FOR. { A = -1; }
for_intro(A) ::= LBRACKET LOOP RBRACKET FOR. { A = 0; }
402
for_intro(A) ::= FOR. { A = -2; }
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
%type for_details { Statement * }
%destructor for_details { delete_statement(ctx, $$); }
for_details(A) ::= LPAREN expression(B) SEMICOLON expression(C) SEMICOLON expression(D) RPAREN statement(E). { A = new_for_statement(ctx, NULL, B, C, D, E); }
for_details(A) ::= LPAREN SEMICOLON SEMICOLON RPAREN statement(B). { A = new_for_statement(ctx, NULL, NULL, NULL, NULL, B); }
for_details(A) ::= LPAREN SEMICOLON SEMICOLON expression(B) RPAREN statement(C). { A = new_for_statement(ctx, NULL, NULL, NULL, B, C); }
for_details(A) ::= LPAREN SEMICOLON expression(B) SEMICOLON RPAREN statement(C). { A = new_for_statement(ctx, NULL, NULL, B, NULL, C); }
for_details(A) ::= LPAREN SEMICOLON expression(B) SEMICOLON expression(C) RPAREN statement(D). { A = new_for_statement(ctx, NULL, NULL, B, C, D); }
for_details(A) ::= LPAREN expression(B) SEMICOLON SEMICOLON RPAREN statement(C). { A = new_for_statement(ctx, NULL, B, NULL, NULL, C); }
for_details(A) ::= LPAREN expression(B) SEMICOLON SEMICOLON expression(C) RPAREN statement(D). { A = new_for_statement(ctx, NULL, B, NULL, C, D); }
for_details(A) ::= LPAREN expression(B) SEMICOLON expression(C) SEMICOLON RPAREN statement(D). { A = new_for_statement(ctx, NULL, B, C, NULL, D); }
for_details(A) ::= LPAREN variable_declaration(B) expression(C) SEMICOLON expression(D) RPAREN statement(E). { A = new_for_statement(ctx, B, NULL, C, D, E); }
for_details(A) ::= LPAREN variable_declaration(B) SEMICOLON RPAREN statement(C). { A = new_for_statement(ctx, B, NULL, NULL, NULL, C); }
for_details(A) ::= LPAREN variable_declaration(B) SEMICOLON expression(C) RPAREN statement(D). { A = new_for_statement(ctx, B, NULL, C, NULL, D); }
for_details(A) ::= LPAREN variable_declaration(B) expression(C) SEMICOLON RPAREN statement(D). { A = new_for_statement(ctx, B, NULL, C, NULL, D); }
%type do_intro { int64 }
do_intro(A) ::= LBRACKET UNROLL LPAREN INT_CONSTANT(B) RPAREN RBRACKET DO. { A = (B.i64 < 0) ? 0 : (int) B.i64; }
do_intro(A) ::= LBRACKET UNROLL RBRACKET DO. { A = -1; }
do_intro(A) ::= LBRACKET LOOP RBRACKET DO. { A = 0; }
423
do_intro(A) ::= DO. { A = -2; }
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
%type if_intro { int }
if_intro(A) ::= LBRACKET BRANCH RBRACKET IF. { A = IFATTR_BRANCH; }
if_intro(A) ::= LBRACKET FLATTEN RBRACKET IF. { A = IFATTR_FLATTEN; }
if_intro(A) ::= LBRACKET IFALL RBRACKET IF. { A = IFATTR_IFALL; }
if_intro(A) ::= LBRACKET IFANY RBRACKET IF. { A = IFATTR_IFANY; }
if_intro(A) ::= LBRACKET PREDICATE RBRACKET IF. { A = IFATTR_PREDICATE; }
if_intro(A) ::= LBRACKET PREDICATEBLOCK RBRACKET IF. { A = IFATTR_PREDICATEBLOCK; }
if_intro(A) ::= IF. { A = IFATTR_NONE; }
%type switch_intro { int }
switch_intro(A) ::= LBRACKET FLATTEN RBRACKET SWITCH. { A = SWITCHATTR_FLATTEN; }
switch_intro(A) ::= LBRACKET BRANCH RBRACKET SWITCH. { A = SWITCHATTR_BRANCH; }
switch_intro(A) ::= LBRACKET FORCECASE RBRACKET SWITCH. { A = SWITCHATTR_FORCECASE; }
switch_intro(A) ::= LBRACKET CALL RBRACKET SWITCH. { A = SWITCHATTR_CALL; }
switch_intro(A) ::= SWITCH. { A = SWITCHATTR_NONE; }
%type switch_case_list { SwitchCases * }
%destructor switch_case_list { delete_switch_case(ctx, $$); }
switch_case_list(A) ::= switch_case(B). { A = B; }
switch_case_list(A) ::= switch_case_list(B) switch_case(C). { A = C; A->next = B; }
445
446
447
// You can do math here, apparently, as long as it produces an int constant.
// ...so "case 3+2:" works.
448
449
%type switch_case { SwitchCases * }
%destructor switch_case { delete_switch_case(ctx, $$); }
450
switch_case(A) ::= CASE expression(B) COLON statement_list(C). { REVERSE_LINKED_LIST(Statement, C); A = new_switch_case(ctx, B, C); }
451
switch_case(A) ::= CASE expression(B) COLON. { A = new_switch_case(ctx, B, NULL); }
452
switch_case(A) ::= DEFAULT COLON statement_list(B). { REVERSE_LINKED_LIST(Statement, B); A = new_switch_case(ctx, NULL, B); }
453
switch_case(A) ::= DEFAULT COLON. { A = new_switch_case(ctx, NULL, NULL); }
454
455
// the expression stuff is based on Jeff Lee's ANSI C grammar.
456
%type primary_expr { Expression * }
457
%destructor primary_expr { delete_expr(ctx, $$); }
458
459
460
461
462
463
464
primary_expr(A) ::= IDENTIFIER(B). { A = new_identifier_expr(ctx, B.string); }
primary_expr(A) ::= INT_CONSTANT(B). { A = new_literal_int_expr(ctx, B.i64); }
primary_expr(A) ::= FLOAT_CONSTANT(B). { A = new_literal_float_expr(ctx, B.dbl); }
primary_expr(A) ::= STRING_LITERAL(B). { A = new_literal_string_expr(ctx, B.string); }
primary_expr(A) ::= LPAREN expression(B) RPAREN. { A = B; }
%type postfix_expr { Expression * }
465
%destructor postfix_expr { delete_expr(ctx, $$); }
466
postfix_expr(A) ::= primary_expr(B). { A = B; }
467
468
469
postfix_expr(A) ::= postfix_expr(B) LBRACKET expression(C) RBRACKET. { A = new_binary_expr(ctx, AST_OP_DEREF_ARRAY, B, C); }
postfix_expr(A) ::= postfix_expr(B) LPAREN RPAREN. { A = new_binary_expr(ctx, AST_OP_CALLFUNC, B, NULL); }
postfix_expr(A) ::= postfix_expr(B) LPAREN argument_expr_list(C) RPAREN. { A = new_binary_expr(ctx, AST_OP_CALLFUNC, B, C); }
470
postfix_expr(A) ::= datatype(B) LPAREN argument_expr_list(C) RPAREN. { A = NULL; new_constructor_expr(ctx, B, C); } // HLSL constructor
471
472
473
postfix_expr(A) ::= postfix_expr(B) DOT IDENTIFIER(C). { A = new_binary_expr(ctx, AST_OP_DEREF_STRUCT, B, new_identifier_expr(ctx, C.string)); }
postfix_expr(A) ::= postfix_expr(B) PLUSPLUS. { A = new_unary_expr(ctx, AST_OP_POSTINCREMENT, B); }
postfix_expr(A) ::= postfix_expr(B) MINUSMINUS. { A = new_unary_expr(ctx, AST_OP_POSTDECREMENT, B); }
474
475
%type argument_expr_list { Expression * }
476
%destructor argument_expr_list { delete_expr(ctx, $$); }
477
argument_expr_list(A) ::= assignment_expr(B). { A = B; }
478
argument_expr_list(A) ::= argument_expr_list(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
479
480
%type unary_expr { Expression * }
481
482
%destructor unary_expr { delete_expr(ctx, $$); }
unary_expr(A) ::= postfix_expr(B). { A = B; }
483
484
unary_expr(A) ::= PLUSPLUS unary_expr(B). { A = new_unary_expr(ctx, AST_OP_PREINCREMENT, B); }
unary_expr(A) ::= MINUSMINUS unary_expr(B). { A = new_unary_expr(ctx, AST_OP_PREDECREMENT, B); }
485
unary_expr(A) ::= PLUS cast_expr(B). { A = B; } // unary "+x" is always a no-op, so throw it away here.
486
487
488
unary_expr(A) ::= MINUS cast_expr(B). { A = new_unary_expr(ctx, AST_OP_NEGATE, B); }
unary_expr(A) ::= COMPLEMENT cast_expr(B). { A = new_unary_expr(ctx, AST_OP_COMPLEMENT, B); }
unary_expr(A) ::= EXCLAMATION cast_expr(B). { A = new_unary_expr(ctx, AST_OP_NOT, B); }
489
490
%type cast_expr { Expression * }
491
%destructor cast_expr { delete_expr(ctx, $$); }
492
cast_expr(A) ::= unary_expr(B). { A = B; }
493
cast_expr(A) ::= LPAREN datatype(B) RPAREN cast_expr(C). { A = new_cast_expr(ctx, B, C); }
494
495
%type multiplicative_expr { Expression * }
496
%destructor multiplicative_expr { delete_expr(ctx, $$); }
497
multiplicative_expr(A) ::= cast_expr(B). { A = B; }
498
499
500
multiplicative_expr(A) ::= multiplicative_expr(B) STAR cast_expr(C). { A = new_binary_expr(ctx, AST_OP_MULTIPLY, B, C); }
multiplicative_expr(A) ::= multiplicative_expr(B) SLASH cast_expr(C). { A = new_binary_expr(ctx, AST_OP_DIVIDE, B, C); }
multiplicative_expr(A) ::= multiplicative_expr(B) PERCENT cast_expr(C). { A = new_binary_expr(ctx, AST_OP_MODULO, B, C); }
501
502
%type additive_expr { Expression * }
503
%destructor additive_expr { delete_expr(ctx, $$); }
504
additive_expr(A) ::= multiplicative_expr(B). { A = B; }
505
506
additive_expr(A) ::= additive_expr(B) PLUS multiplicative_expr(C). { A = new_binary_expr(ctx, AST_OP_ADD, B, C); }
additive_expr(A) ::= additive_expr(B) MINUS multiplicative_expr(C). { A = new_binary_expr(ctx, AST_OP_SUBTRACT, B, C); }
507
508
%type shift_expr { Expression * }
509
%destructor shift_expr { delete_expr(ctx, $$); }
510
shift_expr(A) ::= additive_expr(B). { A = B; }
511
512
shift_expr(A) ::= shift_expr(B) LSHIFT additive_expr(C). { A = new_binary_expr(ctx, AST_OP_LSHIFT, B, C); }
shift_expr(A) ::= shift_expr(B) RSHIFT additive_expr(C). { A = new_binary_expr(ctx, AST_OP_RSHIFT, B, C); }
513
514
%type relational_expr { Expression * }
515
%destructor relational_expr { delete_expr(ctx, $$); }
516
relational_expr(A) ::= shift_expr(B). { A = B; }
517
518
519
520
relational_expr(A) ::= relational_expr(B) LT shift_expr(C). { A = new_binary_expr(ctx, AST_OP_LESSTHAN, B, C); }
relational_expr(A) ::= relational_expr(B) GT shift_expr(C). { A = new_binary_expr(ctx, AST_OP_GREATERTHAN, B, C); }
relational_expr(A) ::= relational_expr(B) LEQ shift_expr(C). { A = new_binary_expr(ctx, AST_OP_LESSTHANOREQUAL, B, C); }
relational_expr(A) ::= relational_expr(B) GEQ shift_expr(C). { A = new_binary_expr(ctx, AST_OP_GREATERTHANOREQUAL, B, C); }
521
522
%type equality_expr { Expression * }
523
%destructor equality_expr { delete_expr(ctx, $$); }
524
equality_expr(A) ::= relational_expr(B). { A = B; }
525
526
equality_expr(A) ::= equality_expr(B) EQL relational_expr(C). { A = new_binary_expr(ctx, AST_OP_EQUAL, B, C); }
equality_expr(A) ::= equality_expr(B) NEQ relational_expr(C). { A = new_binary_expr(ctx, AST_OP_NOTEQUAL, B, C); }
527
528
%type and_expr { Expression * }
529
%destructor and_expr { delete_expr(ctx, $$); }
530
and_expr(A) ::= equality_expr(B). { A = B; }
531
and_expr(A) ::= and_expr(B) AND equality_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYAND, B, C); }
532
533
%type exclusive_or_expr { Expression * }
534
%destructor exclusive_or_expr { delete_expr(ctx, $$); }
535
exclusive_or_expr(A) ::= and_expr(B). { A = B; }
536
exclusive_or_expr(A) ::= exclusive_or_expr(B) XOR and_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYXOR, B, C); }
537
538
%type inclusive_or_expr { Expression * }
539
%destructor inclusive_or_expr { delete_expr(ctx, $$); }
540
inclusive_or_expr(A) ::= exclusive_or_expr(B). { A = B; }
541
inclusive_or_expr(A) ::= inclusive_or_expr(B) OR exclusive_or_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYOR, B, C); }
542
543
%type logical_and_expr { Expression * }
544
%destructor logical_and_expr { delete_expr(ctx, $$); }
545
logical_and_expr(A) ::= inclusive_or_expr(B). { A = B; }
546
logical_and_expr(A) ::= logical_and_expr(B) ANDAND inclusive_or_expr(C). { A = new_binary_expr(ctx, AST_OP_LOGICALAND, B, C); }
547
548
%type logical_or_expr { Expression * }
549
%destructor logical_or_expr { delete_expr(ctx, $$); }
550
logical_or_expr(A) ::= logical_and_expr(B). { A = B; }
551
logical_or_expr(A) ::= logical_or_expr(B) OROR logical_and_expr(C). { A = new_binary_expr(ctx, AST_OP_LOGICALOR, B, C); }
552
553
%type conditional_expr { Expression * }
554
%destructor conditional_expr { delete_expr(ctx, $$); }
555
conditional_expr(A) ::= logical_or_expr(B). { A = B; }
556
conditional_expr(A) ::= logical_or_expr(B) QUESTION logical_or_expr(C) COLON conditional_expr(D). { A = new_ternary_expr(ctx, AST_OP_CONDITIONAL, B, C, D); }
557
558
%type assignment_expr { Expression * }
559
%destructor assignment_expr { delete_expr(ctx, $$); }
560
assignment_expr(A) ::= conditional_expr(B). { A = B; }
561
562
563
564
565
566
567
568
569
570
571
assignment_expr(A) ::= unary_expr(B) ASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_ASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) MULASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_MULASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) DIVASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_DIVASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) MODASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_MODASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ADDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_ADDASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) SUBASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_SUBASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) LSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_LSHIFTASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) RSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_RSHIFTASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ANDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_ANDASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) XORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_XORASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_ORASSIGN, B, C); }
572
573
%type expression { Expression * }
574
%destructor expression { delete_expr(ctx, $$); }
575
expression(A) ::= assignment_expr(B). { A = B; }
576
expression(A) ::= expression(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
577
578
// end of mojoshader_parser_hlsl.lemon ...