Skip to content

Latest commit

 

History

History
593 lines (500 loc) · 38.7 KB

mojoshader_parser_hlsl.lemon

File metadata and controls

593 lines (500 loc) · 38.7 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.
26
27
%start_symbol shader
%token_prefix TOKEN_HLSL_
29
30
31
%extra_argument { Context *ctx }
%include {
32
33
34
#ifndef __MOJOSHADER_HLSL_COMPILER__
#error Do not compile this file directly.
#endif
38
// !!! FIXME: make this a proper fail() function.
43
// !!! FIXME: make this a proper fail() function.
44
fail(ctx, "Giving up. Parser is hopelessly lost...");
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.
78
shader ::= compilation_units(B). { assert(ctx->ast == NULL); REVERSE_LINKED_LIST(MOJOSHADER_astCompilationUnit, B); ctx->ast = (MOJOSHADER_astNode *) B; }
80
%type compilation_units { MOJOSHADER_astCompilationUnit * }
81
82
83
84
%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; } }
85
%type compilation_unit { MOJOSHADER_astCompilationUnit * }
86
%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
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
95
%type typedef { MOJOSHADER_astTypedef * }
96
97
%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); push_usertype(ctx, C->identifier, A->datatype); }
typedef(A) ::= TYPEDEF datatype(B) scalar_or_array(C). { A = new_typedef(ctx, 0, B, C); push_usertype(ctx, C->identifier, A->datatype); }
101
%type function_signature { MOJOSHADER_astFunctionSignature * }
102
103
104
105
106
107
%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; }
108
%type function_details { MOJOSHADER_astFunctionSignature * }
109
%destructor function_details { delete_function_signature(ctx, $$); }
110
111
function_details(A) ::= datatype(B) IDENTIFIER(C) LPAREN function_parameters(D) RPAREN. { A = new_function_signature(ctx, B, C.string, D); }
function_details(A) ::= VOID IDENTIFIER(B) LPAREN function_parameters(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
%type function_storageclass { MOJOSHADER_astFunctionStorageClass }
120
//function_storageclass(A) ::= target(B). { A = B; }
121
function_storageclass(A) ::= INLINE. { A = MOJOSHADER_AST_FNSTORECLS_INLINE; }
123
%type function_parameters { MOJOSHADER_astFunctionParameters * }
124
125
%destructor function_parameters { delete_function_params(ctx, $$); }
function_parameters(A) ::= VOID. { A = NULL; }
126
function_parameters(A) ::= function_parameter_list(B). { REVERSE_LINKED_LIST(MOJOSHADER_astFunctionParameters, B); A = B; }
127
function_parameters(A) ::= . { A = NULL; }
129
%type function_parameter_list { MOJOSHADER_astFunctionParameters * }
130
131
132
%destructor function_parameter_list { delete_function_params(ctx, $$); }
function_parameter_list(A) ::= function_parameter(B). { A = B; }
function_parameter_list(A) ::= function_parameter_list(B) COMMA function_parameter(C). { C->next = B; A = C; }
133
134
// !!! FIXME: this is pretty unreadable.
136
%type function_parameter { MOJOSHADER_astFunctionParameters * }
137
138
139
%destructor function_parameter { delete_function_params(ctx, $$); }
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) interpolation_mod(F) initializer(G). { A = new_function_param(ctx, B, C, D.string, E, F, G); }
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) interpolation_mod(F). { A = new_function_param(ctx, B, C, D.string, E, F, NULL); }
140
141
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E) initializer(F). { A = new_function_param(ctx, B, C, D.string, E, MOJOSHADER_AST_INTERPMOD_NONE, F); }
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) semantic(E). { A = new_function_param(ctx, B, C, D.string, E, MOJOSHADER_AST_INTERPMOD_NONE, NULL); }
142
143
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) interpolation_mod(E) initializer(F). { A = new_function_param(ctx, B, C, D.string, NULL, E, F); }
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) interpolation_mod(E). { A = new_function_param(ctx, B, C, D.string, NULL, E, NULL); }
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D) initializer(E). { A = new_function_param(ctx, B, C, D.string, NULL, MOJOSHADER_AST_INTERPMOD_NONE, E); }
function_parameter(A) ::= input_modifier(B) datatype(C) IDENTIFIER(D). { A = new_function_param(ctx, B, C, D.string, NULL, MOJOSHADER_AST_INTERPMOD_NONE, NULL); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) semantic(D) interpolation_mod(E) initializer(F). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, D, E, F); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) semantic(D) interpolation_mod(E). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, D, E, NULL); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) semantic(D) initializer(E). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, D, MOJOSHADER_AST_INTERPMOD_NONE, E); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) semantic(D). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, D, MOJOSHADER_AST_INTERPMOD_NONE, NULL); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) interpolation_mod(D) initializer(E). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, NULL, D, E); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) interpolation_mod(D). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, NULL, D, NULL); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C) initializer(D). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, NULL, MOJOSHADER_AST_INTERPMOD_NONE, D); }
function_parameter(A) ::= datatype(B) IDENTIFIER(C). { A = new_function_param(ctx, MOJOSHADER_AST_INPUTMOD_NONE, B, C.string, NULL, MOJOSHADER_AST_INTERPMOD_NONE, NULL); }
%type input_modifier { MOJOSHADER_astInputModifier }
input_modifier(A) ::= IN. { A = MOJOSHADER_AST_INPUTMOD_IN; }
input_modifier(A) ::= INOUT. { A = MOJOSHADER_AST_INPUTMOD_INOUT; }
input_modifier(A) ::= OUT. { A = MOJOSHADER_AST_INPUTMOD_OUT; }
input_modifier(A) ::= IN OUT. { A = MOJOSHADER_AST_INPUTMOD_INOUT; }
input_modifier(A) ::= OUT IN. { A = MOJOSHADER_AST_INPUTMOD_INOUT; }
input_modifier(A) ::= UNIFORM. { A = MOJOSHADER_AST_INPUTMOD_UNIFORM; }
162
163
%type semantic { const char * }
164
semantic(A) ::= COLON IDENTIFIER(B). { A = B.string; }
167
168
169
170
171
172
173
174
%type interpolation_mod { MOJOSHADER_astInterpolationModifier }
interpolation_mod(A) ::= LINEAR. { A = MOJOSHADER_AST_INTERPMOD_LINEAR; }
interpolation_mod(A) ::= CENTROID. { A = MOJOSHADER_AST_INTERPMOD_CENTROID; }
interpolation_mod(A) ::= NOINTERPOLATION. { A = MOJOSHADER_AST_INTERPMOD_NOINTERPOLATION; }
interpolation_mod(A) ::= NOPERSPECTIVE. { A = MOJOSHADER_AST_INTERPMOD_NOPERSPECTIVE; }
interpolation_mod(A) ::= SAMPLE. { A = MOJOSHADER_AST_INTERPMOD_SAMPLE; }
%type variable_declaration { MOJOSHADER_astVariableDeclaration * }
175
%destructor variable_declaration { delete_variable_declaration(ctx, $$); }
176
177
variable_declaration(A) ::= variable_attribute_list(B) datatype(C) variable_declaration_details_list(D) SEMICOLON. { REVERSE_LINKED_LIST(MOJOSHADER_astVariableDeclaration, D); A = D; A->attributes = B; A->datatype = C; }
variable_declaration(A) ::= datatype(B) variable_declaration_details_list(C) SEMICOLON. { REVERSE_LINKED_LIST(MOJOSHADER_astVariableDeclaration, C); A = C; A->datatype = B; }
178
// !!! FIXME: this expects "struct Identifier {} varname" ... that "Identifier" is wrong.
179
variable_declaration(A) ::= struct_declaration(B) variable_declaration_details_list(C) SEMICOLON. { REVERSE_LINKED_LIST(MOJOSHADER_astVariableDeclaration, C); A = C; A->anonymous_datatype = B; }
180
181
182
183
184
185
%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 }
186
187
188
189
190
191
192
193
194
195
196
variable_attribute(A) ::= EXTERN. { A = MOJOSHADER_AST_VARATTR_EXTERN; }
variable_attribute(A) ::= NOINTERPOLATION. { A = MOJOSHADER_AST_VARATTR_NOINTERPOLATION; }
variable_attribute(A) ::= SHARED. { A = MOJOSHADER_AST_VARATTR_SHARED; }
variable_attribute(A) ::= STATIC. { A = MOJOSHADER_AST_VARATTR_STATIC; }
variable_attribute(A) ::= UNIFORM. { A = MOJOSHADER_AST_VARATTR_UNIFORM; }
variable_attribute(A) ::= VOLATILE. { A = MOJOSHADER_AST_VARATTR_VOLATILE; }
variable_attribute(A) ::= CONST. { A = MOJOSHADER_AST_VARATTR_CONST; }
variable_attribute(A) ::= ROWMAJOR. { A = MOJOSHADER_AST_VARATTR_ROWMAJOR; }
variable_attribute(A) ::= COLUMNMAJOR. { A = MOJOSHADER_AST_VARATTR_COLUMNMAJOR; }
%type variable_declaration_details_list { MOJOSHADER_astVariableDeclaration * }
197
198
199
200
%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; }
201
%type variable_declaration_details { MOJOSHADER_astVariableDeclaration * }
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
%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); }
220
221
// !!! FIXME: we don't handle full sampler declarations at the moment.
223
%type struct_declaration { MOJOSHADER_astStructDeclaration * }
224
%destructor struct_declaration { delete_struct_declaration(ctx, $$); }
225
struct_declaration(A) ::= struct_intro(B) LBRACE struct_member_list(C) RBRACE. { REVERSE_LINKED_LIST(MOJOSHADER_astStructMembers, C); A = new_struct_declaration(ctx, B, C); }
226
227
228
// 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 * }
229
struct_intro(A) ::= STRUCT IDENTIFIER(B). { A = B.string; push_usertype(ctx, A, &ctx->dt_none); } // datatype is bogus until semantic analysis.
231
%type struct_member_list { MOJOSHADER_astStructMembers * }
232
233
234
235
%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; }
236
%type struct_member { MOJOSHADER_astStructMembers * }
237
%destructor struct_member { delete_struct_member(ctx, $$); }
238
struct_member(A) ::= interpolation_mod(B) struct_member_details(C). { MOJOSHADER_astStructMembers *i = C; A = C; while (i) { i->interpolation_mod = B; i = i->next; } }
239
240
struct_member(A) ::= struct_member_details(B). { A = B; }
241
%type struct_member_details { MOJOSHADER_astStructMembers * }
242
%destructor struct_member_details { delete_struct_member(ctx, $$); }
243
struct_member_details(A) ::= datatype(B) struct_member_item_list(C) SEMICOLON. { MOJOSHADER_astStructMembers *i = C; A = C; while (i) { i->datatype = B; i = i->next; } }
245
%type struct_member_item_list { MOJOSHADER_astStructMembers * }
246
247
248
249
250
%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; }
251
%type variable_lowlevel { MOJOSHADER_astVariableLowLevel * }
252
253
254
255
256
257
258
%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.
259
%type scalar_or_array { MOJOSHADER_astScalarOrArray * }
260
261
262
263
264
%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); }
265
%type packoffset { MOJOSHADER_astPackOffset * }
266
267
268
269
270
271
272
273
274
275
%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; }
276
%type annotations { MOJOSHADER_astAnnotations * }
277
%destructor annotations { delete_annotation(ctx, $$); }
278
annotations(A) ::= LT annotation_list(B) GT. { REVERSE_LINKED_LIST(MOJOSHADER_astAnnotations, B); A = B; }
280
%type annotation_list { MOJOSHADER_astAnnotations * }
281
282
283
284
285
%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?
286
%type annotation { MOJOSHADER_astAnnotations * }
287
288
289
%destructor annotation { delete_annotation(ctx, $$); }
annotation(A) ::= datatype_scalar(B) initializer(C) SEMICOLON. { A = new_annotation(ctx, B, C); }
290
%type initializer_block_list { MOJOSHADER_astExpression * }
291
292
293
%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; }
294
initializer_block_list(A) ::= initializer_block_list(B) COMMA initializer_block_list(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_COMMA, B, C); }
296
%type initializer_block { MOJOSHADER_astExpression * }
297
298
299
%destructor initializer_block { delete_expr(ctx, $$); }
initializer_block(A) ::= LBRACE initializer_block_list(B) RBRACE. { A = B; }
300
%type initializer { MOJOSHADER_astExpression * }
301
302
303
304
%destructor initializer { delete_expr(ctx, $$); }
initializer(A) ::= ASSIGN initializer_block(B). { A = B; }
initializer(A) ::= ASSIGN expression(B). { A = B; }
305
%type intrinsic_datatype { const MOJOSHADER_astDataType * }
306
307
308
309
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; }
310
intrinsic_datatype(A) ::= datatype_buffer(B). { A = B; }
312
%type datatype { const MOJOSHADER_astDataType * }
313
datatype(A) ::= intrinsic_datatype(B). { A = B; }
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
datatype(A) ::= USERTYPE(B). { A = B.datatype; }
%type datatype_sampler { const MOJOSHADER_astDataType * }
datatype_sampler(A) ::= SAMPLER. { A = &ctx->dt_sampler2d; }
datatype_sampler(A) ::= SAMPLER1D. { A = &ctx->dt_sampler1d; }
datatype_sampler(A) ::= SAMPLER2D. { A = &ctx->dt_sampler2d; }
datatype_sampler(A) ::= SAMPLER3D. { A = &ctx->dt_sampler3d; }
datatype_sampler(A) ::= SAMPLERCUBE. { A = &ctx->dt_samplercube; }
datatype_sampler(A) ::= SAMPLER_STATE. { A = &ctx->dt_samplerstate; }
datatype_sampler(A) ::= SAMPLERSTATE. { A = &ctx->dt_samplerstate; }
datatype_sampler(A) ::= SAMPLERCOMPARISONSTATE. { A = &ctx->dt_samplercompstate; }
%type datatype_scalar { const MOJOSHADER_astDataType * }
datatype_scalar(A) ::= BOOL. { A = &ctx->dt_bool; }
datatype_scalar(A) ::= INT. { A = &ctx->dt_int; }
datatype_scalar(A) ::= UINT. { A = &ctx->dt_uint; }
datatype_scalar(A) ::= HALF. { A = &ctx->dt_half; }
datatype_scalar(A) ::= FLOAT. { A = &ctx->dt_float; }
datatype_scalar(A) ::= DOUBLE. { A = &ctx->dt_double; }
datatype_scalar(A) ::= STRING. { A = &ctx->dt_string; } // this is for the effects framework, not HLSL.
datatype_scalar(A) ::= SNORM FLOAT. { A = &ctx->dt_float_snorm; }
datatype_scalar(A) ::= UNORM FLOAT. { A = &ctx->dt_float_unorm; }
%type datatype_buffer { const MOJOSHADER_astDataType * }
datatype_buffer(A) ::= BUFFER LT BOOL GT. { A = &ctx->dt_buf_bool; }
datatype_buffer(A) ::= BUFFER LT INT GT. { A = &ctx->dt_buf_int; }
datatype_buffer(A) ::= BUFFER LT UINT GT. { A = &ctx->dt_buf_uint; }
datatype_buffer(A) ::= BUFFER LT HALF GT. { A = &ctx->dt_buf_half; }
datatype_buffer(A) ::= BUFFER LT FLOAT GT. { A = &ctx->dt_buf_float; }
datatype_buffer(A) ::= BUFFER LT DOUBLE GT. { A = &ctx->dt_buf_double; }
datatype_buffer(A) ::= BUFFER LT SNORM FLOAT GT. { A = &ctx->dt_buf_float_snorm; }
datatype_buffer(A) ::= BUFFER LT UNORM FLOAT GT. { A = &ctx->dt_buf_float_unorm; }
%type datatype_vector { const MOJOSHADER_astDataType * }
datatype_vector(A) ::= VECTOR LT datatype_scalar(B) COMMA INT_CONSTANT(C) GT. { A = new_datatype_vector(ctx, B, (int) C.i64); }
%type datatype_matrix { const MOJOSHADER_astDataType * }
datatype_matrix(A) ::= MATRIX LT datatype_scalar(B) COMMA INT_CONSTANT(C) COMMA INT_CONSTANT(D) GT. { A = new_datatype_matrix(ctx, B, (int) C.i64, (int) D.i64); }
353
%type statement_block { MOJOSHADER_astStatement * }
354
%destructor statement_block { delete_statement(ctx, $$); }
355
statement_block(A) ::= LBRACE RBRACE. { A = new_block_statement(ctx, NULL); }
356
statement_block(A) ::= LBRACE statement_list(B) RBRACE. { REVERSE_LINKED_LIST(MOJOSHADER_astStatement, B); A = new_block_statement(ctx, B); }
358
%type statement_list { MOJOSHADER_astStatement * }
359
360
%destructor statement_list { delete_statement(ctx, $$); }
statement_list(A) ::= statement(B). { A = B; }
361
statement_list(A) ::= statement_list(B) statement(C). { A = C; A->next = B; }
363
// These are for Shader Model 4 and Xbox 360 only, apparently.
364
365
366
367
368
369
370
371
372
373
// !!! 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
374
%type statement { MOJOSHADER_astStatement * }
375
376
377
378
379
380
381
382
383
384
385
%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); }
386
statement(A) ::= switch_intro(B) LPAREN expression(C) RPAREN LBRACE switch_case_list(D) RBRACE. { REVERSE_LINKED_LIST(MOJOSHADER_astSwitchCases, D); A = new_switch_statement(ctx, B, C, D); }
387
388
389
390
391
392
393
394
395
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
396
%type while_intro { int }
397
398
399
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; }
400
while_intro(A) ::= WHILE. { A = -2; }
402
%type for_statement { MOJOSHADER_astStatement * }
403
%destructor for_statement { delete_statement(ctx, $$); }
404
for_statement(A) ::= for_intro(B) for_details(C). { A = C; ((MOJOSHADER_astForStatement *) A)->unroll = B; }
406
%type for_intro { int }
407
408
409
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; }
410
for_intro(A) ::= FOR. { A = -2; }
412
%type for_details { MOJOSHADER_astStatement * }
413
414
415
416
417
418
419
420
421
422
423
424
425
426
%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); }
427
%type do_intro { int }
428
429
430
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; }
432
433
%type if_intro { int }
434
435
436
437
438
439
440
if_intro(A) ::= LBRACKET BRANCH RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_BRANCH; }
if_intro(A) ::= LBRACKET FLATTEN RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_FLATTEN; }
if_intro(A) ::= LBRACKET IFALL RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_IFALL; }
if_intro(A) ::= LBRACKET IFANY RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_IFANY; }
if_intro(A) ::= LBRACKET PREDICATE RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_PREDICATE; }
if_intro(A) ::= LBRACKET PREDICATEBLOCK RBRACKET IF. { A = MOJOSHADER_AST_IFATTR_PREDICATEBLOCK; }
if_intro(A) ::= IF. { A = MOJOSHADER_AST_IFATTR_NONE; }
441
442
%type switch_intro { int }
443
444
445
446
447
switch_intro(A) ::= LBRACKET FLATTEN RBRACKET SWITCH. { A = MOJOSHADER_AST_SWITCHATTR_FLATTEN; }
switch_intro(A) ::= LBRACKET BRANCH RBRACKET SWITCH. { A = MOJOSHADER_AST_SWITCHATTR_BRANCH; }
switch_intro(A) ::= LBRACKET FORCECASE RBRACKET SWITCH. { A = MOJOSHADER_AST_SWITCHATTR_FORCECASE; }
switch_intro(A) ::= LBRACKET CALL RBRACKET SWITCH. { A = MOJOSHADER_AST_SWITCHATTR_CALL; }
switch_intro(A) ::= SWITCH. { A = MOJOSHADER_AST_SWITCHATTR_NONE; }
449
%type switch_case_list { MOJOSHADER_astSwitchCases * }
450
451
452
%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; }
453
454
455
// You can do math here, apparently, as long as it produces an int constant.
// ...so "case 3+2:" works.
456
%type switch_case { MOJOSHADER_astSwitchCases * }
457
%destructor switch_case { delete_switch_case(ctx, $$); }
458
switch_case(A) ::= CASE expression(B) COLON statement_list(C). { REVERSE_LINKED_LIST(MOJOSHADER_astStatement, C); A = new_switch_case(ctx, B, C); }
459
switch_case(A) ::= CASE expression(B) COLON. { A = new_switch_case(ctx, B, NULL); }
460
switch_case(A) ::= DEFAULT COLON statement_list(B). { REVERSE_LINKED_LIST(MOJOSHADER_astStatement, B); A = new_switch_case(ctx, NULL, B); }
461
switch_case(A) ::= DEFAULT COLON. { A = new_switch_case(ctx, NULL, NULL); }
462
463
// the expression stuff is based on Jeff Lee's ANSI C grammar.
464
%type primary_expr { MOJOSHADER_astExpression * }
465
%destructor primary_expr { delete_expr(ctx, $$); }
466
467
468
469
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); }
470
471
primary_expr(A) ::= TRUE. { A = new_literal_boolean_expr(ctx, 1); }
primary_expr(A) ::= FALSE. { A = new_literal_boolean_expr(ctx, 0); }
472
473
primary_expr(A) ::= LPAREN expression(B) RPAREN. { A = B; }
474
%type postfix_expr { MOJOSHADER_astExpression * }
475
%destructor postfix_expr { delete_expr(ctx, $$); }
476
postfix_expr(A) ::= primary_expr(B). { A = B; }
477
postfix_expr(A) ::= postfix_expr(B) LBRACKET expression(C) RBRACKET. { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_DEREF_ARRAY, B, C); }
478
postfix_expr(A) ::= IDENTIFIER(B) arguments(C). { A = new_callfunc_expr(ctx, B.string, C); }
479
postfix_expr(A) ::= datatype(B) arguments(C). { A = new_constructor_expr(ctx, B, C); } // HLSL constructor
480
postfix_expr(A) ::= postfix_expr(B) DOT IDENTIFIER(C). { A = new_deref_struct_expr(ctx, B, C.string); }
481
482
postfix_expr(A) ::= postfix_expr(B) PLUSPLUS. { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_POSTINCREMENT, B); }
postfix_expr(A) ::= postfix_expr(B) MINUSMINUS. { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_POSTDECREMENT, B); }
484
%type arguments { MOJOSHADER_astArguments * }
485
486
%destructor arguments { delete_arguments(ctx, $$); }
arguments(A) ::= LPAREN RPAREN. { A = NULL; }
487
arguments(A) ::= LPAREN argument_list(B) RPAREN. { REVERSE_LINKED_LIST(MOJOSHADER_astArguments, B); A = B; }
489
%type argument_list { MOJOSHADER_astArguments * }
490
491
492
%destructor argument_list { delete_arguments(ctx, $$); }
argument_list(A) ::= assignment_expr(B). { A = new_argument(ctx, B); }
argument_list(A) ::= argument_list(B) COMMA assignment_expr(C). { A = new_argument(ctx, C); A->next = B; }
494
%type unary_expr { MOJOSHADER_astExpression * }
495
496
%destructor unary_expr { delete_expr(ctx, $$); }
unary_expr(A) ::= postfix_expr(B). { A = B; }
497
498
unary_expr(A) ::= PLUSPLUS unary_expr(B). { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_PREINCREMENT, B); }
unary_expr(A) ::= MINUSMINUS unary_expr(B). { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_PREDECREMENT, B); }
499
unary_expr(A) ::= PLUS cast_expr(B). { A = B; } // unary "+x" is always a no-op, so throw it away here.
500
501
502
unary_expr(A) ::= MINUS cast_expr(B). { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_NEGATE, B); }
unary_expr(A) ::= COMPLEMENT cast_expr(B). { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_COMPLEMENT, B); }
unary_expr(A) ::= EXCLAMATION cast_expr(B). { A = new_unary_expr(ctx, MOJOSHADER_AST_OP_NOT, B); }
504
%type cast_expr { MOJOSHADER_astExpression * }
505
%destructor cast_expr { delete_expr(ctx, $$); }
506
cast_expr(A) ::= unary_expr(B). { A = B; }
507
cast_expr(A) ::= LPAREN datatype(B) RPAREN cast_expr(C). { A = new_cast_expr(ctx, B, C); }
509
%type multiplicative_expr { MOJOSHADER_astExpression * }
510
%destructor multiplicative_expr { delete_expr(ctx, $$); }
511
multiplicative_expr(A) ::= cast_expr(B). { A = B; }
512
513
514
multiplicative_expr(A) ::= multiplicative_expr(B) STAR cast_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_MULTIPLY, B, C); }
multiplicative_expr(A) ::= multiplicative_expr(B) SLASH cast_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_DIVIDE, B, C); }
multiplicative_expr(A) ::= multiplicative_expr(B) PERCENT cast_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_MODULO, B, C); }
516
%type additive_expr { MOJOSHADER_astExpression * }
517
%destructor additive_expr { delete_expr(ctx, $$); }
518
additive_expr(A) ::= multiplicative_expr(B). { A = B; }
519
520
additive_expr(A) ::= additive_expr(B) PLUS multiplicative_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_ADD, B, C); }
additive_expr(A) ::= additive_expr(B) MINUS multiplicative_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_SUBTRACT, B, C); }
522
%type shift_expr { MOJOSHADER_astExpression * }
523
%destructor shift_expr { delete_expr(ctx, $$); }
524
shift_expr(A) ::= additive_expr(B). { A = B; }
525
526
shift_expr(A) ::= shift_expr(B) LSHIFT additive_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LSHIFT, B, C); }
shift_expr(A) ::= shift_expr(B) RSHIFT additive_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_RSHIFT, B, C); }
528
%type relational_expr { MOJOSHADER_astExpression * }
529
%destructor relational_expr { delete_expr(ctx, $$); }
530
relational_expr(A) ::= shift_expr(B). { A = B; }
531
532
533
534
relational_expr(A) ::= relational_expr(B) LT shift_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LESSTHAN, B, C); }
relational_expr(A) ::= relational_expr(B) GT shift_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_GREATERTHAN, B, C); }
relational_expr(A) ::= relational_expr(B) LEQ shift_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LESSTHANOREQUAL, B, C); }
relational_expr(A) ::= relational_expr(B) GEQ shift_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_GREATERTHANOREQUAL, B, C); }
536
%type equality_expr { MOJOSHADER_astExpression * }
537
%destructor equality_expr { delete_expr(ctx, $$); }
538
equality_expr(A) ::= relational_expr(B). { A = B; }
539
540
equality_expr(A) ::= equality_expr(B) EQL relational_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_EQUAL, B, C); }
equality_expr(A) ::= equality_expr(B) NEQ relational_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_NOTEQUAL, B, C); }
542
%type and_expr { MOJOSHADER_astExpression * }
543
%destructor and_expr { delete_expr(ctx, $$); }
544
and_expr(A) ::= equality_expr(B). { A = B; }
545
and_expr(A) ::= and_expr(B) AND equality_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_BINARYAND, B, C); }
547
%type exclusive_or_expr { MOJOSHADER_astExpression * }
548
%destructor exclusive_or_expr { delete_expr(ctx, $$); }
549
exclusive_or_expr(A) ::= and_expr(B). { A = B; }
550
exclusive_or_expr(A) ::= exclusive_or_expr(B) XOR and_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_BINARYXOR, B, C); }
552
%type inclusive_or_expr { MOJOSHADER_astExpression * }
553
%destructor inclusive_or_expr { delete_expr(ctx, $$); }
554
inclusive_or_expr(A) ::= exclusive_or_expr(B). { A = B; }
555
inclusive_or_expr(A) ::= inclusive_or_expr(B) OR exclusive_or_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_BINARYOR, B, C); }
557
%type logical_and_expr { MOJOSHADER_astExpression * }
558
%destructor logical_and_expr { delete_expr(ctx, $$); }
559
logical_and_expr(A) ::= inclusive_or_expr(B). { A = B; }
560
logical_and_expr(A) ::= logical_and_expr(B) ANDAND inclusive_or_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LOGICALAND, B, C); }
562
%type logical_or_expr { MOJOSHADER_astExpression * }
563
%destructor logical_or_expr { delete_expr(ctx, $$); }
564
logical_or_expr(A) ::= logical_and_expr(B). { A = B; }
565
logical_or_expr(A) ::= logical_or_expr(B) OROR logical_and_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LOGICALOR, B, C); }
567
%type conditional_expr { MOJOSHADER_astExpression * }
568
%destructor conditional_expr { delete_expr(ctx, $$); }
569
conditional_expr(A) ::= logical_or_expr(B). { A = B; }
570
conditional_expr(A) ::= logical_or_expr(B) QUESTION logical_or_expr(C) COLON conditional_expr(D). { A = new_ternary_expr(ctx, MOJOSHADER_AST_OP_CONDITIONAL, B, C, D); }
572
%type assignment_expr { MOJOSHADER_astExpression * }
573
%destructor assignment_expr { delete_expr(ctx, $$); }
574
assignment_expr(A) ::= conditional_expr(B). { A = B; }
575
576
577
578
579
580
581
582
583
584
585
586
587
assignment_expr(A) ::= unary_expr(B) ASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_ASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) MULASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_MULASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) DIVASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_DIVASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) MODASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_MODASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ADDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_ADDASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) SUBASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_SUBASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) LSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_LSHIFTASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) RSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_RSHIFTASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ANDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_ANDASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) XORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_XORASSIGN, B, C); }
assignment_expr(A) ::= unary_expr(B) ORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_ORASSIGN, B, C); }
%type expression { MOJOSHADER_astExpression * }
588
%destructor expression { delete_expr(ctx, $$); }
589
expression(A) ::= assignment_expr(B). { A = B; }
590
expression(A) ::= expression(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, MOJOSHADER_AST_OP_COMMA, B, C); }
591
592
// end of mojoshader_parser_hlsl.lemon ...