private static void CreateStreamsType(ParsingContext context, ParseTreeNode parseNode)
{
var nextNode = parseNode;
while (nextNode.Token == null)
{
nextNode = nextNode.ChildNodes[0];
}
var value = StreamsType.Parse(nextNode.Token.Text);
parseNode.AstNode = value;
}
/// <summary>
/// Initializes a new instance of the <see cref="ParadoxGrammar"/> class.
/// </summary>
public ParadoxGrammar()
{
SnippetRoots.Add(expression);
semantic_type.Rule = Keyword("Semantic");
type.Rule |= semantic_type;
link_type.Rule = Keyword("LinkType");
type.Rule |= link_type;
member_name.Rule = Keyword("MemberName");
type.Rule |= member_name;
var_type.Rule = Keyword("var");
object_type.Rule |= var_type;
// Add all Streams types
streams_type.Rule = CreateRuleFromObjectTypes(StreamsType.GetStreams());
object_type.Rule |= streams_type;
identifier_extended.Rule |= Keyword("stage");
// Allow simple types within generics (numbers, etc...)
//type_name.Rule = identifier_or_generic + new IdentifierResolverHint(true);
type_name.Rule = identifier_or_generic;
identifier_sub_generic.Rule |= number;
//identifier_sub_generic.Rule |= boolean;
identifier_sub_generic.Rule |= identifier_dot;
identifier_sub_generic.Rule |= simple_type;
// Foreach statement
foreach_statement.Rule = Keyword("foreach") + "(" + type + identifier + Keyword("in") + expression + ")" + statement;
iteration_statement.Rule |= foreach_statement;
// Add inheritance qualifiers
storage_qualifier.Rule |= Keyword("override") | Keyword("abstract") | Keyword("stream") | Keyword("patchstream") | Keyword("stage") | Keyword("clone") | Keyword("compose") | Keyword("internal");
// override Hlsl class
class_specifier.AstNodeCreator = CreateShaderClassSpecifierAst;
class_base_type.AstNodeCreator = CreateShaderClassBaseTypeAst;
class_base_type_list.AstNodeCreator = CreateListFromNode <ShaderTypeName>;
class_base_type_list.Rule = MakePlusRule(class_base_type_list, ToTerm(","), class_type);
class_type.Rule = identifier_or_generic;
variable_identifier.Rule |= identifier_generic;
// Allow generic identifier on member expressions
member_reference_expression.Rule = postfix_expression + "." + identifier_or_generic;
// ---------------------------------------------------
// New Mixin System
// ---------------------------------------------------
params_block.Rule = attribute_qualifier_pre + Keyword("params") + identifier_raw + block_statement;
shader_block.Rule = attribute_qualifier_pre + Keyword("partial").Opt() + Keyword("shader") + identifier_raw + block_statement;
using_params_statement.Rule = Keyword("using") + Keyword("params") + expression + ";"
| Keyword("using") + Keyword("params") + expression + block_statement;
using_statement.Rule = Keyword("using") + identifier_or_dot + ";";
foreach_params_statement.Rule = Keyword("foreach") + "(" + Keyword("params") + conditional_expression + ")" + statement;
iteration_statement.Rule |= foreach_params_statement;
mixin_statement.Rule = Keyword("mixin") + Keyword("compose") + expression + ";"
| Keyword("mixin") + Keyword("remove") + expression + ";"
| Keyword("mixin") + Keyword("macro") + expression + ";"
| Keyword("mixin") + Keyword("child") + expression + ";"
| Keyword("mixin") + Keyword("clone") + ";"
| Keyword("mixin") + expression + ";";
enum_item.Rule = identifier_raw + "=" + conditional_expression
| identifier_raw;
enum_item_list.Rule = MakeStarRule(enum_item_list, ToTerm(","), enum_item);
enum_block.Rule = attribute_qualifier_pre + Keyword("enum") + identifier_raw + "{" + enum_item_list + "}";
statement_raw.Rule |= mixin_statement | using_statement | using_params_statement;
toplevel_declaration_block.Rule = "{" + toplevel_declaration_list + "}";
namespace_block.Rule = Keyword("namespace") + identifier_or_dot + toplevel_declaration_block;
toplevel_declaration.Rule |= params_block | shader_block | enum_block | namespace_block | using_statement;
// override class specifier
class_specifier.Rule = Keyword("class") + class_identifier_or_generic + class_base_type + "{" + scope_declaration.ListOpt() + "}";
class_identifier_or_generic.Rule = identifier + new IdentifierResolverHint(true)
| class_identifier_generic + this.ReduceHere();
class_identifier_generic.Rule = identifier + new GenericResolverHint(_skipTokensInPreview) + "<" + class_identifier_generic_parameter_list + ">";
class_identifier_generic_parameter_list.Rule = MakePlusRule(class_identifier_generic_parameter_list, ToTerm(","), class_identifier_sub_generic);
class_identifier_sub_generic.Rule = type + identifier;
class_identifier_sub_generic.AstNodeCreator = CreateClassIdentifierSubGenericAst;
}
