Paradox Game Engine  v1.0.0 beta06
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Events Macros Pages
ShaderGrammar.cs
Go to the documentation of this file.
1 // Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
2 // This file is distributed under GPL v3. See LICENSE.md for details.
3 using System.Collections.Generic;
4 using System.Diagnostics.CodeAnalysis;
5 
6 using Irony.Parsing;
7 using SiliconStudio.Shaders.Ast;
8 using SiliconStudio.Shaders.Utility;
9 
10 namespace SiliconStudio.Shaders.Grammar
11 {
12  /// <summary>
13  /// Generic grammar for a shading language.
14  /// </summary>
15  /// <remarks>
16  /// This grammar provides the core grammar for a shading language including expressions (binary, unary, methods...), statements (if, for, while...).
17  /// </remarks>
18  [SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1600:ElementsMustBeDocumented", Justification = "Reviewed. Suppression is OK here.")]
19  [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1310:FieldNamesMustNotContainUnderscore", Justification = "Reviewed. Suppression is OK here.")]
20  [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1304:NonPrivateReadonlyFieldsMustBeginWithUpperCaseLetter", Justification = "Reviewed. Suppression is OK here.")]
21  public abstract partial class ShaderGrammar : Irony.Parsing.Grammar
22  {
23  // ReSharper disable InconsistentNaming
24  // ------------------------------------------------------------------------------------
25  // Comments
26  // ------------------------------------------------------------------------------------
27  public readonly Terminal single_line_comment = new Terminal("single_line_comment", Irony.Parsing.TokenCategory.Comment, TermFlags.IsNonGrammar) { AstNodeConfig = new TokenInfo(TokenCategory.Comment) };
28  public readonly Terminal multi_line_comment = new Terminal("multi_line_comment", Irony.Parsing.TokenCategory.Comment, TermFlags.IsNonGrammar) { AstNodeConfig = new TokenInfo(TokenCategory.Comment) };
29 
30  // ------------------------------------------------------------------------------------
31  // Literals
32  // ------------------------------------------------------------------------------------
33  public readonly Terminal float_literal = new Terminal("float_literal") { AstNodeConfig = new TokenInfo(TokenCategory.Number) };
34  public readonly Terminal integer_literal = new Terminal("integer_literal") { AstNodeConfig = new TokenInfo(TokenCategory.Number) };
35  public readonly NonTerminal number = TT("number");
36  public readonly Terminal identifier_raw = new Terminal("identifier") { AstNodeConfig = new TokenInfo(TokenCategory.Identifier) };
37  public readonly NonTerminal identifier = TT("identifier");
38  public readonly NonTerminal boolean = T("boolean", (context, node) => node.AstNode = bool.Parse(node.ChildNodes[0].Token.Text));
39 
40  // ------------------------------------------------------------------------------------
41  // Terminals
42  // ------------------------------------------------------------------------------------
43  public readonly Terminal unknown = new Terminal("unknown", Irony.Parsing.TokenCategory.Content);
44 
45  public readonly Terminal whitespace = new Terminal("whitespace", Irony.Parsing.TokenCategory.Content, TermFlags.IsNonGrammar) { AstNodeConfig = new TokenInfo(TokenCategory.WhiteSpace) };
46  public readonly Terminal newline = new Terminal("newline", Irony.Parsing.TokenCategory.Content, TermFlags.IsNonGrammar) { AstNodeConfig = new TokenInfo(TokenCategory.WhiteSpace)};
47  // Pseudo terminal
48  protected readonly NonTerminal semi_opt = TT("semi_opt");
49  protected readonly NonTerminal less_than = TT("less_than");
50 
51  // ------------------------------------------------------------------------------------
52  // NonTerminals
53  // ------------------------------------------------------------------------------------
54  protected readonly NonTerminal additive_expression = TT("additive_expression");
55  protected readonly NonTerminal additive_expression_raw = T("additive_expression_raw", CreateBinaryExpressionAst);
56  protected readonly NonTerminal and_expression = TT("and_expression");
57  protected readonly NonTerminal and_expression_raw = T("and_expression_raw", CreateBinaryExpressionAst);
58  protected readonly NonTerminal argument_expression_list = T("argument_expression_list", CreateListFromNode<Expression>);
59  protected readonly NonTerminal array_initializer_expression = T("array_initializer_expression", CreateArrayInitializerExpressionAst);
60  protected readonly NonTerminal assignment_expression = TT("assignment_expression");
61  protected readonly NonTerminal assignment_expression_raw = T("assignment_expression_raw", CreateAssignementExpressionAst);
62  protected readonly NonTerminal assignment_operator = T("assignment_operator", CreateAssignmentOperator);
63  protected readonly NonTerminal attribute_qualifier_pre = TT("attribute_qualifier_pre");
64  protected readonly NonTerminal block_item = TT("block_item");
65  protected readonly NonTerminal block_statement = T("block_statement", CreateBlockStatementAst);
66  protected readonly NonTerminal break_statement = T("break_statement", CreateExpressionStatementAst);
67  protected readonly NonTerminal cast_expression = TT("cast_expression");
68  protected readonly NonTerminal conditional_expression = TT("conditional_expression");
69  protected readonly NonTerminal conditional_expression_raw = T("conditional_expression_raw", CreateConditionalExpressionAst);
70  protected readonly NonTerminal constant_expression = TT("constant_expression");
71  protected readonly NonTerminal continue_statement = T("continue_statement", CreateExpressionStatementAst);
72  protected readonly NonTerminal declaration = TT("declaration");
73  protected readonly NonTerminal declaration_specifiers = T("declaration_specifiers", CreateDeclarationSpecifier);
74  protected readonly NonTerminal declaration_statement = T("declaration_statement", CreateDeclarationStatementAst);
75  protected readonly NonTerminal discard_statement = T("discard_statement", CreateExpressionStatementAst);
76  protected readonly NonTerminal do_while_statement = T("do_while_statement", CreateDoWhileStatementAst);
77  protected readonly NonTerminal empty_statement = T("empty_statement", CreateEmptyStatementAst);
78  protected readonly NonTerminal equality_expression = TT("equality_expression");
79  protected readonly NonTerminal equality_expression_raw = T("equality_expression_raw", CreateBinaryExpressionAst);
80  protected readonly NonTerminal exclusive_or_expression = TT("exclusive_or_expression");
81  protected readonly NonTerminal exclusive_or_expression_raw = T("exclusive_or_expression_raw", CreateBinaryExpressionAst);
82  protected readonly NonTerminal expression = TT("expression");
83  protected readonly NonTerminal expression_list = T("expression_list", CreateExpressionListAst);
84  protected readonly NonTerminal expression_or_empty = T("expression_or_empty", CreateExpressionOrEmptyAst);
85  protected readonly NonTerminal expression_statement = T("expression_statement", CreateExpressionStatementAst);
86  protected readonly NonTerminal for_statement = T("for_statement", CreateForStatementAst);
87  protected readonly NonTerminal field_declaration = T("field_declaration", CheckFieldDeclarationAst);
88  protected readonly NonTerminal identifier_list = T("identifier_list", CreateIdentifierListAst);
89  protected readonly NonTerminal if_statement = T("if_terminal", CreateIfStatementAst);
90  protected readonly NonTerminal inclusive_or_expression = TT("inclusive_or_expression");
91  protected readonly NonTerminal inclusive_or_expression_raw = T("inclusive_or_expression_raw", CreateBinaryExpressionAst);
92  protected readonly NonTerminal incr_or_decr = TT("incr_or_decr");
93  protected readonly NonTerminal identifier_extended = T("identifier_extended", CreateIdentifierAst);
94  protected readonly NonTerminal indexable_identifier = T("identifier_indexable", CreateIdentifierIndexableAst);
95  protected readonly NonTerminal indexable_identifier_declarator = T("indexable_identifier_declarator", CreateIdentifierIndexableAst);
96  protected readonly NonTerminal indexer_expression = T("indexer-expression", CreateIndexerExpressionAst);
97  protected readonly NonTerminal initializer = TT("initializer");
98  protected readonly NonTerminal initializer_list = T("initializer_list", CreateListFromNode<Expression>);
99  protected readonly NonTerminal iteration_statement = TT("iteration_statement");
100  protected readonly NonTerminal jump_statement = TT("jump_statement");
101  protected readonly NonTerminal literal = T("literal", CreateLiteralAst);
102  protected readonly NonTerminal literal_expression = T("literal-expression", CreateLiteralExpressionAst);
103  protected readonly NonTerminal literal_list = T("literal_list", CreateListFromNode<Literal>);
104  protected readonly NonTerminal logical_and_expression = TT("logical_and_expression");
105  protected readonly NonTerminal logical_and_expression_raw = T("logical_and_expression_raw", CreateBinaryExpressionAst);
106  protected readonly NonTerminal logical_or_expression = TT("logical_or_expression");
107  protected readonly NonTerminal logical_or_expression_raw = T("logical_or_expression_raw", CreateBinaryExpressionAst);
108  protected readonly NonTerminal matrix_type = T("matrix_type");
109  protected readonly NonTerminal matrix_type_simple = T("matrix_type_simple");
110  protected readonly NonTerminal matrix_type_list = TT("matricx_type_list");
111  protected readonly NonTerminal member_reference_expression = T("member_reference_expression", CreateMemberReferenceExpressionAst);
112  protected readonly NonTerminal method_declaration = T("method_declaration", CreateMethodDeclarationAst);
113  protected readonly NonTerminal method_declaration_raw = T("method_declaration_raw", CreateMethodDeclarationRawAst);
114  protected readonly NonTerminal method_declarator = T("method_declarator", CreateMethodDeclaratorAst);
115  protected readonly NonTerminal method_definition = T("method_definition", CreateMethodDefinitionAst);
116  protected readonly NonTerminal method_definition_or_declaration = TT("method_definition_or_declaration");
117  protected readonly NonTerminal method_invoke_expression = T("method_invoke_expression", CreateMethodInvokeExpressionAst);
118  protected readonly NonTerminal method_invoke_expression_simple = T("method_invoke_expression_simple", CreateMethodInvokeExpressionAst);
119  protected readonly NonTerminal method_qualifier_post = TT("method_qualifier_post");
120  protected readonly NonTerminal multiplicative_expression = TT("multiplicative_expression");
121  protected readonly NonTerminal multiplicative_expression_raw = T("multiplicative_expression_raw", CreateBinaryExpressionAst);
122  protected readonly NonTerminal object_type = TT("object_type");
123  protected readonly NonTerminal parameter_declaration = T("parameter_declaration");
124  protected readonly NonTerminal parameter_list = T("parameter_list", CreateListFromNode<Parameter>);
125  protected readonly NonTerminal parameter_qualifier_pre = T("parameter_qualifier_pre");
126  protected readonly NonTerminal parameter_qualifier_post = T("parameter_qualifier_post");
127  protected readonly NonTerminal parameter_type = TT("parameter_type");
128  protected readonly NonTerminal parenthesized_expression = T("parenthesized_expression", CreateParenthesizedExpressionAst);
129  protected readonly NonTerminal post_incr_decr_expression = T("post_incr_decr_expression", CreatePostfixUnaryExpressionAst);
130  protected readonly NonTerminal postfix_expression = TT("postfix_expression");
131  protected readonly NonTerminal primary_expression = TT("primary-expression");
132  protected readonly NonTerminal rank_specifier = T("rank_specifier", CreateRankSpecifierAst);
133  protected readonly NonTerminal rank_specifier_empty = T("rank_specifier_empty", CreateRankSpecifierAst);
134  protected readonly NonTerminal relational_expression = TT("relational_expression");
135  protected readonly NonTerminal relational_expression_raw = T("relational_expression_raw", CreateBinaryExpressionAst);
136  protected readonly NonTerminal return_statement = T("return_statement", CreateReturnStatementAst);
137  protected readonly NonTerminal sampler_type = T("sampler_type");
138  protected readonly NonTerminal scalars = TT("scalars");
139  protected readonly NonTerminal scalars_and_vectors = TT("scalars_and_vectors");
140  protected readonly NonTerminal scalars_or_typename = TT("scalars_or_typename");
141  protected readonly NonTerminal scope_declaration = TT("scope_declaration");
142  protected readonly NonTerminal selection_statement = TT("selection_statement");
143  protected readonly NonTerminal shader = T("shader", CreateShaderAst);
144  protected readonly NonTerminal shift_expression = TT("shift_expression");
145  protected readonly NonTerminal shift_expression_raw = T("shift_expression_raw", CreateBinaryExpressionAst);
146  protected readonly NonTerminal simple_assignment_expression_statement = T("simple_assignment_expression_statement", CreateAssignementExpressionAst);
147  protected readonly NonTerminal simple_type = TT("simple_type");
148  protected readonly NonTerminal simple_type_or_type_name = TT("simple_type_or_type_name");
149  protected readonly NonTerminal statement = T("Statement", CreateStatementAst);
150  protected readonly NonTerminal statement_raw = TT("statement_raw");
151  protected readonly NonTerminal storage_qualifier = T("storage_qualifier");
152  protected readonly NonTerminal storage_qualifier_list_opt = T("storage_qualifier_list_opt", CreateQualifiers);
153  protected readonly NonTerminal struct_specifier = T("struct_specifier", CreateStructureAst);
154  protected readonly NonTerminal switch_case_group = T("switch_case_group", CreateSwitchCastGroupAst);
155  protected readonly NonTerminal switch_case_statement = T("switch_case_statement", CreateCaseStatementAst);
156  protected readonly NonTerminal switch_statement = T("switch_statement", CreateSwitchStatementAst);
157  protected readonly NonTerminal toplevel_declaration = TT("toplevel_declaration");
158  protected readonly NonTerminal toplevel_declaration_list = T("toplevel_declaration_list", CreateListFromNode<Node>);
159  protected readonly NonTerminal type = TT("type");
160  protected readonly NonTerminal type_for_cast = TT("type_for_cast");
161  protected readonly NonTerminal type_name = T("type_name", CreateTypeNameAst);
162  protected readonly NonTerminal typename_for_cast = T("typename_for_cast", CreateTypeNameAst);
163  protected readonly NonTerminal unary_expression = TT("unary_expression");
164  protected readonly NonTerminal unary_expression_raw = T("unary_expression_raw", CreateUnaryExpressionAst);
165  protected readonly NonTerminal unary_operator = TT("unary_operator");
166  protected readonly NonTerminal value_type = TT("value-type");
167  protected readonly NonTerminal type_reference_expression = T("type_reference_expression", CreateTypeReferenceExpression);
168  protected readonly NonTerminal variable_declaration = T("variable_declaration", CreateVariableGroupAst);
169  protected readonly NonTerminal variable_declaration_raw = T("variable_declaration_raw", CreateVariableGroupRawAst);
170  protected readonly NonTerminal variable_declarator = T("variable_declarator");
171  protected readonly NonTerminal variable_declarator_raw = T("variable_declarator_raw");
172  protected readonly NonTerminal variable_declarator_qualifier_post = TT("variable_declarator_qualifier_post");
173  protected readonly NonTerminal variable_declarator_list = T("variable_declarator_list", CreateListFromNode<Variable>);
174  protected readonly NonTerminal variable_identifier = T("variable_identifier", CreateVariableReferenceExpressionAst);
175 
176  ////protected readonly NonTerminal layout_qualifier_pre = T("layout_qualifier_pre");
177  ////protected readonly NonTerminal layout_qualifier_post = T("layout_qualifier_post");
178 
179  protected readonly NonTerminal vector_type = T("vector_type");
180  protected readonly NonTerminal vector_type_list = TT("vector_type_list");
181  protected readonly NonTerminal void_type = T("void_type", (context, node) => Ast<TypeName>(node).Name = new Identifier("void") { Span = SpanConverter.Convert(node.Span) });
182  protected readonly NonTerminal while_statement = T("while_statement", CreateWhileStatementAst);
183 
184  // ReSharper restore InconsistentNaming
185 
186  internal Dictionary<TokenType, Terminal> TokenTypeToTerminals = new Dictionary<TokenType, Terminal>();
187 
188  /// <summary>
189  /// Initializes a new instance of the <see cref="ShaderGrammar"/> class.
190  /// </summary>
191  protected ShaderGrammar()
192  {
193  GrammarComments = "Shader abstract";
194 
195  // ------------------------------------------------------------------------------------
196  // Prepare mapping for GoldScanner
197  // ------------------------------------------------------------------------------------
198 
199  // Global mappings
200  Term(whitespace, TokenCategory.WhiteSpace, TokenType.Whitespace);
201  Term(newline, TokenCategory.WhiteSpace, TokenType.NewLine);
202  Term(single_line_comment, TokenCategory.Comment, TokenType.SingleLineComment);
203  Term(multi_line_comment, TokenCategory.MultilineComment, TokenType.MultiLineComment);
204 
205  // Special unknown terminal
206  Term(unknown, TokenCategory.Identifier, TokenType.Unknown);
207 
208  // Mapping for identifier, numbers
209  Term(identifier_raw, TokenCategory.Identifier, TokenType.Identifier);
210  Term(float_literal, TokenCategory.Number, TokenType.FloatingPointLiteral);
211  Term(float_literal, TokenCategory.Number, TokenType.FloatingPointLiteralExponent);
212  Term(integer_literal, TokenCategory.Number, TokenType.HexIntegerLiteral);
213  Term(integer_literal, TokenCategory.Number, TokenType.OctalIntegerLiteral);
214  Term(integer_literal, TokenCategory.Number, TokenType.StartWithNoZeroDecimalIntegerLiteral);
215  Term(integer_literal, TokenCategory.Number, TokenType.StartWithZeroDecimalIntegerLiteral);
216 
217  // Preprocessor terminals
218  Punc("\\", TokenType.LineContinuation);
219  Punc("#", TokenType.Preprocessor);
220  Punc("##", TokenType.TokenPasting);
221 
222  // Mapping for symbols, punctuation, delimiters...
223  Op("@", TokenType.Arrobas);
224  Op("!", TokenType.Not);
225  Op("!=", TokenType.NotEqual);
226  Op("&&", TokenType.And);
227  Punc("(", TokenType.LeftParen);
228  Punc(")", TokenType.RightParen);
229  Op("*", TokenType.Mul);
230  Op("*=", TokenType.MulAssign);
231  Op("+", TokenType.Plus);
232  Op("++", TokenType.PlusPlus);
233  Op("+=", TokenType.AddAssign);
234  Punc(",", TokenType.Comma);
235  Op("-", TokenType.Minus);
236  Op("--", TokenType.MinusMinus);
237  Op("-=", TokenType.SubAssign);
238  Op("/", TokenType.Div);
239  Op("/=", TokenType.DivAssign);
240  Op("%", TokenType.Mod);
241  Op("%=", TokenType.ModAssign);
242  Punc(":", TokenType.Colon);
243  Punc(";", TokenType.Semi);
244  Op("<", TokenType.LessThan);
245  Op("<=", TokenType.LessThanOrEqual);
246  Op("=", TokenType.Assign);
247  Op("==", TokenType.Equal);
248  Op(">", TokenType.GreaterThan);
249  Op(">=", TokenType.GreaterThanOrEqual);
250  Punc("?", TokenType.Question);
251  Punc("[", TokenType.LeftBracket);
252  Punc("]", TokenType.RightBracket);
253  Punc("{", TokenType.LeftCurly);
254  Op("||", TokenType.Or);
255  Punc("}", TokenType.RightCurly);
256  Punc(".", TokenType.Dot);
257  Op("~", TokenType.BitwiseNot);
258  Op("<<", TokenType.BitwiseShiftLeft);
259  Op(">>", TokenType.BitwiseShiftRight);
260  Op("&", TokenType.BitwiseAnd);
261  Op("|", TokenType.BitwiseOr);
262  Op("^", TokenType.BitwiseXor);
263  Op("<<=", TokenType.BitwiseShiftLeftAssign);
264  Op(">>=", TokenType.BitwiseShiftRightAssign);
265  Op("&=", TokenType.BitwiseAndAssign);
266  Op("|=", TokenType.BitwiseOrAssign);
267  Op("^=", TokenType.BitwiseXorAssign);
268 
269  // ------------------------------------------------------------------------------------
270  // Comments
271  // ------------------------------------------------------------------------------------
272  NonGrammarTerminals.Add(single_line_comment);
273  NonGrammarTerminals.Add(multi_line_comment);
274 
275  identifier.Rule = identifier_raw;
276  identifier_raw.AstNodeCreator = CreateIdentifierAst;
277 
278  semi_opt.Rule = Empty | PreferShiftHere() + ";";
279 
280  less_than.Rule = "<";
281 
282  // ------------------------------------------------------------------------------------
283  // Types
284  // ------------------------------------------------------------------------------------
285 
286  // Numnber rule
287  number.Rule = integer_literal | float_literal;
288  integer_literal.AstNodeCreator = CreateIntegerLiteral;
289  float_literal.AstNodeCreator = CreateFloatLiteral;
290 
291  // Boolean rule
292  boolean.Rule = Keyword("true") | Keyword("false");
293 
294  // Literal rule (no strings!)
295  literal.Rule = number | boolean;
296 
297  // Predefined scalars and vectors
298  scalars_and_vectors.Rule = vector_type_list | scalars | type_name;
299 
300  scalars_or_typename.Rule = scalars | type_name;
301 
302  // Typename
303  type_name.Rule = identifier + new IdentifierResolverHint(true);
304 
305  // Simple types
306  simple_type.Rule = scalars
307  | vector_type_list
308  | matrix_type_list;
309 
310  // Value types
311  value_type.Rule = simple_type
312  | struct_specifier;
313 
314  // Object types
315  object_type.Rule = sampler_type;
316 
317  // Void type
318  void_type.Rule = Keyword("void");
319 
320  // Main type
321  type.Rule = type_name
322  | value_type
323  | object_type
324  | void_type;
325 
326  // Parameter type doesn't have void because void can be used by a method without arguments
327  parameter_type.Rule = type_name
328  | value_type
329  | object_type;
330 
331  simple_type_or_type_name.Rule = type_name | simple_type;
332 
333 
334  // Special valuetype used for cast
335  type_reference_expression.Rule = simple_type;
336 
337  // ------------------------------------------------------------------------------------
338  // Complex type
339  // ------------------------------------------------------------------------------------
340  field_declaration.Rule = variable_declaration;
341 
342  struct_specifier.Rule = Keyword("struct") + identifier.Opt() + "{" + field_declaration.ListOpt() + "}";
343 
344  // ------------------------------------------------------------------------------------
345  // Expressions
346  // ------------------------------------------------------------------------------------
347 
348  // primary expressions
349  primary_expression.Rule = variable_identifier | literal_expression | parenthesized_expression;
350 
351  identifier_extended.Rule = identifier;
352 
353  variable_identifier.Rule = identifier_extended;
354 
355  literal_expression.Rule = literal;
356 
357  parenthesized_expression.Rule = "(" + expression + ")";
358 
359  // postfix_expression
360  postfix_expression.Rule = primary_expression
361  | indexer_expression
362  | method_invoke_expression
363  | member_reference_expression
364  | post_incr_decr_expression;
365 
366  indexer_expression.Rule = postfix_expression + rank_specifier;
367 
368  method_invoke_expression_simple.Rule = identifier + "(" + argument_expression_list.Opt() + ")";
369 
370  // Force to add value type for cast in order to support construct like x = (int(5)); <= need to disambiguate with cast (int[5])
371  method_invoke_expression.Rule = type_reference_expression + "(" + argument_expression_list.Opt() + ")"
372  | postfix_expression + "(" + argument_expression_list.Opt() + ")";
373 
374  member_reference_expression.Rule = postfix_expression + "." + identifier;
375 
376  post_incr_decr_expression.Rule = postfix_expression + incr_or_decr;
377 
378  argument_expression_list.Rule = MakePlusRule(argument_expression_list, ToTerm(","), assignment_expression);
379 
380  // unary_expression
381  unary_expression_raw.Rule = incr_or_decr + unary_expression
382  | unary_operator + cast_expression;
383 
384  unary_expression.Rule = postfix_expression
385  | unary_expression_raw;
386 
387  incr_or_decr.Rule = ToTerm("++") | "--";
388 
389  unary_operator.Rule = ToTerm("+") | "-" | "!" | "~" | "*";
390 
391  cast_expression.Rule = unary_expression;
392 
393  // multiplicative_expression
394  multiplicative_expression_raw.Rule = multiplicative_expression + "*" + cast_expression
395  | multiplicative_expression + "/" + cast_expression
396  | multiplicative_expression + "%" + cast_expression;
397 
398  multiplicative_expression.Rule = cast_expression | multiplicative_expression_raw;
399 
400  // additive_expression
401  additive_expression_raw.Rule = additive_expression + "+" + multiplicative_expression | additive_expression + "-" + multiplicative_expression;
402 
403  additive_expression.Rule = multiplicative_expression | additive_expression_raw;
404 
405  // shift_expression
406  shift_expression_raw.Rule = shift_expression + "<<" + additive_expression | shift_expression + ">>" + additive_expression;
407 
408  shift_expression.Rule = additive_expression | shift_expression_raw;
409 
410  // relational_expression
411  relational_expression_raw.Rule = relational_expression + less_than + shift_expression | relational_expression + ">" + shift_expression
412  | relational_expression + "<=" + shift_expression | relational_expression + ">=" + shift_expression;
413 
414  relational_expression.Rule = shift_expression | relational_expression_raw;
415 
416  // equality_expression
417  equality_expression_raw.Rule = equality_expression + "==" + relational_expression | equality_expression + "!=" + relational_expression;
418 
419  equality_expression.Rule = relational_expression | equality_expression_raw;
420 
421  // and_expression
422  and_expression_raw.Rule = and_expression + "&" + equality_expression;
423 
424  and_expression.Rule = equality_expression
425  | and_expression_raw;
426 
427  // exclusive
428  exclusive_or_expression_raw.Rule = exclusive_or_expression + "^" + and_expression;
429  exclusive_or_expression.Rule = and_expression
430  | exclusive_or_expression_raw;
431 
432  // inclusive
433  inclusive_or_expression_raw.Rule = inclusive_or_expression + "|" + exclusive_or_expression;
434 
435  inclusive_or_expression.Rule = exclusive_or_expression | inclusive_or_expression_raw;
436 
437  // logical and
438  logical_and_expression_raw.Rule = logical_and_expression + "&&" + inclusive_or_expression;
439 
440  logical_and_expression.Rule = inclusive_or_expression | logical_and_expression_raw;
441 
442  // logical or
443  logical_or_expression_raw.Rule = logical_or_expression + "||" + logical_and_expression;
444 
445  logical_or_expression.Rule = logical_and_expression
446  | logical_or_expression_raw;
447 
448  // conditional
449  conditional_expression.Rule = logical_or_expression
450  | conditional_expression_raw;
451 
452  conditional_expression_raw.Rule = logical_or_expression + "?" + expression + ":" + conditional_expression;
453 
454  // assignment
455  assignment_expression.Rule = conditional_expression
456  | assignment_expression_raw;
457 
458  assignment_expression_raw.Rule = unary_expression + assignment_operator + assignment_expression;
459 
460  assignment_operator.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=";
461 
462  // expression
463  expression.Rule = expression_list;
464 
465  expression_list.Rule = MakePlusRule(expression_list, ToTerm(","), assignment_expression);
466  expression_list.ErrorRule = SyntaxError + ";";
467 
468  expression_or_empty.Rule = Empty | expression;
469 
470  // rank_specifier
471  rank_specifier.Rule = "[" + expression + "]";
472  rank_specifier_empty.Rule = "[" + expression_or_empty + "]";
473 
474  simple_assignment_expression_statement.Rule = indexable_identifier + assignment_operator + expression + ";";
475 
476  indexable_identifier.Rule = identifier_extended + rank_specifier.ListOpt();
477 
478  indexable_identifier_declarator.Rule = identifier_extended + rank_specifier_empty.ListOpt();
479 
480  // constant expression - used to plug builtin verification during Ast creation
481  constant_expression.Rule = conditional_expression;
482 
483  // ------------------------------------------------------------------------------------
484  // Variable modifiers
485  // ------------------------------------------------------------------------------------
486  // storageClass = Storage_Class + Type_Modifier
487  storage_qualifier.Rule = Keyword("const") | Keyword("uniform");
488  storage_qualifier.AstNodeCreator = CreateStorageQualifier;
489 
490  storage_qualifier_list_opt.Rule = Empty | storage_qualifier.List();
491 
492  // layout_qualifier_pre.Rule = null;
493 
494  // layout_qualifier_post.Rule = null;
495 
496  variable_declarator_qualifier_post.Rule = null;
497 
498  // ------------------------------------------------------------------------------------
499  // Declarations
500  // ------------------------------------------------------------------------------------
501  declaration.Rule = variable_declaration;
502 
503  variable_declaration.Rule = attribute_qualifier_pre + variable_declaration_raw;
504 
505  variable_declaration_raw.Rule = declaration_specifiers + variable_declarator_list.Opt() + ";";
506 
507  declaration_specifiers.Rule = type
508  | storage_qualifier.List() + type;
509 
510  variable_declarator_list.Rule = MakePlusRule(variable_declarator_list, ToTerm(","), variable_declarator);
511 
512  variable_declarator_raw.Rule = indexable_identifier_declarator + variable_declarator_qualifier_post;
513  variable_declarator_raw.AstNodeCreator = CreateVariableDeclaratorRawAst;
514 
515  variable_declarator.Rule = variable_declarator_raw
516  | variable_declarator_raw + "=" + initializer;
517  variable_declarator.AstNodeCreator = CreateVariableDeclaratorAst;
518 
519  initializer.Rule = assignment_expression
520  | array_initializer_expression;
521 
522  array_initializer_expression.Rule = "{" + initializer_list + "}"
523  | "{" + initializer_list + "," + "}";
524 
525  initializer_list.Rule = MakePlusRule(initializer_list, ToTerm(","), initializer);
526 
527  // Attribute qualifier pre
528  attribute_qualifier_pre.Rule = null;
529 
530  // Method
531  method_qualifier_post.Rule = null;
532 
533  method_declaration_raw.Rule = attribute_qualifier_pre + declaration_specifiers + method_declarator + method_qualifier_post;
534 
535  method_declaration.Rule = method_declaration_raw + ";";
536 
537  var optional_block_statement_list = block_item.ListOpt();
538  method_definition.Rule = method_declaration_raw + "{" + optional_block_statement_list + "}" + semi_opt;
539 
540 
541  method_definition_or_declaration.Rule = method_declaration | method_definition;
542 
543  method_declarator.Rule = identifier + "(" + parameter_list + ")"
544  | identifier + "(" + "void" + ")"
545  | identifier + "(" + ")";
546 
547  parameter_list.Rule = MakePlusRule(parameter_list, ToTerm(","), parameter_declaration);
548 
549  // Need to be fill out woth pre qualifier
550  parameter_qualifier_pre.Rule = null;
551  parameter_qualifier_post.Rule = null;
552 
553  parameter_declaration.Rule = attribute_qualifier_pre + parameter_qualifier_pre + parameter_type + indexable_identifier.Opt() + parameter_qualifier_post; // +parameter_declaration_raw;
554  parameter_declaration.AstNodeCreator = CreateParameterAst;
555 
556  identifier_list.Rule = MakePlusRule(identifier_list, ToTerm(","), identifier);
557 
558  // ------------------------------------------------------------------------------------
559  // Statements
560  // ------------------------------------------------------------------------------------
561  statement.Rule = attribute_qualifier_pre + statement_raw;
562 
563  statement_raw.Rule = discard_statement
564  | block_statement
565  | expression_statement
566  | selection_statement
567  | iteration_statement
568  | jump_statement;
569 
570  discard_statement.Rule = Keyword("discard") + ";";
571 
572  // skip all until semicolon
573  // statement.ErrorRule = SyntaxError + ";" | SyntaxError + "}";
574 
575  block_statement.Rule = "{" + optional_block_statement_list + "}";
576 
577  // Add an error rule at optional_block_statement_list
578  optional_block_statement_list.ErrorRule = SyntaxError + ";";
579 
580  declaration_statement.Rule = declaration;
581 
582  block_item.Rule = declaration_statement
583  | statement;
584 
585  empty_statement.Rule = ";";
586 
587  expression_statement.Rule = empty_statement
588  | expression + ";";
589 
590  selection_statement.Rule = if_statement
591  | switch_statement;
592 
593  iteration_statement.Rule = while_statement
594  | do_while_statement
595  | for_statement;
596 
597  if_statement.Rule = Keyword("if") + "(" + expression + ")" + statement
598  | Keyword("if") + "(" + expression + ")" + statement + PreferShiftHere() + Keyword("else") + statement;
599 
600 
601  switch_statement.Rule = Keyword("switch") + "(" + expression + ")" + "{" + switch_case_group.ListOpt() + "}";
602 
603  switch_case_group.Rule = switch_case_statement.List() + statement.List();
604 
605  switch_case_statement.Rule = Keyword("case") + constant_expression + ":"
606  | Keyword("default") + ":";
607 
608  while_statement.Rule = Keyword("while") + "(" + expression + ")" + statement;
609 
610  do_while_statement.Rule = Keyword("do") + statement + "while" + "(" + expression + ")" + ";";
611 
612  for_statement.Rule = Keyword("for") + "(" + expression_statement + expression.Opt() + ";" + expression.Opt() + ")" + statement
613  | Keyword("for") + "(" + variable_declaration_raw + expression.Opt() + ";" + expression.Opt() + ")" + statement;
614 
615  break_statement.Rule = Keyword("break") + ";";
616  continue_statement.Rule = Keyword("continue") + ";";
617  return_statement.Rule = Keyword("return") + ";" | Keyword("return") + expression + ";";
618 
619  jump_statement.Rule = continue_statement
620  | break_statement
621  | return_statement;
622 
623  literal_list.Rule = MakePlusRule(literal_list, ToTerm(","), literal);
624 
625  // ------------------------------------------------------------------------------------
626  // Top Level
627  // ------------------------------------------------------------------------------------
628  toplevel_declaration.Rule = scope_declaration;
629 
630  scope_declaration.Rule = method_definition_or_declaration | declaration | empty_statement;
631 
632  toplevel_declaration_list.Rule = MakeStarRule(toplevel_declaration_list, null, toplevel_declaration);
633 
634  shader.Rule = toplevel_declaration_list;
635 
636  shader.ErrorRule = SyntaxError + ";";
637 
638  Root = shader;
639 
640  // ------------------------------------------------------------------------------------
641  // Preprocessor declaration
642  // ------------------------------------------------------------------------------------
643 
644  // Using a special terminal to match lines
645  //NonGrammarTerminals.Add(new PreprocessorLines());
646 
647  // ------------------------------------------------------------------------------------
648  // Globals
649  // ------------------------------------------------------------------------------------
650  // MarkReservedWords("true", "false", "do", "while", "for", "if", "then", "else", "case", "switch", "continue", "break", "return");
651 
652  Delimiters = "{}[](),:;+-*/%&|^!~<>=";
653  MarkPunctuation(";", ",", ":");
654 
655  // CR, linefeed, nextLine, LineSeparator, paragraphSeparator
656  LineTerminators = "\r\n\u2085\u2028\u2029";
657 
658  // Add extra line terminators
659  WhitespaceChars = " \t\r\n\v\u2085\u2028\u2029";
660 
661  LanguageFlags = LanguageFlags.NewLineBeforeEOF;
662  }
663  }
664 }
SiliconStudio.Shaders.Grammar.ShaderGrammar.ShaderGrammar
ShaderGrammar()
Initializes a new instance of the ShaderGrammar class.
Definition: ShaderGrammar.cs:191