/
mojoshader_parser_hlsl.lemon
580 lines (489 loc) · 36.1 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
%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, $$); }
87
//compilation_unit(A) ::= PRAGMA . { A = NULL; } // !!! FIXME: deal with pragmas.
88
89
90
91
92
93
94
95
96
97
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?
98
99
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); }
100
101
102
103
104
105
106
107
108
109
110
111
%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); }
112
113
114
115
116
117
118
// !!! 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.
119
120
121
122
123
124
125
%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; }
126
function_arguments(A) ::= function_argument_list(B). { REVERSE_LINKED_LIST(FunctionArguments, B); A = B; }
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
162
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 * }
163
semantic(A) ::= COLON IDENTIFIER(B). { A = B.string; }
164
165
// DX10 only?
166
167
168
169
170
171
172
173
174
%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, $$); }
175
176
177
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; }
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
216
%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); }
217
218
219
// !!! FIXME: we don't handle full sampler declarations at the moment.
220
221
222
%type struct_declaration { StructDeclaration * }
%destructor struct_declaration { delete_struct_declaration(ctx, $$); }
223
struct_declaration(A) ::= struct_intro(B) LBRACE struct_member_list(C) RBRACE. { REVERSE_LINKED_LIST(StructMembers, C); A = new_struct_declaration(ctx, B, C); }
224
225
226
227
// 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); }
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
275
%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, $$); }
276
annotations(A) ::= LT annotation_list(B) GT. { REVERSE_LINKED_LIST(Annotations, B); A = B; }
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
%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; }
292
initializer_block_list(A) ::= initializer_block_list(B) COMMA initializer_block_list(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
%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 * }
314
315
316
317
318
319
320
321
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"); }
322
323
%type datatype_scalar { const char * }
324
325
326
327
328
329
330
331
332
333
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); }
334
335
336
337
338
339
// !!! 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?
340
%type datatype_vector { const char * }
341
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); }
342
343
%type datatype_matrix { const char * }
344
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); }
345
346
347
348
%type statement_block { Statement * }
%destructor statement_block { delete_statement(ctx, $$); }
statement_block(A) ::= LBRACE RBRACE. { A = new_empty_statement(ctx); }
349
statement_block(A) ::= LBRACE statement_list(B) RBRACE. { REVERSE_LINKED_LIST(Statement, B); A = B; }
350
351
352
353
%type statement_list { Statement * }
%destructor statement_list { delete_statement(ctx, $$); }
statement_list(A) ::= statement(B). { A = B; }
354
statement_list(A) ::= statement_list(B) statement(C). { A = C; A->next = B; }
355
356
// These are for Shader Model 4 and Xbox 360 only, apparently.
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
// !!! 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); }
379
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); }
380
381
382
383
384
385
386
387
388
389
390
391
392
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; }
393
while_intro(A) ::= WHILE. { A = -2; }
394
395
396
397
398
399
400
401
402
%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; }
403
for_intro(A) ::= FOR. { A = -2; }
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
%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; }
424
do_intro(A) ::= DO. { A = -2; }
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
%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; }
446
447
448
// You can do math here, apparently, as long as it produces an int constant.
// ...so "case 3+2:" works.
449
450
%type switch_case { SwitchCases * }
%destructor switch_case { delete_switch_case(ctx, $$); }
451
switch_case(A) ::= CASE expression(B) COLON statement_list(C). { REVERSE_LINKED_LIST(Statement, C); A = new_switch_case(ctx, B, C); }
452
switch_case(A) ::= CASE expression(B) COLON. { A = new_switch_case(ctx, B, NULL); }
453
switch_case(A) ::= DEFAULT COLON statement_list(B). { REVERSE_LINKED_LIST(Statement, B); A = new_switch_case(ctx, NULL, B); }
454
switch_case(A) ::= DEFAULT COLON. { A = new_switch_case(ctx, NULL, NULL); }
455
456
// the expression stuff is based on Jeff Lee's ANSI C grammar.
457
%type primary_expr { Expression * }
458
%destructor primary_expr { delete_expr(ctx, $$); }
459
460
461
462
463
464
465
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 * }
466
%destructor postfix_expr { delete_expr(ctx, $$); }
467
postfix_expr(A) ::= primary_expr(B). { A = B; }
468
469
470
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); }
471
postfix_expr(A) ::= datatype(B) LPAREN argument_expr_list(C) RPAREN. { A = NULL; new_constructor_expr(ctx, B, C); } // HLSL constructor
472
473
474
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); }
475
476
%type argument_expr_list { Expression * }
477
%destructor argument_expr_list { delete_expr(ctx, $$); }
478
argument_expr_list(A) ::= assignment_expr(B). { A = B; }
479
argument_expr_list(A) ::= argument_expr_list(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
480
481
%type unary_expr { Expression * }
482
483
%destructor unary_expr { delete_expr(ctx, $$); }
unary_expr(A) ::= postfix_expr(B). { A = B; }
484
485
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); }
486
unary_expr(A) ::= PLUS cast_expr(B). { A = B; } // unary "+x" is always a no-op, so throw it away here.
487
488
489
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); }
490
491
%type cast_expr { Expression * }
492
%destructor cast_expr { delete_expr(ctx, $$); }
493
cast_expr(A) ::= unary_expr(B). { A = B; }
494
cast_expr(A) ::= LPAREN datatype(B) RPAREN cast_expr(C). { A = new_cast_expr(ctx, B, C); }
495
496
%type multiplicative_expr { Expression * }
497
%destructor multiplicative_expr { delete_expr(ctx, $$); }
498
multiplicative_expr(A) ::= cast_expr(B). { A = B; }
499
500
501
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); }
502
503
%type additive_expr { Expression * }
504
%destructor additive_expr { delete_expr(ctx, $$); }
505
additive_expr(A) ::= multiplicative_expr(B). { A = B; }
506
507
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); }
508
509
%type shift_expr { Expression * }
510
%destructor shift_expr { delete_expr(ctx, $$); }
511
shift_expr(A) ::= additive_expr(B). { A = B; }
512
513
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); }
514
515
%type relational_expr { Expression * }
516
%destructor relational_expr { delete_expr(ctx, $$); }
517
relational_expr(A) ::= shift_expr(B). { A = B; }
518
519
520
521
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); }
522
523
%type equality_expr { Expression * }
524
%destructor equality_expr { delete_expr(ctx, $$); }
525
equality_expr(A) ::= relational_expr(B). { A = B; }
526
527
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); }
528
529
%type and_expr { Expression * }
530
%destructor and_expr { delete_expr(ctx, $$); }
531
and_expr(A) ::= equality_expr(B). { A = B; }
532
and_expr(A) ::= and_expr(B) AND equality_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYAND, B, C); }
533
534
%type exclusive_or_expr { Expression * }
535
%destructor exclusive_or_expr { delete_expr(ctx, $$); }
536
exclusive_or_expr(A) ::= and_expr(B). { A = B; }
537
exclusive_or_expr(A) ::= exclusive_or_expr(B) XOR and_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYXOR, B, C); }
538
539
%type inclusive_or_expr { Expression * }
540
%destructor inclusive_or_expr { delete_expr(ctx, $$); }
541
inclusive_or_expr(A) ::= exclusive_or_expr(B). { A = B; }
542
inclusive_or_expr(A) ::= inclusive_or_expr(B) OR exclusive_or_expr(C). { A = new_binary_expr(ctx, AST_OP_BINARYOR, B, C); }
543
544
%type logical_and_expr { Expression * }
545
%destructor logical_and_expr { delete_expr(ctx, $$); }
546
logical_and_expr(A) ::= inclusive_or_expr(B). { A = B; }
547
logical_and_expr(A) ::= logical_and_expr(B) ANDAND inclusive_or_expr(C). { A = new_binary_expr(ctx, AST_OP_LOGICALAND, B, C); }
548
549
%type logical_or_expr { Expression * }
550
%destructor logical_or_expr { delete_expr(ctx, $$); }
551
logical_or_expr(A) ::= logical_and_expr(B). { A = B; }
552
logical_or_expr(A) ::= logical_or_expr(B) OROR logical_and_expr(C). { A = new_binary_expr(ctx, AST_OP_LOGICALOR, B, C); }
553
554
%type conditional_expr { Expression * }
555
%destructor conditional_expr { delete_expr(ctx, $$); }
556
conditional_expr(A) ::= logical_or_expr(B). { A = B; }
557
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); }
558
559
%type assignment_expr { Expression * }
560
%destructor assignment_expr { delete_expr(ctx, $$); }
561
assignment_expr(A) ::= conditional_expr(B). { A = B; }
562
563
564
565
566
567
568
569
570
571
572
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); }
573
574
%type expression { Expression * }
575
%destructor expression { delete_expr(ctx, $$); }
576
expression(A) ::= assignment_expr(B). { A = B; }
577
expression(A) ::= expression(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, AST_OP_COMMA, B, C); }
578
579
// end of mojoshader_parser_hlsl.lemon ...