public Calculadora() : base(caseSensitive: true) { var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var division = ToTerm("/"); var potencia = ToTerm("^"); /*---no terminal----*/ var INICIO = new NonTerminal("INICIO"); var EXPRE = new NonTerminal("EXPRE"); /*------------numero----*/ NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero"); this.Root = INICIO; INICIO.Rule = EXPRE; EXPRE.Rule = EXPRE + mas + EXPRE | EXPRE + menos + EXPRE | EXPRE + por + EXPRE | EXPRE + division + EXPRE | EXPRE + potencia + EXPRE | numero; this.RegisterOperators(1, Associativity.Left, mas, menos); this.RegisterOperators(2, Associativity.Left, por, division); this.RegisterOperators(2, Associativity.Left, potencia); }
public ASLGrammar() : base(true) { var string_lit = TerminalFactory.CreateCSharpString("string"); var number = TerminalFactory.CreateCSharpNumber("number"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var code = new CustomTerminal("code", MatchCodeTerminal); var single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(single_line_comment); NonGrammarTerminals.Add(delimited_comment); var state = new KeyTerm("state", "state"); var init = new KeyTerm("init", "init"); var exit = new KeyTerm("exit", "exit"); var update = new KeyTerm("update", "update"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var startup = new KeyTerm("startup", "startup"); var shutdown = new KeyTerm("shutdown", "shutdown"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var state_def = new NonTerminal("stateDef"); var version = new NonTerminal("version"); var state_list = new NonTerminal("stateList"); var method_list = new NonTerminal("methodList"); var var_list = new NonTerminal("varList"); var var = new NonTerminal("var"); var module = new NonTerminal("module"); var method = new NonTerminal("method"); var offset_list = new NonTerminal("offsetList"); var offset = new NonTerminal("offset"); var method_type = new NonTerminal("methodType"); root.Rule = state_list + method_list; version.Rule = (comma + string_lit) | Empty; state_def.Rule = state + "(" + string_lit + version + ")" + "{" + var_list + "}"; state_list.Rule = MakeStarRule(state_list, state_def); method_list.Rule = MakeStarRule(method_list, method); var_list.Rule = MakeStarRule(var_list, semi, var); module.Rule = (string_lit + comma) | Empty; var.Rule = (identifier + identifier + ":" + module + offset_list) | Empty; method.Rule = (method_type + "{" + code + "}") | Empty; offset_list.Rule = MakePlusRule(offset_list, comma, offset); offset.Rule = number; method_type.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown; Root = root; MarkTransient(var_list, method_list, offset, method_type); LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public ExpressionEvaluatorGrammar() : base(false) { //false means case insensitive //Non-Terminal Node var program = new NonTerminal("program", typeof(ProgramNode)); var expression = new NonTerminal("expression", typeof(ExpressionNode)); var binaryOperator = new NonTerminal("binaryOperator", typeof(BinaryOperatorNode)); //Identifier for Number and Variable var number = TerminalFactory.CreateCSharpNumber("number"); number.AstConfig.NodeType = typeof(MyNumber); var Id = new NonTerminal("Id"); var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple"); Id.AstConfig.NodeType = typeof(MyVariable); var stringLiteral = new StringLiteral("string", "\'", StringOptions.None); Id.Rule = MakePlusRule(Id, Id_simple); this.Root = program; //Expression program.Rule = expression; expression.Rule = number | Id | stringLiteral | expression + binaryOperator + expression | "(" + expression + ")"; binaryOperator.Rule = ToTerm("+") | "-" | "*" | "/" | "%" //arithmetic | "&" | "|" | "^" //bit | "=" | ">" | "<" | ">=" | "<=" | "<>" | "!=" | "!<" | "!>" // comparator | "AND" | "OR" | "CONTAINS" | ToTerm("NOT") + "CONTAINS" | ToTerm("NOT"); //others //Operators precedence RegisterOperators(10, "*", "/", "%"); RegisterOperators(9, "+", "-"); RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "!=", "!<", "!>"); RegisterOperators(7, "^", "&", "|"); RegisterOperators(6, "NOT"); RegisterOperators(5, "AND"); RegisterOperators(4, "OR", "CONTAINS"); this.LanguageFlags = LanguageFlags.CreateAst; this.MarkPunctuation("(", ")"); }
public VASLGrammar() : base(true) { var code = new CustomTerminal("code", MatchCodeTerminal); var stringLit = TerminalFactory.CreateCSharpString("string"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var number = TerminalFactory.CreateCSharpNumber("number"); number.Options |= NumberOptions.AllowSign; var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); // Todo: Aliases var init = new KeyTerm("init", "init"); var exit = new KeyTerm("exit", "exit"); var update = new KeyTerm("update", "update"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var startup = new KeyTerm("startup", "startup"); var shutdown = new KeyTerm("shutdown", "shutdown"); var undoSplit = new KeyTerm("undoSplit", "undoSplit"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var version = new NonTerminal("version"); var methodList = new NonTerminal("methodList"); var varList = new NonTerminal("varList"); var var = new NonTerminal("var"); var method = new NonTerminal("method"); var methodType = new NonTerminal("methodType"); root.Rule = methodList; version.Rule = (comma + stringLit) | Empty; methodList.Rule = MakeStarRule(methodList, method); varList.Rule = MakeStarRule(varList, semi, var); method.Rule = (methodType + "{" + code + "}") | Empty; methodType.Rule = init | exit | update | start | split | isLoading | gameTime | reset | startup | shutdown | undoSplit; Root = root; MarkTransient(varList, methodList, methodType); LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public ASLGrammar() : base(true) { var stringLit = TerminalFactory.CreateCSharpString("string"); var number = TerminalFactory.CreateCSharpNumber("number"); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var code = new CustomTerminal("code", MatchCodeTerminal); var singleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); var delimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); var state = new KeyTerm("state", "state"); var start = new KeyTerm("start", "start"); var split = new KeyTerm("split", "split"); var reset = new KeyTerm("reset", "reset"); var isLoading = new KeyTerm("isLoading", "isLoading"); var gameTime = new KeyTerm("gameTime", "gameTime"); var comma = ToTerm(",", "comma"); var semi = ToTerm(";", "semi"); var root = new NonTerminal("root"); var stateDef = new NonTerminal("stateDef"); var methodList = new NonTerminal("methodList"); var varList = new NonTerminal("varList"); var var = new NonTerminal("var"); var method = new NonTerminal("method"); var offsetList = new NonTerminal("offsetList"); var offset = new NonTerminal("offset"); var methodType = new NonTerminal("methodType"); root.Rule = stateDef + methodList; stateDef.Rule = state + "(" + stringLit + ")" + "{" + varList + "}"; methodList.Rule = MakeStarRule(methodList, method); varList.Rule = MakeStarRule(varList, semi, var); var.Rule = (identifier + identifier + ":" + stringLit + comma + offsetList) | Empty; method.Rule = (methodType + "{" + code + "}") | Empty; offsetList.Rule = MakePlusRule(offsetList, comma, offset); offset.Rule = number; methodType.Rule = start | split | isLoading | gameTime | reset; this.Root = root; MarkTransient(varList, methodList, offset, methodType); this.LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
//Examples: //GAPoT biversor using terms form: // -1.3<>, 1.2<1,2>, -4.6<3,4> public GaPoTNumBiversorConstructorGrammar() : base(caseSensitive: true) { // 1. Terminals var number = TerminalFactory.CreateCSharpNumber("number"); number.Options = NumberOptions.AllowSign; var comma1 = ToTerm(","); // 2. Non-terminals var biversor = new NonTerminal("biversor"); var biversorTerm = new NonTerminal("biversorTerm"); var biversorTerm0 = new NonTerminal("biversorTerm0"); var biversorTerm2 = new NonTerminal("biversorTerm2"); biversorTerm0.Rule = number + "<" + ">"; biversorTerm2.Rule = number + "<" + number + comma1 + number + ">"; biversorTerm.Rule = biversorTerm0 | biversorTerm2; biversor.Rule = MakePlusRule(biversor, comma1, biversorTerm); // Set grammar root Root = biversor; // 5. Punctuation and transient terms MarkPunctuation("<", ">", ","); RegisterBracePair("<", ">"); MarkTransient(biversorTerm); // 7. Syntax error reporting AddToNoReportGroup("<"); AddToNoReportGroup(NewLine); //9. Language flags. // Automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source LanguageFlags = LanguageFlags.NewLineBeforeEOF; }
public SparkGrammar() : base(true) { var program = new NonTerminal("Program"); var statement = new NonTerminal("Statement"); var assignStmt = new NonTerminal("AssignStatement"); var commandStmt = new NonTerminal("CommandStatement"); var assignRHS = new NonTerminal("AssignRHS"); var createLayer = new NonTerminal("CreateLayer"); var createNetwork = new NonTerminal("CreateNetwork"); var createTrainer = new NonTerminal("CreateTrainer"); var runNetwork = new NonTerminal("RunNetwork"); var loadFile = new NonTerminal("LoadFile"); var convertData = new NonTerminal("ConvertData"); var findError = new NonTerminal("FindError"); var basicNetwork = new NonTerminal("BasicNetwork"); var advancedNetwork = new NonTerminal("AdvancedNetwork"); var matrixLoadType = new NonTerminal("MatrixLoadType"); var convertToVector = new NonTerminal("ConvertToVector"); var convertToIndices = new NonTerminal("ConvertToIndices"); var supportedFileTypes = new NonTerminal("SupportedFileTypes"); var printStatement = new NonTerminal("PrintStatement"); var trainStatement = new NonTerminal("TrainStatement"); var saveStatement = new NonTerminal("SaveStatement"); var kvPair = new NonTerminal("KeyValuePair"); var identifier = TerminalFactory.CreateCSharpIdentifier("Identifier"); var number = TerminalFactory.CreateCSharpNumber("Number"); var str = TerminalFactory.CreateCSharpString("string"); program.Rule = statement + ";" | statement + ";" + program; statement.Rule = assignStmt | commandStmt; assignStmt.Rule = identifier + "=" + assignRHS; assignRHS.Rule = createLayer | createNetwork | createTrainer | runNetwork | loadFile | convertData | findError; createLayer.Rule = ToTerm("layer") + "with" + kvPair; createNetwork.Rule = basicNetwork | advancedNetwork; basicNetwork.Rule = identifier + "->" + identifier; advancedNetwork.Rule = createNetwork + "->" + identifier; runNetwork.Rule = ToTerm("run") + identifier + "on" + identifier; loadFile.Rule = ToTerm("load") + str + "as" + matrixLoadType | ToTerm("load") + supportedFileTypes + str + "as" + matrixLoadType; matrixLoadType.Rule = ToTerm("row") + "major" | ToTerm("row") + "major" + "with" + "headers" | ToTerm("column") + "major"; createTrainer.Rule = ToTerm("trainer") + "of" + "type" + identifier + "with" + kvPair; kvPair.Rule = identifier + "=" + (number | identifier) | identifier + "=" + (number | identifier) + "," + kvPair; convertData.Rule = convertToVector | convertToIndices; convertToVector.Rule = ToTerm("convert") + identifier + "to" + "class" + "vector" | ToTerm("convert") + identifier + "to" + "class" + "vector" + "of" + "size" + "=" + number; convertToIndices.Rule = ToTerm("convert") + identifier + "to" + "class" + "indices"; findError.Rule = ToTerm("count") + "mismatches" + "between" + identifier + "and" + identifier | ToTerm("get") + "mismatches" + "between" + identifier + "and" + identifier; commandStmt.Rule = printStatement | trainStatement | saveStatement; printStatement.Rule = ToTerm("print") + identifier; trainStatement.Rule = ToTerm("train") + identifier + "with" + identifier + "on" + "inputs" + identifier + "and" + "targets" + identifier; saveStatement.Rule = ToTerm("save") + identifier + "to" + str | ToTerm("save") + identifier + "as" + supportedFileTypes + "to" + str; supportedFileTypes.Rule = ToTerm("csv") | "tsv" | "ssv"; MarkPunctuation("layer", "run", "train", "trainer", "on", "and", "inputs", "targets", "major", "load", "save", "print", "type", "indices", "convert", "class", "vector", "of", "mismatches", "between", "size", "as", "to", "with", "of", "as", ";", ",", "=", "->"); this.Root = program; }
public JavaStubGrammar() { CommentTerminal single_line_comment = new CommentTerminal("SingleLineComment", "//", "\r", "\n"); CommentTerminal delimited_comment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(single_line_comment); NonGrammarTerminals.Add(delimited_comment); IdentifierTerminal identifier = new IdentifierTerminal("identifier"); KeyTerm keyword_package = Keyword("package"); KeyTerm keyword_import = Keyword("import"); KeyTerm keyword_public = Keyword("public"); KeyTerm keyword_protected = Keyword("protected"); KeyTerm keyword_static = Keyword("static"); KeyTerm keyword_final = Keyword("final"); KeyTerm keyword_abstract = Keyword("abstract"); KeyTerm keyword_synchronized = Keyword("synchronized"); KeyTerm keyword_default = Keyword("default"); KeyTerm keyword_native = Keyword("native"); KeyTerm keyword_volatile = Keyword("volatile"); KeyTerm keyword_transient = Keyword("transient"); KeyTerm keyword_enum = Keyword("enum"); KeyTerm keyword_class = Keyword("class"); KeyTerm keyword_interface = Keyword("interface"); KeyTerm keyword_at_interface = Keyword("@interface"); KeyTerm keyword_extends = Keyword("extends"); KeyTerm keyword_implements = Keyword("implements"); KeyTerm keyword_throw = Keyword("throw"); KeyTerm keyword_throws = Keyword("throws"); KeyTerm keyword_null = Keyword("null"); KeyTerm keyword_super = Keyword("super"); KeyTerm keyword_true = Keyword("true"); KeyTerm keyword_false = Keyword("false"); KeyTerm keyword_new = Keyword("new"); var compile_unit = DefaultNonTerminal("compile_unit"); var opt_package_decl = DefaultNonTerminal("opt_package_declaration"); var package_decl = DefaultNonTerminal("package_declaration"); var imports = DefaultNonTerminal("imports"); var import = DefaultNonTerminal("import"); var type_decls = DefaultNonTerminal("type_decls"); var type_decl = DefaultNonTerminal("type_decl"); var enum_decl = DefaultNonTerminal("enum_decl"); var enum_body = DefaultNonTerminal("enum_body"); var class_decl = DefaultNonTerminal("class_decl"); var opt_generic_arg_decl = DefaultNonTerminal("opt_generic_arg_decl"); var opt_extends_decl = DefaultNonTerminal("opt_extends_decl"); var opt_implements_decl = DefaultNonTerminal("opt_implements_decl"); var implements_decl = DefaultNonTerminal("implements_decl"); var interface_decl = DefaultNonTerminal("interface_decl"); var iface_or_at_iface = DefaultNonTerminal("iface_or_at_iface"); var type_body = DefaultNonTerminal("type_body"); var type_members = DefaultNonTerminal("type_members"); var type_member = DefaultNonTerminal("type_member"); var nested_type_decl = DefaultNonTerminal("nested_type_decl"); var ctor_decl = DefaultNonTerminal("ctor_decl"); var method_decl = DefaultNonTerminal("method_decl"); var field_decl = DefaultNonTerminal("field_decl"); var opt_field_assignment = DefaultNonTerminal("opt_field_assignment"); var static_ctor_decl = DefaultNonTerminal("static_ctor_decl"); var enum_members_decl = DefaultNonTerminal("enum_members_decl"); var enum_member_initializers = DefaultNonTerminal("enum_member_initializers"); var enum_member_initializer = DefaultNonTerminal("enum_member_initializer"); var opt_enum_braces = DefaultNonTerminal("opt_enum_braces"); var opt_final_field_assign = DefaultNonTerminal("opt_final_field_assign"); var final_field_assign = DefaultNonTerminal("final_field_assign"); var terminate_decl_or_body = DefaultNonTerminal("terminate_decl_or_body"); var assignments = DefaultNonTerminal("assignments"); var assignment = DefaultNonTerminal("assignment"); var assign_expr = DefaultNonTerminal("assign_expr"); var rvalue_expressions = DefaultNonTerminal("rvalue_expressions"); var rvalue_expression = DefaultNonTerminal("rvalue_expression"); var array_literal = DefaultNonTerminal("array_literal"); var annotations = DefaultNonTerminal("annotations"); var annotation = DefaultNonTerminal("annotation"); var opt_annotation_args = DefaultNonTerminal("opt_annotation_args"); var annotation_value_assignments = DefaultNonTerminal("annotation_value_assignments"); var annot_assign_expr = DefaultNonTerminal("annot_assign_expr"); var modifiers_then_opt_generic_arg = DefaultNonTerminal("modifiers_then_opt_generic_arg"); var modifier_or_generic_arg = DefaultNonTerminal("modifier_or_generic_arg"); var modifiers = DefaultNonTerminal("modifiers"); var modifier = DefaultNonTerminal("modifier"); var argument_decls = DefaultNonTerminal("argument_decls"); var argument_decl = DefaultNonTerminal("argument_decl"); var comma_separated_types = DefaultNonTerminal("comma_separated_types"); var throws_decl = DefaultNonTerminal("throws_decl"); var opt_throws_decl = DefaultNonTerminal("opt_throws_decl"); var type_name = DefaultNonTerminal("type_name"); var dotted_identifier = DefaultNonTerminal("dotted_identifier"); var array_type = DefaultNonTerminal("array_type"); var vararg_type = DefaultNonTerminal("vararg_type"); var generic_type = DefaultNonTerminal("generic_type"); var generic_definition_arguments = DefaultNonTerminal("generic_definition_arguments"); var generic_definition_argument = DefaultNonTerminal("generic_definition_argument"); var generic_definition_constraints = DefaultNonTerminal("generic_definition_constraints"); var generic_definition_arguments_spec = DefaultNonTerminal("generic_definition_arguments_spec"); var generic_instance_arguments_spec = DefaultNonTerminal("generic_instance_arguments_spec"); var generic_instance_arguments = DefaultNonTerminal("generic_instance_arguments"); var generic_instance_argument = DefaultNonTerminal("generic_instance_argument"); var generic_instance_identifier_or_q = DefaultNonTerminal("generic_instance_identifier_or_q"); var generic_instance_constraints = DefaultNonTerminal("generic_instance_constraints"); var generic_instance_constraints_extends = DefaultNonTerminal("generic_instance_constraints_extends"); var generic_instance_constraints_super = DefaultNonTerminal("generic_instance_constraints_super"); var generic_instance_constraint_types = DefaultNonTerminal("generic_instance_constraint_types"); var impl_expressions = DefaultNonTerminal("impl_expressions"); var impl_expression = DefaultNonTerminal("impl_expression"); var call_super = DefaultNonTerminal("call_super"); var super_args = DefaultNonTerminal("super_args"); var default_value_expr = DefaultNonTerminal("default_value_expr"); var default_value_casted = DefaultNonTerminal("default_value_casted"); var default_value_literal = DefaultNonTerminal("default_value_literal"); var new_array = DefaultNonTerminal("new_array"); var runtime_exception = DefaultNonTerminal("runtime_exception"); var numeric_terminal = TerminalFactory.CreateCSharpNumber("numeric_value_literal"); numeric_terminal.AddPrefix("-", NumberOptions.AllowSign); numeric_terminal.AddPrefix("+", NumberOptions.AllowSign); //numeric_terminal.AddSuffix ("f"); numeric_terminal.AddSuffix("L"); var numeric_literal = DefaultNonTerminal("numeric_literal"); var string_literal = TerminalFactory.CreateCSharpString("string_literal"); var value_literal = DefaultNonTerminal("value_literal"); var identifier_wild = DefaultNonTerminal("identifier_wild"); // <construction_rules> compile_unit.Rule = opt_package_decl + imports + type_decls; opt_package_decl.Rule = package_decl | Empty; package_decl.Rule = keyword_package + dotted_identifier + ";"; imports.Rule = MakeStarRule(imports, import); import.Rule = keyword_import + dotted_identifier + ";"; type_decls.Rule = MakeStarRule(type_decls, type_decl); type_decl.Rule = class_decl | interface_decl | enum_decl; // FIXME: those modifiers_then_opt_generic_arg should be actually just modifiers... see modifiers_then_opt_generic_arg.Rule below. enum_decl.Rule = annotations + modifiers_then_opt_generic_arg + keyword_enum + identifier + opt_implements_decl + "{" + enum_body + "}"; enum_body.Rule = Empty | enum_members_decl + type_members; class_decl.Rule = annotations + modifiers_then_opt_generic_arg + keyword_class + identifier + opt_generic_arg_decl + opt_extends_decl + opt_implements_decl + type_body; interface_decl.Rule = annotations + modifiers_then_opt_generic_arg + iface_or_at_iface + identifier + opt_generic_arg_decl + opt_extends_decl + opt_implements_decl + type_body; iface_or_at_iface.Rule = keyword_interface | keyword_at_interface; opt_generic_arg_decl.Rule = Empty | "<" + generic_definition_arguments + ">"; opt_extends_decl.Rule = Empty | keyword_extends + implements_decl; // when it is used with an interface, it can be more than one... opt_implements_decl.Rule = Empty | keyword_implements + implements_decl; implements_decl.Rule = MakePlusRule(implements_decl, ToTerm(","), type_name); type_body.Rule = T("{") + type_members + T("}"); annotations.Rule = MakeStarRule(annotations, annotation); annotation.Rule = T("@") + dotted_identifier + opt_annotation_args; opt_annotation_args.Rule = Empty | T("(") + annotation_value_assignments + T(")"); annotation_value_assignments.Rule = rvalue_expression | MakeStarRule(annotation_value_assignments, ToTerm(","), annot_assign_expr); annot_assign_expr.Rule = assign_expr | T("{") + rvalue_expressions + T("}"); // HACK: I believe this is an Irony bug that adding opt_generic_arg_decl here results in shift-reduce conflict, but it's too complicated to investigate the actual issue. // As a workaround I add generic arguments as part of this "modifier" so that it can be safely added to a generic method declaration. modifiers_then_opt_generic_arg.Rule = MakeStarRule(modifiers_then_opt_generic_arg, modifier_or_generic_arg); modifiers.Rule = MakeStarRule(modifiers, modifier); modifier_or_generic_arg.Rule = modifier | generic_definition_arguments_spec; modifier.Rule = keyword_public | keyword_protected | keyword_final | keyword_abstract | keyword_synchronized | keyword_default | keyword_native | keyword_volatile | keyword_transient | keyword_static; type_members.Rule = MakeStarRule(type_members, type_member); type_member.Rule = nested_type_decl | ctor_decl | method_decl | field_decl | static_ctor_decl; nested_type_decl.Rule = type_decl; enum_members_decl.Rule = enum_member_initializers + ";"; enum_member_initializers.Rule = MakeStarRule(enum_member_initializers, ToTerm(","), enum_member_initializer); enum_member_initializer.Rule = annotations + identifier + opt_enum_braces; opt_enum_braces.Rule = Empty | "(" + ")"; static_ctor_decl.Rule = annotations + keyword_static + "{" + assignments + "}"; assignments.Rule = MakeStarRule(assignments, assignment); assignment.Rule = assign_expr + ";"; assign_expr.Rule = identifier + "=" + rvalue_expression; rvalue_expressions.Rule = MakeStarRule(rvalue_expressions, ToTerm(","), rvalue_expression); rvalue_expression.Rule = value_literal | new_array | type_name | identifier | array_literal | annotation; array_literal.Rule = "{" + rvalue_expressions + "}"; field_decl.Rule = annotations + modifiers_then_opt_generic_arg + type_name + identifier + opt_field_assignment + ";" + opt_final_field_assign; opt_field_assignment.Rule = Empty | "=" + rvalue_expression; opt_final_field_assign.Rule = Empty | "{" + assign_expr + ";" + "}"; terminate_decl_or_body.Rule = ";" | ("{" + impl_expressions + "}") | (keyword_default + default_value_literal + ";"); ctor_decl.Rule = annotations + modifiers_then_opt_generic_arg + identifier + "(" + argument_decls + ")" + opt_throws_decl + terminate_decl_or_body; // these Empties can make the structure common to method_decl. method_decl.Rule = annotations + modifiers_then_opt_generic_arg + /*opt_generic_arg_decl*/ type_name + identifier + "(" + argument_decls + ")" + opt_throws_decl + terminate_decl_or_body; impl_expressions.Rule = MakeStarRule(impl_expressions, impl_expression); impl_expression.Rule = call_super | runtime_exception | assign_expr; call_super.Rule = keyword_super + "(" + super_args + ")" + ";"; super_args.Rule = MakeStarRule(super_args, ToTerm(","), default_value_expr); default_value_expr.Rule = keyword_null | default_value_casted | default_value_literal; default_value_casted.Rule = "(" + type_name + ")" + default_value_expr; default_value_literal.Rule = numeric_terminal | "\"\"" | "{" + "}" | keyword_true | keyword_false; runtime_exception.Rule = keyword_throw + keyword_new + identifier + "(\"Stub!\"" + ")" + ";"; new_array.Rule = keyword_new + dotted_identifier + "[" + numeric_literal + "]"; argument_decls.Rule = annotations | MakeStarRule(argument_decls, ToTerm(","), argument_decl); argument_decl.Rule = annotations + type_name + identifier; throws_decl.Rule = keyword_throws + comma_separated_types; comma_separated_types.Rule = MakeStarRule(comma_separated_types, ToTerm(","), type_name); opt_throws_decl.Rule = Empty | throws_decl; type_name.Rule = dotted_identifier | array_type | vararg_type | generic_type; vararg_type.Rule = type_name + T("..."); array_type.Rule = type_name + ("[") + T("]"); generic_definition_arguments_spec.Rule = "<" + generic_definition_arguments + ">"; generic_type.Rule = dotted_identifier + generic_instance_arguments_spec; generic_instance_arguments_spec.Rule = "<" + generic_instance_arguments + ">"; generic_definition_arguments.Rule = MakePlusRule(generic_definition_arguments, ToTerm(","), generic_definition_argument); generic_definition_argument.Rule = identifier + generic_definition_constraints; generic_definition_constraints.Rule = Empty | generic_instance_constraints_extends | generic_instance_constraints_super; generic_instance_arguments.Rule = MakePlusRule(generic_instance_arguments, ToTerm(","), generic_instance_argument); generic_instance_argument.Rule = generic_instance_identifier_or_q + generic_instance_constraints; generic_instance_identifier_or_q.Rule = type_name | T("?"); generic_instance_constraints.Rule = Empty | generic_instance_constraints_extends | generic_instance_constraints_super; generic_instance_constraints_extends.Rule = keyword_extends + generic_instance_constraint_types; generic_instance_constraints_super.Rule = keyword_super + generic_instance_constraint_types; generic_instance_constraint_types.Rule = MakePlusRule(generic_instance_constraint_types, ToTerm("&"), type_name); dotted_identifier.Rule = MakePlusRule(dotted_identifier, ToTerm("."), identifier_wild); numeric_literal.Rule = numeric_terminal; numeric_literal.Rule |= "(" + numeric_literal + "/" + numeric_literal + ")"; value_literal.Rule = string_literal | numeric_literal | keyword_null; identifier_wild.Rule = identifier | "*"; // Define AST node creators Func <string, string> stripGenerics = s => s.IndexOf('<') > 0 ? s.Substring(0, s.IndexOf('<')) : s; single_line_comment.AstConfig.NodeCreator = DoNothing; delimited_comment.AstConfig.NodeCreator = DoNothing; identifier.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.Token.ValueString; compile_unit.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new JavaPackage(null) { Name = (string)node.ChildNodes [0].AstNode, Types = ((IEnumerable <JavaType>)node.ChildNodes [2].AstNode).ToList() }; }; opt_package_decl.AstConfig.NodeCreator = SelectSingleChild; package_decl.AstConfig.NodeCreator = SelectChildValueAt(1); imports.AstConfig.NodeCreator = CreateArrayCreator <object> (); import.AstConfig.NodeCreator = SelectChildValueAt(1); type_decls.AstConfig.NodeCreator = CreateArrayCreator <JavaType> (); type_decl.AstConfig.NodeCreator = SelectSingleChild; opt_generic_arg_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode; }; opt_extends_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode; }; opt_implements_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = node.ChildNodes.Count == 0 ? null : node.ChildNodes [1].AstNode; }; implements_decl.AstConfig.NodeCreator = CreateArrayCreator <string> (); Action <ParseTreeNode, JavaType> fillType = (node, type) => { var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode; var mods = modsOrTps.OfType <string> (); bool isEnum = node.ChildNodes [2].AstNode as string == "enum"; type.Abstract |= mods.Contains("abstract"); type.Static |= mods.Contains("static"); type.Final |= mods.Contains("final"); type.Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? ""; type.Name = (string)node.ChildNodes [3].AstNode; type.Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated"; type.TypeParameters = isEnum ? null : (JavaTypeParameters)node.ChildNodes [4].AstNode; type.Members = (IList <JavaMember>)node.ChildNodes [isEnum ? 6 : 7].AstNode; }; enum_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var type = new JavaClass(null) { Extends = "java.lang.Enum", Final = true }; var methods = new JavaMember [] { new JavaMethod(null) { Deprecated = "not deprecated", Name = "valueOf", // Return needs to be filled later, with full package name. Static = true, Visibility = "public", Parameters = new JavaParameter [] { new JavaParameter(null) { Name = "name", Type = "java.lang.String" } }, }, new JavaMethod(null) { Deprecated = "not deprecated", Name = "values", // Return needs to be filled later, with full package name. Static = true, Visibility = "public", Parameters = new JavaParameter [0], } }; fillType(node, type); node.AstNode = type; }; class_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var exts = ((IEnumerable <string>)node.ChildNodes [5].AstNode) ?? Enumerable.Empty <string> (); var impls = ((IEnumerable <string>)node.ChildNodes [6].AstNode) ?? Enumerable.Empty <string> (); var ext = exts.FirstOrDefault() ?? "java.lang.Object"; var type = new JavaClass(null) { Extends = stripGenerics(ext), ExtendsGeneric = ext, Implements = impls.Select(s => new JavaImplements { Name = stripGenerics(s), NameGeneric = s }).ToArray(), }; fillType(node, type); node.AstNode = type; }; interface_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); bool annot = node.ChildNodes [2].AstNode as string == "@interface"; var exts = ((IEnumerable <string>)node.ChildNodes [5].AstNode) ?? Enumerable.Empty <string> (); var impls = ((IEnumerable <string>)node.ChildNodes [6].AstNode) ?? Enumerable.Empty <string> (); var type = new JavaInterface(null) { Implements = exts.Concat(impls).Select(s => new JavaImplements { Name = stripGenerics(s), NameGeneric = s }).ToList(), }; if (annot) { type.Implements.Add(new JavaImplements { Name = "java.lang.annotation.Annotation", NameGeneric = "java.lang.annotation.Annotation" }); } fillType(node, type); node.AstNode = type; }; iface_or_at_iface.AstConfig.NodeCreator = SelectSingleChild; type_body.AstConfig.NodeCreator = SelectChildValueAt(1); type_members.AstConfig.NodeCreator = CreateArrayCreator <JavaMember> (); type_member.AstConfig.NodeCreator = SelectSingleChild; nested_type_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new JavaNestedType(null) { Type = (JavaType)node.ChildNodes [0].AstNode }; }; Action <ParseTreeNode, JavaMethodBase> fillMethodBase = (node, method) => { bool ctor = node.ChildNodes.Count == 8; var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode; var mods = modsOrTps.OfType <string> (); method.Static = mods.Contains("static"); method.Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? ""; method.Name = (string)node.ChildNodes [ctor ? 2 : 3].AstNode; method.Parameters = ((IEnumerable <JavaParameter>)node.ChildNodes [ctor ? 4 : 5].AstNode).ToArray(); method.ExtendedSynthetic = mods.Contains("synthetic"); // HACK: Exception "name" can be inconsistent for nested types, and this nested type detection is hacky. Func <string, string> stripPackage = s => { var packageTokens = s.Split('.').TakeWhile(t => !t.Any(c => Char.IsUpper(c))); return(s.Substring(Enumerable.Sum(packageTokens.Select(t => t.Length)) + packageTokens.Count())); }; method.Exceptions = ((IEnumerable <string>)node.ChildNodes [ctor ? 6 : 7].AstNode) ?.Select(s => new JavaException { Type = s, Name = stripPackage(s) }) ?.ToArray(); method.Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated"; method.Final = mods.Contains("final"); method.TypeParameters = modsOrTps.OfType <JavaTypeParameters> ().FirstOrDefault(); }; ctor_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var annots = node.ChildNodes [0].AstNode; var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode; var mods = modsOrTps.OfType <string> (); var ctor = new JavaConstructor(null); fillMethodBase(node, ctor); node.AstNode = ctor; }; method_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var annots = node.ChildNodes [0].AstNode; var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode; var mods = modsOrTps.OfType <string> (); var method = new JavaMethod(null) { Return = (string)node.ChildNodes [2].AstNode, Abstract = mods.Contains("abstract"), Native = mods.Contains("native"), Synchronized = mods.Contains("synchronized"), ExtendedSynthetic = mods.Contains("synthetic"), }; fillMethodBase(node, method); node.AstNode = method; }; field_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var annots = node.ChildNodes [0].AstNode; var modsOrTps = (IEnumerable <object>)node.ChildNodes [1].AstNode; var mods = modsOrTps.OfType <string> (); var value = node.ChildNodes [4].AstNode?.ToString(); var type = (string)node.ChildNodes [2].AstNode; node.AstNode = new JavaField(null) { Static = mods.Contains("static"), Visibility = mods.FirstOrDefault(s => s == "public" || s == "protected") ?? "", Type = stripGenerics(type), TypeGeneric = type, Name = (string)node.ChildNodes [3].AstNode, Deprecated = ((IEnumerable <string>)node.ChildNodes [0].AstNode).Any(v => v == "java.lang.Deprecated" || v == "Deprecated") ? "deprecated" : "not deprecated", Value = value == "null" ? null : value, // null will not be explicitly written. Volatile = mods.Contains("volatile"), Final = mods.Contains("final"), Transient = mods.Contains("transient"), }; }; opt_field_assignment.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.ChildNodes.Count > 0 ? node.ChildNodes [1].AstNode : null; opt_final_field_assign.AstConfig.NodeCreator = (ctx, node) => node.AstNode = node.ChildNodes.Count > 0 ? node.ChildNodes [1].AstNode : null; static_ctor_decl.AstConfig.NodeCreator = DoNothing; // static constructors are ignorable. enum_body.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var ml = new List <JavaMember> (); foreach (var c in node.ChildNodes) { ml.AddRange((IEnumerable <JavaMember>)c.AstNode); } node.AstNode = ml; }; enum_members_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); if (node.ChildNodes.Count > 0) { node.AstNode = ((IEnumerable <string>)node.ChildNodes [0].AstNode) .Select(s => new JavaField(null) { Name = s, Final = true, Deprecated = "not deprecated", Static = true, // Type needs to be filled later, with full package name. Visibility = "public" }); } }; enum_member_initializers.AstConfig.NodeCreator = CreateArrayCreator <string> (); enum_member_initializer.AstConfig.NodeCreator = SelectChildValueAt(1); opt_enum_braces.AstConfig.NodeCreator = DoNothing; terminate_decl_or_body.AstConfig.NodeCreator = DoNothing; // method/ctor body doesn't matter. assignments.AstConfig.NodeCreator = CreateArrayCreator <object> (); assignment.AstConfig.NodeCreator = SelectChildValueAt(0); assign_expr.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new KeyValuePair <string, string?> ((string)node.ChildNodes [0].AstNode, node.ChildNodes [2].AstNode?.ToString()); }; rvalue_expressions.AstConfig.NodeCreator = CreateArrayCreator <object> (); rvalue_expression.AstConfig.NodeCreator = SelectSingleChild; array_literal.AstConfig.NodeCreator = CreateStringFlattener(); annotations.AstConfig.NodeCreator = CreateArrayCreator <string> (); annotation.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node.ChildNodes [1]); // we only care about name. node.AstNode = node.ChildNodes [1].AstNode; }; opt_annotation_args.AstConfig.NodeCreator = DoNothing; annotation_value_assignments.AstConfig.NodeCreator = DoNothing; annot_assign_expr.AstConfig.NodeCreator = DoNothing; modifiers_then_opt_generic_arg.AstConfig.NodeCreator = CreateArrayCreator <object> (); modifier_or_generic_arg.AstConfig.NodeCreator = SelectSingleChild; modifiers.AstConfig.NodeCreator = CreateArrayCreator <string> (); modifier.AstConfig.NodeCreator = CreateStringFlattener(); argument_decls.AstConfig.NodeCreator = CreateArrayCreator <JavaParameter> (); argument_decl.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new JavaParameter(null) { Type = (string)node.ChildNodes [1].AstNode, Name = (string)node.ChildNodes [2].AstNode }; }; opt_throws_decl.AstConfig.NodeCreator = SelectSingleChild; throws_decl.AstConfig.NodeCreator = SelectChildValueAt(1); comma_separated_types.AstConfig.NodeCreator = CreateArrayCreator <string> (); type_name.AstConfig.NodeCreator = SelectSingleChild; dotted_identifier.AstConfig.NodeCreator = CreateStringFlattener("."); array_type.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = node.ChildNodes [0].AstNode + "[]"; }; vararg_type.AstConfig.NodeCreator = CreateStringFlattener(); generic_type.AstConfig.NodeCreator = CreateStringFlattener(); generic_definition_arguments_spec.AstConfig.NodeCreator = SelectChildValueAt(1); generic_instance_arguments_spec.AstConfig.NodeCreator = (ctx, node) => { // It is distinct from generic type parameters definition. ProcessChildren(ctx, node); node.AstNode = "<" + string.Join(", ", (IEnumerable <string>)node.ChildNodes [1].AstNode) + ">"; }; generic_definition_arguments.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new JavaTypeParameters((JavaMethod?)null) { TypeParameters = node.ChildNodes.Select(c => c.AstNode).Cast <JavaTypeParameter> ().ToList() }; }; generic_definition_argument.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); node.AstNode = new JavaTypeParameter(null) { Name = (string)node.ChildNodes [0].AstNode, GenericConstraints = (JavaGenericConstraints)node.ChildNodes [1].AstNode }; }; generic_definition_constraints.AstConfig.NodeCreator = SelectSingleChild; generic_instance_arguments.AstConfig.NodeCreator = CreateArrayCreator <string> (); generic_instance_argument.AstConfig.NodeCreator = CreateStringFlattener(); generic_instance_identifier_or_q.AstConfig.NodeCreator = SelectSingleChild; generic_instance_constraints.AstConfig.NodeCreator = (ctx, node) => { ProcessChildren(ctx, node); var c = (JavaGenericConstraints?)node.ChildNodes.FirstOrDefault()?.AstNode; if (c != null) { node.AstNode = " " + c.BoundsType + " " + string.Join(" & ", c.GenericConstraints.Select(cc => cc.Type)); } }; AstNodeCreator createGenericConstaints = (ctx, node) => { ProcessChildren(ctx, node); var cl = ((IEnumerable <string>)node.ChildNodes [1].AstNode).Select(s => new JavaGenericConstraint { Type = s }); node.AstNode = new JavaGenericConstraints() { BoundsType = (string)node.ChildNodes [0].AstNode, GenericConstraints = cl.Any() ? cl.ToArray() : null, }; }; generic_instance_constraints_extends.AstConfig.NodeCreator = createGenericConstaints; generic_instance_constraints_super.AstConfig.NodeCreator = createGenericConstaints; generic_instance_constraint_types.AstConfig.NodeCreator = CreateArrayCreator <string> (); impl_expressions.AstConfig.NodeCreator = CreateArrayCreator <object> (); impl_expression.AstConfig.NodeCreator = SelectSingleChild; // each expression item is not seriously processed. // They are insignificant except for consts, and for consts they are just string values. call_super.AstConfig.NodeCreator = CreateStringFlattener(); super_args.AstConfig.NodeCreator = CreateStringFlattener(); default_value_expr.AstConfig.NodeCreator = CreateStringFlattener(); default_value_casted.AstConfig.NodeCreator = CreateStringFlattener(); default_value_literal.AstConfig.NodeCreator = CreateStringFlattener(); new_array.AstConfig.NodeCreator = DoNothing; runtime_exception.AstConfig.NodeCreator = CreateStringFlattener(); Func <string, string, string> stripTail = (s, t) => s.EndsWith(t, StringComparison.Ordinal) ? s.Substring(0, s.Length - t.Length) : s; numeric_terminal.AstConfig.NodeCreator = (ctx, node) => node.AstNode = stripTail(stripTail(node.Token.Text, "L"), "f"); numeric_literal.AstConfig.NodeCreator = CreateStringFlattener(); string_literal.AstConfig.NodeCreator = (ctx, node) => node.AstNode = '"' + node.Token.ValueString + '"'; value_literal.AstConfig.NodeCreator = SelectSingleChild; identifier_wild.AstConfig.NodeCreator = SelectSingleChild; this.Root = compile_unit; }
public SqlGrammar() : base(false) { //SQL is case insensitive //Terminals var comment = new CommentTerminal("comment", "/*", "*/"); var lineComment = new CommentTerminal("line_comment", "--", "\n", "\r\n"); NonGrammarTerminals.Add(comment); NonGrammarTerminals.Add(lineComment); var number = TerminalFactory.CreateCSharpNumber("number"); number.Options = NumberOptions.AllowSign; var string_literal = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote); string_literal.AddStartEnd("N'", "'", StringOptions.AllowsDoubledQuote | StringOptions.AllowsLineBreak); var Id_simple = TerminalFactory.CreateSqlExtIdentifier(this, "id_simple"); //covers normal identifiers (abc) and quoted id's ([abc d], "abc d") Id_simple.AddPrefix("@@", IdOptions.NameIncludesPrefix); Id_simple.AddPrefix("@", IdOptions.NameIncludesPrefix); var comma = ToTerm(","); var dot = ToTerm("."); var equals = ToTerm("="); var plus = ToTerm("+"); var CREATE = ToTerm("CREATE"); var NULL = ToTerm("NULL"); var NOT = ToTerm("NOT"); var UNIQUE = ToTerm("UNIQUE"); var WITH = ToTerm("WITH"); var TABLE = ToTerm("TABLE"); var VIEW = ToTerm("VIEW"); var DATABASE = ToTerm("DATABASE"); var ALTER = ToTerm("ALTER"); var ADD = ToTerm("ADD"); var COLUMN = ToTerm("COLUMN"); var DROP = ToTerm("DROP"); var CONSTRAINT = ToTerm("CONSTRAINT"); var INDEX = ToTerm("INDEX"); var CLUSTERED = ToTerm("CLUSTERED"); var NONCLUSTERED = ToTerm("NONCLUSTERED"); var ON = ToTerm("ON"); var KEY = ToTerm("KEY"); var PRIMARY = ToTerm("PRIMARY"); var INSERT = ToTerm("INSERT"); var INTO = ToTerm("INTO"); var UPDATE = ToTerm("UPDATE"); var SET = ToTerm("SET"); var VALUES = ToTerm("VALUES"); var DELETE = ToTerm("DELETE"); var SELECT = ToTerm("SELECT"); var FROM = ToTerm("FROM"); var AS = ToTerm("AS"); var COUNT = ToTerm("COUNT"); var JOIN = ToTerm("JOIN"); var BY = ToTerm("BY"); var DEFAULT = ToTerm("DEFAULT"); var CHECK = ToTerm("CHECK"); var REPLICATION = ToTerm("REPLICATION"); var FOR = ToTerm("FOR"); var COLLATE = ToTerm("COLLATE"); var IDENTITY = ToTerm("IDENTITY"); var TEXTIMAGE_ON = ToTerm("TEXTIMAGE_ON"); var IF = ToTerm("IF"); var ELSE = ToTerm("ELSE"); var BEGIN = ToTerm("BEGIN"); var END = ToTerm("END"); var GO = ToTerm("GO"); var PRINT = ToTerm("PRINT"); var IS = ToTerm("IS"); var USE = ToTerm("USE"); var EXEC = ToTerm("EXEC"); var NOCHECK = ToTerm("NOCHECK"); var CASCADE = ToTerm("CASCADE"); var TYPE = ToTerm("TYPE"); var PROCEDURE = ToTerm("PROCEDURE"); var DECLARE = ToTerm("DECLARE"); var TRY = ToTerm("TRY"); var CATCH = ToTerm("CATCH"); var CAST = ToTerm("CAST"); var AND = ToTerm("AND"); var OR = ToTerm("OR"); var GRANT = ToTerm("GRANT"); var UNION = ToTerm("UNION"); var ALL = ToTerm("ALL"); var CASE = ToTerm("CASE"); var WHEN = ToTerm("WHEN"); var THEN = ToTerm("THEN"); var RETURN = ToTerm("RETURN"); var COMMIT = ToTerm("COMMIT"); var TRAN = ToTerm("TRAN"); var TRANSACTION = ToTerm("TRANSACTION"); var TOP = ToTerm("TOP"); var MERGE = ToTerm("MERGE"); var USING = ToTerm("USING"); var MATCHED = ToTerm("MATCHED"); var TARGET = ToTerm("TARGET"); var TRUNCATE = ToTerm("TRUNCATE"); var ROLLBACK = ToTerm("ROLLBACK"); var STATISTICS = ToTerm("STATISTICS"); var ROLE = ToTerm("ROLE"); var WHILE = ToTerm("WHILE"); var BREAK = ToTerm("BREAK"); var REBUILD = ToTerm("REBUILD"); var CHECKPOINT = ToTerm("CHECKPOINT"); var HASH = ToTerm("HASH"); var OUTPUT = ToTerm("OUTPUT"); //Non-terminals var Id = new NonTerminal("Id"); var IdWithAliasOpt = new NonTerminal("IdWithAliasOpt"); var stmt = new NonTerminal("stmt"); var createTableStmt = new NonTerminal("createTableStmt"); var createIndexStmt = new NonTerminal("createIndexStmt"); var createViewStmt = new NonTerminal("createViewStmt"); var createTypeStmt = new NonTerminal("createTypeStmt"); var createProcedureStmt = new NonTerminal("createProcedureStmt"); var variableDefLists = new NonTerminal("variableDefLists"); var variableDefList = new NonTerminal("variableDefList"); var variableDef = new NonTerminal("variableDef"); var outputOpt = new NonTerminal("outputOpt"); var primaryKeyOpt = new NonTerminal("primaryKeyOpt"); var alterStmt = new NonTerminal("alterStmt"); var dropTableStmt = new NonTerminal("dropTableStmt"); var dropIndexStmt = new NonTerminal("dropIndexStmt"); var dropViewStmt = new NonTerminal("dropViewStmt"); var dropProcedureStmt = new NonTerminal("dropProcedureStmt"); var selectStmt = new NonTerminal("selectStmt"); var insertStmt = new NonTerminal("insertStmt"); var updateStmt = new NonTerminal("updateStmt"); var deleteStmt = new NonTerminal("deleteStmt"); var ifStmt = new NonTerminal("ifStmt"); var elseStmt = new NonTerminal("elseStmt"); var fieldDef = new NonTerminal("fieldDef"); var fieldDefList = new NonTerminal("fieldDefList"); var nullSpecOpt = new NonTerminal("nullSpecOpt"); var typeName = new NonTerminal("typeName"); var constraintListOpt = new NonTerminal("constraintListOpt"); var constraintDef = new NonTerminal("constraintDef"); var indexContraintDef = new NonTerminal("indexContraintDef"); var constraintTypeOpt = new NonTerminal("constraintTypeOptOpt"); var defaultValueOpt = new NonTerminal("defaultValueOpt"); var idlist = new NonTerminal("idlist"); var idOrExpression = new NonTerminal("idOrExpression"); var idOrExpressionList = new NonTerminal("idOrExpressionList"); var idlistForSelect = new NonTerminal("idlistForSelect"); var idlistParOpt = new NonTerminal("idlistPar"); var orderList = new NonTerminal("orderList"); var orderMember = new NonTerminal("orderMember"); var orderDirOpt = new NonTerminal("orderDirOpt"); var defaultValueParams = new NonTerminal("defaultValueParams"); var indexTypeOpt = new NonTerminal("indexTypeOpt"); var indexTypeList = new NonTerminal("indexTypeList"); var withClauseOpt = new NonTerminal("withClauseOpt"); var alterCmdOpt = new NonTerminal("alterCmdOpt"); var insertData = new NonTerminal("insertData"); var intoOpt = new NonTerminal("intoOpt"); var assignList = new NonTerminal("assignList"); var whereClauseOpt = new NonTerminal("whereClauseOpt"); var andClauseOpt = new NonTerminal("andClauseOpt"); var betweenClauseOpt = new NonTerminal("betweenClauseOpt"); var assignment = new NonTerminal("assignment"); var expression = new NonTerminal("expression"); var exprList = new NonTerminal("exprList"); var selRestrOpt = new NonTerminal("selRestrOpt"); var selList = new NonTerminal("selList"); var intoClauseOpt = new NonTerminal("intoClauseOpt"); var fromClauseOpt = new NonTerminal("fromClauseOpt"); var groupClauseOpt = new NonTerminal("groupClauseOpt"); var havingClauseOpt = new NonTerminal("havingClauseOpt"); var orderClauseOpt = new NonTerminal("orderClauseOpt"); var columnItemList = new NonTerminal("columnItemList"); var columnItem = new NonTerminal("columnItem"); var columnSource = new NonTerminal("columnSource"); var asOpt = new NonTerminal("asOpt"); var aliasOpt = new NonTerminal("aliasOpt"); var aggregate = new NonTerminal("aggregate"); var aggregateArg = new NonTerminal("aggregateArg"); var aggregateName = new NonTerminal("aggregateName"); var tuple = new NonTerminal("tuple"); var joinChainOpt = new NonTerminal("joinChainOpt"); var joinKindOpt = new NonTerminal("joinKindOpt"); var term = new NonTerminal("term"); var unExpr = new NonTerminal("unExpr"); var unOp = new NonTerminal("unOp"); var binExpr = new NonTerminal("binExpr"); var binOp = new NonTerminal("binOp"); var betweenExpr = new NonTerminal("betweenExpr"); var notOpt = new NonTerminal("notOpt"); var funCall = new NonTerminal("funCall"); var stmtLine = new NonTerminal("stmtLine"); var semiOpt = new NonTerminal("semiOpt"); var stmtList = new NonTerminal("stmtList"); var funArgsOpt = new NonTerminal("funArgsOpt"); var inStmt = new NonTerminal("inStmt"); var settingList = new NonTerminal("settingList"); var settingListItem = new NonTerminal("settingListItem"); var onOpt = new NonTerminal("onOpt"); var textImageOnOpt = new NonTerminal("textImageOnOpt"); var defaultValueParamsList = new NonTerminal("defaultValueParamsList"); var typeNameParamsList = new NonTerminal("typeNameParamsList"); var notForReplOpt = new NonTerminal("notForReplOpt"); var collateOpt = new NonTerminal("collateOpt"); var columnDef = new NonTerminal("columnDef"); var identityOpt = new NonTerminal("identityOpt"); var referencesOpt = new NonTerminal("referencesOpt"); var fieldDefLists = new NonTerminal("fieldDefLists"); var onListOpt = new NonTerminal("onListOpt"); var printStmt = new NonTerminal("printStmt"); var beginEndStmt = new NonTerminal("beginEndStmt"); var beginTryCatchStmt = new NonTerminal("beginTryCatchStmt"); var beginEndStmtList = new NonTerminal("beginEndStmtList"); var isNullOpt = new NonTerminal("isNullOpt"); var setStmtOpt = new NonTerminal("setStmtOpt"); var useStmt = new NonTerminal("useStmt"); var forOpt = new NonTerminal("forOpt"); var execStmt = new NonTerminal("execStmt"); var cascadeOpt = new NonTerminal("cascadeOpt"); var cascadeListOpt = new NonTerminal("cascadeListOpt"); var alterProcedureStmt = new NonTerminal("alterProcedureStmt"); var declareStmt = new NonTerminal("declareStmt"); var concatStringItem = new NonTerminal("concatStringItem"); var concatStringList = new NonTerminal("concatStringList"); var castFunCall = new NonTerminal("castFunCall"); var funCallList = new NonTerminal("funCallList"); var funcallDelim = new NonTerminal("funcallDelim"); var declareList = new NonTerminal("declareList"); var declareListItem = new NonTerminal("declareListItem"); var grantStmt = new NonTerminal("grantStmt"); var joinChainOptList = new NonTerminal("joinChainOptList"); var leftParenOpt = new NonTerminal("leftParenOpt"); var rightParenOpt = new NonTerminal("rightParenOpt"); var unionAllOpt = new NonTerminal("unionAllOpt"); var selectCaseStmts = new NonTerminal("selectCaseStmts"); var selectCaseStmt = new NonTerminal("selectCaseStmt"); var caseWhenThenLists = new NonTerminal("caseWhenThenLists"); var caseWhenThenList = new NonTerminal("caseWhenThenList"); var caseWhenThenStmt = new NonTerminal("caseWhenThenStmt"); var unionAllListOpt = new NonTerminal("unionAllListOpt"); var returnStmt = new NonTerminal("returnStmt"); var beginTransStmt = new NonTerminal("beginTransStmt"); var rollbackTransStmt = new NonTerminal("rollbackTransStmt"); var topOpt = new NonTerminal("topOpt"); var mergeStmt = new NonTerminal("mergeStmt"); var mergeWhenMatched = new NonTerminal("mergeWhenMatched"); var mergeWhenNotMatched = new NonTerminal("mergeWhenNotMatched"); var truncateStmt = new NonTerminal("truncateStmt"); var commitTransStmt = new NonTerminal("commitTransStmt"); var noLockOpt = new NonTerminal("noLockOpt"); var declareTableStmt = new NonTerminal("declareTableStmt"); var joinStmtOpt = new NonTerminal("joinStmtOpt"); var forXmlStmtOpt = new NonTerminal("forXmlStmtOpt"); var forXmlFunCallList = new NonTerminal("forXmlFunCallList"); var funArgsList = new NonTerminal("funArgsList"); var updateStatisticsStmt = new NonTerminal("updateStatisticsStmt"); var createRoleStmt = new NonTerminal("createRoleStmt"); var whileStmt = new NonTerminal("whileStmt"); var alterIndexStmt = new NonTerminal("alterIndexStmt"); var ifCondition = new NonTerminal("ifCondition"); var ifConditionChain = new NonTerminal("ifConditionChain"); var hashOpt = new NonTerminal("hashOpt"); var IdAsType = new NonTerminal("IdAsType"); var selectWithUnion = new NonTerminal("selectWithUnion"); var withStmt = new NonTerminal("withStmt"); //BNF Rules this.Root = stmtList; stmtLine.Rule = stmt + semiOpt; semiOpt.Rule = Empty | ";"; stmtList.Rule = MakePlusRule(stmtList, stmtLine); setStmtOpt.Rule = Empty | SET + Id + Id | SET + Id + equals + (leftParenOpt + selectStmt + rightParenOpt | Id | funCall | concatStringList | expression); useStmt.Rule = USE + Id; execStmt.Rule = EXEC + (Empty | Id | Id + ".." + Id) + (leftParenOpt + funArgsList + rightParenOpt); declareStmt.Rule = DECLARE + declareList; declareTableStmt.Rule = DECLARE + Id + TABLE + "(" + fieldDefList + ")"; declareListItem.Rule = Id + typeName | Id + typeName + equals + term; declareList.Rule = MakePlusRule(declareList, comma, declareListItem); castFunCall.Rule = CAST + "(" + funCall + asOpt + (Empty | typeName) + ")" + asOpt + (Empty | typeName); grantStmt.Rule = GRANT + term + ON + TYPE + "::" + Id + "TO" + Id; returnStmt.Rule = RETURN + term; leftParenOpt.Rule = Empty | "("; rightParenOpt.Rule = Empty | ")"; unionAllOpt.Rule = Empty | UNION + ALL + leftParenOpt + selectStmt + rightParenOpt; unionAllListOpt.Rule = MakeStarRule(unionAllListOpt, unionAllOpt); idOrExpression.Rule = Id | expression; idOrExpressionList.Rule = MakeStarRule(idOrExpressionList, comma, idOrExpression); whileStmt.Rule = WHILE + expression + beginEndStmt; //ID Id.Rule = MakePlusRule(Id, dot, Id_simple); IdWithAliasOpt.Rule = Id | Id + Id | Id + AS + Id; IdAsType.Rule = Id + AS + typeName; concatStringItem.Rule = leftParenOpt + term + rightParenOpt; concatStringList.Rule = MakePlusRule(concatStringList, plus, concatStringItem); stmt.Rule = createProcedureStmt | createTableStmt | createIndexStmt | createViewStmt | createTypeStmt | createRoleStmt | declareTableStmt | alterStmt | dropTableStmt | dropIndexStmt | dropViewStmt | dropProcedureStmt | selectWithUnion | insertStmt | updateStmt | deleteStmt | whileStmt | GO | ifStmt | elseStmt | beginEndStmt | printStmt | withStmt | execStmt | setStmtOpt | useStmt | funCall | declareStmt | returnStmt | grantStmt | mergeStmt | truncateStmt | updateStatisticsStmt | beginTransStmt | commitTransStmt | rollbackTransStmt | BREAK | CHECKPOINT | ";"; onOpt.Rule = Empty | ON + Id; textImageOnOpt.Rule = Empty | TEXTIMAGE_ON + Id; forOpt.Rule = Empty | FOR + Id; onListOpt.Rule = MakePlusRule(onListOpt, onOpt); withStmt.Rule = WITH + Id + AS + leftParenOpt + selectStmt + rightParenOpt; fieldDefLists.Rule = MakePlusRule(fieldDefLists, fieldDefList); printStmt.Rule = PRINT + concatStringList; beginEndStmtList.Rule = MakePlusRule(beginEndStmtList, stmt); beginEndStmt.Rule = beginTryCatchStmt | BEGIN + beginEndStmtList + END; beginTryCatchStmt.Rule = BEGIN + TRY + beginEndStmtList + END + TRY + BEGIN + CATCH + beginEndStmtList + END + CATCH; beginTransStmt.Rule = BEGIN + (TRAN | TRANSACTION) + (Empty | Id); commitTransStmt.Rule = COMMIT + (TRAN | TRANSACTION) + (Empty | Id); rollbackTransStmt.Rule = ROLLBACK + (TRAN | TRANSACTION) + (Empty | Id); truncateStmt.Rule = TRUNCATE + TABLE + Id; isNullOpt.Rule = Empty | IS + NULL; funcallDelim.Rule = AND | OR; funCallList.Rule = MakePlusRule(funCallList, funcallDelim, funCall); // If ifStmt.Rule = IF + leftParenOpt + ifConditionChain + rightParenOpt; ifCondition.Rule = (notOpt + funCall + isNullOpt | NOT + leftParenOpt + expression + rightParenOpt) | (Empty | "EXISTS") + "(" + (Id_simple + IS + NULL | settingListItem | selectWithUnion) + ")" | "EXISTS" + "(" + selectWithUnion + ")" | (Id_simple + IS + (Empty | NOT) + NULL | settingListItem) | expression; ifConditionChain.Rule = MakePlusRule(ifConditionChain, AND | OR, ifCondition); elseStmt.Rule = ELSE; createRoleStmt.Rule = CREATE + ROLE + Id; createViewStmt.Rule = CREATE + VIEW + Id + AS + leftParenOpt + selectWithUnion + rightParenOpt + unionAllListOpt; createTypeStmt.Rule = CREATE + TYPE + Id + FROM + Id | CREATE + TYPE + Id + AS + TABLE + "(" + fieldDefLists + ")"; //Create procedure createProcedureStmt.Rule = CREATE + PROCEDURE + Id + "(" + variableDefLists + ")" + AS + BEGIN + stmtList + END; variableDefLists.Rule = MakePlusRule(variableDefLists, variableDefList); variableDefList.Rule = MakeListRule(variableDefList, comma, variableDef, TermListOptions.AllowTrailingDelimiter | TermListOptions.PlusList); variableDef.Rule = Id + typeName + outputOpt; outputOpt.Rule = Empty | OUTPUT; //Create table createTableStmt.Rule = CREATE + TABLE + Id + "(" + fieldDefLists + ")" + (onOpt | withClauseOpt) + textImageOnOpt; fieldDefList.Rule = MakeListRule(fieldDefList, comma, fieldDef, TermListOptions.AllowTrailingDelimiter | TermListOptions.PlusList); fieldDef.Rule = columnDef | constraintListOpt; columnDef.Rule = Id + typeName + collateOpt + primaryKeyOpt + nullSpecOpt + referencesOpt + defaultValueOpt + withClauseOpt | Id + typeName + collateOpt + primaryKeyOpt + nullSpecOpt + constraintListOpt + withClauseOpt | Id + typeName + collateOpt + primaryKeyOpt + notForReplOpt + nullSpecOpt + defaultValueOpt + withClauseOpt | Id + typeName + collateOpt + primaryKeyOpt + notForReplOpt + nullSpecOpt + constraintListOpt + withClauseOpt | Id + typeName + equals + term | primaryKeyOpt + indexTypeOpt + idlistParOpt + withClauseOpt | term; referencesOpt.Rule = Empty | "References" + Id + idlistParOpt; notForReplOpt.Rule = Empty | (NOT + FOR + REPLICATION); nullSpecOpt.Rule = Empty | (NOT + FOR + REPLICATION) | NULL | NOT + NULL | NOT + NULL + typeName | NULL + typeName; collateOpt.Rule = Empty | COLLATE + Id_simple; identityOpt.Rule = Empty | IDENTITY; typeNameParamsList.Rule = MakePlusRule(typeNameParamsList, comma, term); typeName.Rule = Id_simple | Id_simple + "(" + typeNameParamsList + ")" | Id_simple + "(max)"; constraintDef.Rule = CONSTRAINT + Id + constraintTypeOpt + onListOpt; indexContraintDef.Rule = constraintTypeOpt + onListOpt; constraintListOpt.Rule = MakeStarRule(constraintListOpt, constraintDef); constraintTypeOpt.Rule = Empty | defaultValueOpt + withClauseOpt | primaryKeyOpt + indexTypeList + idlistParOpt + withClauseOpt | CHECK + "(" + expression + ")" + withClauseOpt | NOT + NULL + idlistParOpt + withClauseOpt | "Foreign" + KEY + idlistParOpt + referencesOpt + notForReplOpt + withClauseOpt | "INCLUDE" + idlistParOpt + withClauseOpt + onOpt; idlistParOpt.Rule = Empty | "(" + orderList + ")"; idlist.Rule = MakePlusRule(idlist, comma, Id); idlistForSelect.Rule = MakePlusRule(idlist, comma, IdWithAliasOpt); defaultValueParamsList.Rule = MakePlusRule(defaultValueParamsList, comma, term); defaultValueOpt.Rule = Empty | (DEFAULT + defaultValueParams); defaultValueParams.Rule = term | "(" + term + ")"; //Create Index primaryKeyOpt.Rule = Empty | PRIMARY + KEY | typeName; createIndexStmt.Rule = CREATE + indexTypeList + INDEX + Id + onOpt + "(" + orderList + ")" + constraintTypeOpt + whereClauseOpt + withClauseOpt + onOpt; orderList.Rule = MakePlusRule(orderList, comma, orderMember); orderMember.Rule = Id + orderDirOpt; orderDirOpt.Rule = Empty | "ASC" | "DESC"; indexTypeOpt.Rule = Empty | UNIQUE | CLUSTERED | NONCLUSTERED; indexTypeList.Rule = MakeStarRule(indexTypeList, indexTypeOpt); settingList.Rule = MakePlusRule(settingList, comma, settingListItem); settingListItem.Rule = Id + equals + term; withClauseOpt.Rule = Empty | (WITH + PRIMARY | WITH + "Disallow" + NULL | WITH + "Ignore" + NULL | WITH + "(" + settingList + ")" + onOpt + textImageOnOpt); cascadeOpt.Rule = Empty | (ON + (UPDATE | DELETE) + CASCADE); cascadeListOpt.Rule = MakePlusRule(cascadeListOpt, cascadeOpt); noLockOpt.Rule = (Empty | WITH + leftParenOpt + "NOLOCK" + rightParenOpt); //Alter alterStmt.Rule = ALTER + (TABLE | DATABASE) + Id + setStmtOpt + alterCmdOpt | alterProcedureStmt | alterIndexStmt; alterCmdOpt.Rule = Empty | ADD + COLUMN + fieldDefList + constraintDef | CHECK + CONSTRAINT + Id | WITH + (CHECK | NOCHECK) + ADD + CONSTRAINT + Id + constraintTypeOpt + cascadeListOpt | ADD + constraintDef + forOpt | DROP + COLUMN + Id | DROP + CONSTRAINT + Id; alterProcedureStmt.Rule = ALTER + PROCEDURE + Id + leftParenOpt + fieldDefLists + rightParenOpt + asOpt + beginEndStmt; alterIndexStmt.Rule = ALTER + INDEX + Id + ON + Id + REBUILD + WITH + "(" + settingList + ")"; //Drop stmts dropTableStmt.Rule = DROP + TABLE + Id; dropIndexStmt.Rule = DROP + INDEX + Id + ON + Id; dropViewStmt.Rule = DROP + VIEW + Id; dropProcedureStmt.Rule = DROP + PROCEDURE + Id; //Insert stmt insertStmt.Rule = INSERT + (Empty | intoOpt + Id) + (idlistParOpt + insertData | execStmt); insertData.Rule = leftParenOpt + selectWithUnion + rightParenOpt | VALUES + "(" + exprList + ")"; intoOpt.Rule = Empty | INTO; //Into is optional in MSSQL //Update stmt updateStmt.Rule = UPDATE + topOpt + (Empty | Id) + SET + assignList + fromClauseOpt + joinStmtOpt + whereClauseOpt + andClauseOpt; assignList.Rule = MakePlusRule(assignList, comma, assignment); assignment.Rule = Id + "=" + expression; updateStatisticsStmt.Rule = UPDATE + STATISTICS + Id; //Delete stmt deleteStmt.Rule = DELETE + (Empty | FROM) + Id + whereClauseOpt + andClauseOpt; //Select stmt selectCaseStmt.Rule = CASE + caseWhenThenLists + ELSE + expression + END + (Empty | asOpt + Id); caseWhenThenLists.Rule = MakePlusRule(caseWhenThenLists, caseWhenThenList); caseWhenThenList.Rule = WHEN + leftParenOpt + expression + rightParenOpt + THEN + term; variableDef.Rule = Id + typeName + outputOpt; selectStmt.Rule = SELECT + topOpt + selRestrOpt + selList + intoClauseOpt + fromClauseOpt + forXmlStmtOpt + joinChainOptList + whereClauseOpt + andClauseOpt + betweenClauseOpt + groupClauseOpt + havingClauseOpt + orderClauseOpt; selectWithUnion.Rule = MakePlusRule(selectWithUnion, UNION, selectStmt); mergeStmt.Rule = MERGE + Id + AS + Id + USING + (Empty | Id) + leftParenOpt + (Empty | selectWithUnion) + rightParenOpt + AS + Id + ON + expression + mergeWhenMatched + mergeWhenNotMatched + mergeWhenNotMatched; mergeWhenMatched.Rule = WHEN + MATCHED + andClauseOpt + THEN + stmt; mergeWhenNotMatched.Rule = Empty | WHEN + NOT + MATCHED + BY + Id + THEN + stmt; forXmlStmtOpt.Rule = Empty | FOR + "XML" + forXmlFunCallList; forXmlFunCallList.Rule = MakePlusRule(forXmlFunCallList, comma, funCall); topOpt.Rule = Empty | TOP + leftParenOpt + (number | Id) + rightParenOpt; selRestrOpt.Rule = Empty | "ALL" | "DISTINCT"; selList.Rule = columnItemList + semiOpt | "*"; columnItemList.Rule = MakePlusRule(columnItemList, comma, columnItem); columnItem.Rule = columnSource; aliasOpt.Rule = Empty | asOpt + Id; asOpt.Rule = Empty | AS; columnSource.Rule = Id + aliasOpt | Id + "=" + (selectCaseStmt | concatStringList | expression) | expression | expression + asOpt + (Empty | Id) | selectCaseStmt; aggregate.Rule = aggregateName + "(" + aggregateArg + ")"; aggregateArg.Rule = expression | "*"; aggregateName.Rule = COUNT | "Avg" | "Min" | "Max" | "StDev" | "StDevP" | "Sum" | "Var" | "VarP"; intoClauseOpt.Rule = Empty | INTO + Id; fromClauseOpt.Rule = Empty | FROM + leftParenOpt + (selectStmt | funCall | idlistForSelect) + rightParenOpt + (Empty | AS + Id) + noLockOpt; joinStmtOpt.Rule = Empty | JOIN + Id + asOpt + Id + noLockOpt + ON + expression; joinChainOpt.Rule = Empty | joinKindOpt + hashOpt + joinStmtOpt; joinChainOptList.Rule = MakeStarRule(joinChainOptList, joinChainOpt); joinKindOpt.Rule = Empty | "INNER" | "OUTER" | "LEFT" | "RIGHT"; hashOpt.Rule = Empty | HASH; whereClauseOpt.Rule = Empty | "WHERE" + expression; andClauseOpt.Rule = Empty | "AND" + expression; betweenClauseOpt.Rule = Empty | "BETWEEN" + expression; groupClauseOpt.Rule = Empty | "GROUP" + BY + idOrExpressionList; havingClauseOpt.Rule = Empty | "HAVING" + expression; orderClauseOpt.Rule = Empty | "ORDER" + BY + orderList; //Expression exprList.Rule = MakePlusRule(exprList, comma, expression); expression.Rule = term | unExpr | binExpr | betweenExpr; //-- BETWEEN doesn't work - yet; brings a few parsing conflicts term.Rule = Id | IdAsType | string_literal | number | funCall | tuple | aggregate; // | inStmt; tuple.Rule = "(" + exprList + ")"; unExpr.Rule = unOp + term; unOp.Rule = NOT | "+" | "-" | "~"; binExpr.Rule = expression + binOp + expression; binOp.Rule = ToTerm("+") | "-" | "*" | "/" | "%" //arithmetic | "&" | "|" | "^" //bit | "=" | ">" | "<" | ">=" | "<=" | "<>" | "!=" | "!<" | "!>" | "AND" | "OR" | "LIKE" | NOT + "LIKE" | IS | "IN" | NOT + "IN"; betweenExpr.Rule = expression + notOpt + "BETWEEN" + expression + "AND" + expression; notOpt.Rule = Empty | NOT; //funCall covers some psedo-operators and special forms like ANY(...), SOME(...), ALL(...), EXISTS(...), IN(...) funCall.Rule = Id + "(" + funArgsList + ")" + (Empty | AS + typeName); funArgsOpt.Rule = Empty | selectStmt | expression | string_literal | Id + "=" + term; funArgsList.Rule = MakePlusRule(funArgsList, comma, funArgsOpt); inStmt.Rule = expression + "IN" + "(" + exprList + ")"; //Operators RegisterOperators(10, "*", "/", "%"); RegisterOperators(9, "+", "-"); RegisterOperators(8, "=", ">", "<", ">=", "<=", "<>", "!=", "!<", "!>", "LIKE", "IN"); RegisterOperators(7, "^", "&", "|"); RegisterOperators(6, NOT); RegisterOperators(5, "AND"); RegisterOperators(4, "OR"); MarkPunctuation(",", "(", ")"); MarkPunctuation(asOpt, semiOpt); //Note: we cannot declare binOp as transient because it includes operators "NOT LIKE", "NOT IN" consisting of two tokens. // Transient non-terminals cannot have more than one non-punctuation child nodes. // Instead, we set flag InheritPrecedence on binOp , so that it inherits precedence value from it's children, and this precedence is used // in conflict resolution when binOp node is sitting on the stack base.MarkTransient(stmt, term, asOpt, aliasOpt, stmtLine, expression, unOp, tuple); binOp.SetFlag(TermFlags.InheritPrecedence); } //constructor
public Gramatica() : base(caseSensitive: true) { //------------------------------------------------------------------------Expresiones Regulares----------------------------------------------- #region ER NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero"); IdentifierTerminal id = TerminalFactory.CreateCSharpIdentifier("id"); #endregion //--------------------------------------------------------------------------Palabras Reservadas----------------------------------------------------------- #region PalabrasReservadas MarkReservedWords("imprimir"); MarkReservedWords("raiz"); MarkReservedWords("graficar"); MarkReservedWords("programa"); MarkReservedWords("var"); MarkReservedWords("double"); MarkReservedWords("string"); MarkReservedWords("int"); MarkReservedWords("bool"); MarkReservedWords("OR"); MarkReservedWords("AND"); MarkReservedWords("NOT"); MarkReservedWords("retornar"); MarkReservedWords("void"); MarkReservedWords("principal"); MarkReservedWords("SI"); MarkReservedWords("SINO_SI"); MarkReservedWords("SINO"); MarkReservedWords("INTERRUMPIR"); MarkReservedWords("CASO"); MarkReservedWords("DEFECTO"); MarkReservedWords("MIENTRAS"); MarkReservedWords("HACER"); MarkReservedWords("salir"); #endregion #region Terminales var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var division = ToTerm("/"); var potencia = ToTerm("^"); var parentesis = ToTerm("("); var imprimir = ToTerm("imprimir"); var raiz = ToTerm("raiz"); var graficar = ToTerm("graficar"); var programa = ToTerm("programa"); var variable = ToTerm("var"); var vadouble = ToTerm("double"); var vastring = ToTerm("string"); var varint = ToTerm("int"); var vabool = ToTerm("bool"); var or = ToTerm("OR"); var and = ToTerm("AND"); var retornar = ToTerm("retornar"); var tvoid = ToTerm("void"); var principal = ToTerm("principal"); var si = ToTerm("SI"); var sinosi = ToTerm("SINO_SI"); var sino = ToTerm("SINO"); var interruptor = ToTerm("INTERRUMPIR"); var caso = ToTerm("CASO"); var defecto = ToTerm("DEFECTO"); var mientras = ToTerm("MIENTRAS"); var hacer = ToTerm("HACER"); var salir = ToTerm("salir"); var tString = new StringLiteral("tString", "\"", StringOptions.AllowsDoubledQuote); var tchar = new StringLiteral("tchar", "\'", StringOptions.AllowsDoubledQuote); var mayor = ToTerm(">"); var menor = ToTerm("<"); var mayorigual = ToTerm(">="); var menorigual = ToTerm("<="); var igualigual = ToTerm("=="); var diferente = ToTerm("!="); var asignacion = ToTerm("::="); var puntocoma = ToTerm(";"); var opencorch = ToTerm("["); var closecorch = ToTerm("]"); var openpare = ToTerm("("); var closepare = ToTerm(")"); var coma = ToTerm(","); var trues = ToTerm("true"); var falses = ToTerm("false"); var negacion = ToTerm("!"); #endregion #region Noterminales var INICIO = new NonTerminal("INICIO"); var CUERPO = new NonTerminal("CUERPO"); var ESTRUCTURA = new NonTerminal("ESTRUCTURA"); var CUERPO2 = new NonTerminal("CUERPO2"); var ESTRUCTURA2 = new NonTerminal("ESTRUCTURA2"); var IMPRIMIR = new NonTerminal("IMPRIMIR"); var EXPRESION = new NonTerminal("EXPRESION"); var LLAMADAFUNC = new NonTerminal("LLAMADAFUNC"); var RAIZZ = new NonTerminal("RAIZ"); var GRAFICAR = new NonTerminal("GRAFICAR"); var DECLARACION = new NonTerminal("DECLARACION"); var DECLARACION2 = new NonTerminal("DECLARACION2"); var MULTIVAR = new NonTerminal("MULTIVAR"); var ASIGNACION = new NonTerminal("ASIGNACION"); var DECLASIGNA = new NonTerminal("DECLAASIGNA"); var DECLASIGNA2 = new NonTerminal("DECLAASIGNA2"); var METOFUNC = new NonTerminal("METOFUNC"); var TIPO = new NonTerminal("TIPO"); var CUERPOME = new NonTerminal("CUERPOME"); var ESTRUCTURAME = new NonTerminal("ESTRUCTURAME"); var RETORNAR = new NonTerminal("RETORNAR"); var PARAMETROS = new NonTerminal("PARAMETROS"); var MVOID = new NonTerminal("MVOID"); var PRINCIPAL = new NonTerminal("PRINCIPAL"); var CIF = new NonTerminal("CIF"); var CONDICION = new NonTerminal("CONDICION"); var SINOSI = new NonTerminal("SINOSI"); var SINO = new NonTerminal("SINO"); var CINTERRUMPIR = new NonTerminal("CINTERRUMPIR"); var CASO = new NonTerminal("CASO"); var DEFECTO = new NonTerminal("DEFECTO"); var CMIENTRAS = new NonTerminal("CMIENTRAS"); var CHACER = new NonTerminal("CHACER"); var SALIR = new NonTerminal("SALIR"); var DECLAPARA = new NonTerminal("DECLAPARA"); var PARALLAMA = new NonTerminal("PARALLAMA"); #endregion //---------------------------------------------------------------------PRODUCCIONES----------------------------------------------------------- #region producciones this.Root = INICIO; INICIO.Rule = programa + id + opencorch + CUERPO2 + closecorch; CUERPO2.Rule = MakeStarRule(CUERPO2, ESTRUCTURA2); ESTRUCTURA2.Rule = DECLARACION2 | DECLASIGNA2 | METOFUNC | MVOID | PRINCIPAL; CUERPO.Rule = MakeStarRule(CUERPO, ESTRUCTURA); ESTRUCTURA.Rule = IMPRIMIR | GRAFICAR | DECLARACION | ASIGNACION | DECLASIGNA | LLAMADAFUNC | CIF | CINTERRUMPIR | CMIENTRAS | CHACER | RETORNAR; CUERPOME.Rule = MakeStarRule(CUERPOME, ESTRUCTURAME); ESTRUCTURAME.Rule = IMPRIMIR | GRAFICAR | DECLARACION | ASIGNACION | DECLASIGNA | LLAMADAFUNC | CIF | CINTERRUMPIR | CMIENTRAS | CHACER | RETORNAR | SALIR; //----------------------------------------------------------------IMPRIMIR----------------------------------------------- IMPRIMIR.Rule = imprimir + openpare + EXPRESION + closepare + puntocoma; //--------------------------------------------------------------RAIZ CUADRADA------------------------------------------------------ RAIZZ.Rule = raiz + openpare + EXPRESION + coma + EXPRESION + closepare; //-----------------------------------------------------------------GRAFICAR----------------------------------------------------------- GRAFICAR.Rule = graficar + openpare + "\"x\"" + coma + EXPRESION + coma + numero + coma + numero + coma + tString + closepare + puntocoma | graficar + openpare + "\"y\"" + coma + EXPRESION + coma + numero + coma + numero + coma + tString + closepare + puntocoma; //-----------------------------------------------------------------DECLARACION DE VARIABLES------------------------------------------------ DECLARACION.Rule = variable + MULTIVAR + puntocoma; DECLARACION2.Rule = variable + MULTIVAR + puntocoma; MULTIVAR.Rule = id + coma + MULTIVAR | id; //-----------------------------------------------------------------ASIGNACION DE VARIABLES---------------------------------------------- ASIGNACION.Rule = id + asignacion + EXPRESION + puntocoma; //------------------------------------------------------------------ASIGNACION Y DECLARACION----------------------------------------------- DECLASIGNA.Rule = variable + MULTIVAR + asignacion + EXPRESION + puntocoma; DECLASIGNA2.Rule = variable + MULTIVAR + asignacion + EXPRESION + puntocoma; //-------------------------------------------------------------------------FUNCIONES------------------------------------------------------ METOFUNC.Rule = TIPO + id + openpare + DECLAPARA + closepare + opencorch + CUERPOME + closecorch; TIPO.Rule = varint | vastring | vadouble; PARAMETROS.Rule = EXPRESION | EXPRESION + coma + PARAMETROS | Empty; DECLAPARA.Rule = variable + id + coma + DECLAPARA | variable + id | Empty; //-----------------------------------------------------------------------METODO VOID------------------------------------------------------- MVOID.Rule = tvoid + id + openpare + DECLAPARA + closepare + opencorch + CUERPO + closecorch; //----------------------------------------------------------------RETORNAR------------------------------------------------------ RETORNAR.Rule = retornar + EXPRESION + puntocoma; //-------------------------------------------------------------------LLAMADA A FUNCION------------------------------------------- LLAMADAFUNC.Rule = id + openpare + PARAMETROS + closepare + puntocoma; PARALLAMA.Rule = id + openpare + PARAMETROS + closepare; //-------------------------------------------------------------------METODO PRINCIPAL----------------------------------------------- PRINCIPAL.Rule = principal + openpare + closepare + opencorch + CUERPO + closecorch; //--------------------------------------------------------------------CONTROL IF-------------------------------------------------------- CIF.Rule = si + openpare + EXPRESION + closepare + opencorch + CUERPO + closecorch + SINOSI + SINO; //--------------------------------------------------------------ELSE IF---------------------------------------------------------------- SINOSI.Rule = sinosi + openpare + EXPRESION + closepare + opencorch + CUERPO + closecorch + SINOSI | Empty; //-----------------------------------------------------------------ELSE------------------------------------------------------------------- SINO.Rule = sino + opencorch + CUERPO + closecorch | Empty; //------------------------------------------------------------------CONTROL SWITCH---------------------------------------------------------- CINTERRUMPIR.Rule = interruptor + openpare + EXPRESION + closepare + opencorch + CASO + DEFECTO + closecorch; //------------------------------------------------------------------- CASE----------------------------------------------------------------- CASO.Rule = caso + numero + ":" + CUERPO + CASO | caso + id + ":" + CUERPO + CASO | Empty; //-------------------------------------------------------------------------DEFAULT------------------------------------------------------------ DEFECTO.Rule = defecto + ":" + CUERPO | Empty; //----------------------------------------------------------------------------WHILE----------------------------------------------------------------- CMIENTRAS.Rule = mientras + openpare + EXPRESION + closepare + opencorch + CUERPOME + closecorch; //-----------------------------------------------------------------------DO WHILE------------------------------------------------------------------- CHACER.Rule = hacer + opencorch + CUERPOME + closecorch + mientras + openpare + EXPRESION + closepare + puntocoma; //-----------------------------------------------------------------------BREAK---------------------------------------------------------------- SALIR.Rule = salir + puntocoma; //-----------------------------------------------------------------------EXPRESION----------------------------------------------------------------- EXPRESION.Rule = EXPRESION + or + EXPRESION | EXPRESION + and + EXPRESION | EXPRESION + igualigual + EXPRESION | EXPRESION + diferente + EXPRESION | EXPRESION + mayor + EXPRESION | EXPRESION + menor + EXPRESION | EXPRESION + mayorigual + EXPRESION | EXPRESION + menorigual + EXPRESION | EXPRESION + mas + EXPRESION | EXPRESION + menos + EXPRESION | EXPRESION + por + EXPRESION | EXPRESION + potencia + EXPRESION | EXPRESION + division + EXPRESION | openpare + EXPRESION + closepare | negacion + EXPRESION | id | numero | tString | tchar | trues | falses | RAIZZ | PARALLAMA; #endregion #region comentarios //---------------------> Comentarios CommentTerminal COMENTARIO_SIMPLE = new CommentTerminal("comentario_simple", "//", "\n", "\r\n"); CommentTerminal COMENTARIO_MULT = new CommentTerminal("comentario_mult", "/*", "*/"); NonGrammarTerminals.Add(COMENTARIO_SIMPLE); NonGrammarTerminals.Add(COMENTARIO_MULT); #endregion //---------------------> Definir Asociatividad RegisterOperators(1, Associativity.Left, "||"); //OR RegisterOperators(2, Associativity.Left, "&&"); //AND RegisterOperators(3, Associativity.Left, "==", "!="); //IGUAL, DIFERENTE RegisterOperators(4, Associativity.Left, ">", "<", ">=", "<="); //MAYORQUES, MENORQUES RegisterOperators(5, Associativity.Left, "+", "-"); //MAS, MENOS RegisterOperators(6, Associativity.Left, "*", "/"); //POR, DIVIDIR RegisterOperators(6, Associativity.Left, "^"); //POTENCIA RegisterOperators(7, Associativity.Right, "!"); //NOT //---------------------------------------------------MANEJO DE ERRORES------------------------------------------------------------------- ESTRUCTURA.ErrorRule = SyntaxError + ESTRUCTURA; ESTRUCTURA2.ErrorRule = SyntaxError + ESTRUCTURA2; ESTRUCTURAME.ErrorRule = SyntaxError + ESTRUCTURAME; }
public Gramatica1() : base(caseSensitive: false) { #region ER IdentifierTerminal tokId = new IdentifierTerminal("tokId", "_", ""); var tokNumero = TerminalFactory.CreateCSharpNumber("tokNumero"); StringLiteral tokCadena = new StringLiteral("tokenCadena", "\""); StringLiteral tokChar = new StringLiteral("tokenCaracter", "\'"); CommentTerminal comentLinea = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); CommentTerminal comentMulti = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(comentLinea); NonGrammarTerminals.Add(comentMulti); #endregion #region RESERVADAS MarkReservedWords("configuration"); MarkReservedWords("background"); MarkReservedWords("figure"); MarkReservedWords("design"); MarkReservedWords("x-nombre"); MarkReservedWords("x-imagen"); MarkReservedWords("x-tipo"); MarkReservedWords("x-vida"); MarkReservedWords("x-heroe"); MarkReservedWords("x-enemigo"); MarkReservedWords("x-destruir"); MarkReservedWords("x-descripcion"); MarkReservedWords("x-bomba"); MarkReservedWords("x-arma"); MarkReservedWords("x-creditos"); MarkReservedWords("x-meta"); MarkReservedWords("x-bloque"); MarkReservedWords("x-bonus"); MarkReservedWords("x-arma"); MarkReservedWords("x-bomba"); #endregion #region TERMINALES var tokConfig = ToTerm("configuration"); var tokBackground = ToTerm("background"); var tokFigure = ToTerm("figure"); var tokDesign = ToTerm("design"); var tokNombre = ToTerm("x-nombre"); var tokImagen = ToTerm("x-imagen"); var tokTipo = ToTerm("x-tipo"); var tokVida = ToTerm("x-vida"); var tokHero = ToTerm("x-heroe"); var tokEnemy = ToTerm("x-enemigo"); var tokDestruir = ToTerm("x-destruir"); var tokDescripcion = ToTerm("x-descripcion"); var tokBomba = ToTerm("x-bomba"); var tokArma = ToTerm("x-arma"); var tokCreditos = ToTerm("x-creditos"); var tokMeta = ToTerm("x-meta"); var tokBloque = ToTerm("x-bloque"); var tokBonus = ToTerm("x-bonus"); var tokDiv = ToTerm("/"); var tokAllave = ToTerm("{"); var tokCllave = ToTerm("}"); var tokComa = ToTerm(","); var tokPcoma = ToTerm(";"); var tokIgual = ToTerm("="); var tokMas = ToTerm("+"); var tokMenos = ToTerm("-"); var tokPor = ToTerm("*"); var tokApar = ToTerm("("); var tokCpar = ToTerm(")"); var tokAconf = ToTerm("<configuration>"); var tokCconf = ToTerm("</configuration>"); var tokAbackground = ToTerm("<background>"); var tokCbackground = ToTerm("</background>"); var tokAfigure = ToTerm("<figure>"); var tokCfigure = ToTerm("</figure>"); var tokAdesign = ToTerm("<design>"); var tokCdesign = ToTerm("</design>"); #endregion #region NO TERMINALES var START = new NonTerminal("START"); var BODIES = new NonTerminal("BODIES"); var BODY = new NonTerminal("BODY"); var LABELBACKGROUND = new NonTerminal("LABELBACKGROUND"); var BACKGROUNDS = new NonTerminal("BACKGROUNDS"); var BACKGROUND = new NonTerminal("BACKGROUND"); var BODIESBACKGROUND = new NonTerminal("BODIESBACKGROUND"); var BODYBACKGROUND = new NonTerminal("BODYBACKGROUND"); var LABELFIGURE = new NonTerminal("LABELFIGURE"); var FIGURES = new NonTerminal("FIGURES"); var FIGURE = new NonTerminal("FIGURE"); var FIGUREBODIES = new NonTerminal("FIGUREBODIES"); var FIGUREBODY = new NonTerminal("FIGUREBODY"); var LABELDESIGN = new NonTerminal("LABELDESIGN"); var FIGURETYPE = new NonTerminal("FIGURETYPE"); var FTYPE = new NonTerminal("FTYPE"); var NAME = new NonTerminal("NAME"); var SOURCE = new NonTerminal("SOURCE"); var DESCRIPTION = new NonTerminal("DESCRIPTION"); var LIFE = new NonTerminal("LIFE"); var DESTRUCTION = new NonTerminal("DESTRUCTION"); var HERO = new NonTerminal("HERO"); var HEROBODIES = new NonTerminal("HEROBODIES"); var HEROBODY = new NonTerminal("HEROBODY"); var HEROTYPE = new NonTerminal("HEROTYPE"); var ENEMY = new NonTerminal("ENEMY"); var ENEMYBODIES = new NonTerminal("ENEMYBODIES"); var ENEMYBODY = new NonTerminal("ENEMYBODY"); var ENEMYTYPE = new NonTerminal("ENEMYTYPE"); var DESIGN = new NonTerminal("DESIGN"); var DESIGNS = new NonTerminal("DESIGNS"); var DESIGNBODIES = new NonTerminal("DESIGNBODIES"); var DESIGNBODY = new NonTerminal("DESIGNBODY"); var DESIGNTYPE = new NonTerminal("DESIGNTYPE"); var DTYPE = new NonTerminal("DTYPE"); var FINISH = new NonTerminal("FINISH"); var FINISHTYPE = new NonTerminal("FINISHTYPE"); var BLOCK = new NonTerminal("BLOCK"); var BLOCKTYPE = new NonTerminal("BLOCKTYPE"); var BONUS = new NonTerminal("BONUS"); var BONUSTYPE = new NonTerminal("BONUSTYPE"); var POINTS = new NonTerminal("POINTS"); var WEAPON = new NonTerminal("WEAPON"); var WEAPONTYPE = new NonTerminal("WEAPONTYPE"); var WTYPE = new NonTerminal("TYPE"); var EXP = new NonTerminal("EXP"); #endregion #region GRAMATICA START.Rule = tokAconf + BODIES + tokCconf ; BODIES.Rule = MakePlusRule(BODIES, BODY) ; BODY.Rule = LABELBACKGROUND | LABELFIGURE | LABELDESIGN ; BODY.ErrorRule = SyntaxError + ">"; LABELBACKGROUND.Rule = tokAbackground + BACKGROUNDS + tokCbackground ; LABELFIGURE.Rule = tokAfigure + FIGURES + tokCfigure ; LABELDESIGN.Rule = tokAdesign + DESIGNS + tokCdesign ; BACKGROUNDS.Rule = MakePlusRule(BACKGROUNDS, tokComa, BACKGROUND) ; BACKGROUND.Rule = tokAllave + BODIESBACKGROUND + tokCllave ; BACKGROUND.ErrorRule = SyntaxError + "}"; BODIESBACKGROUND.Rule = MakeStarRule(BODIESBACKGROUND, BODYBACKGROUND) ; BODYBACKGROUND.Rule = NAME | SOURCE ; NAME.Rule = tokNombre + tokIgual + tokId + tokPcoma ; //NAME.ErrorRule = SyntaxError + ";"; SOURCE.Rule = tokImagen + tokIgual + tokCadena + tokPcoma ; //SOURCE.ErrorRule = SyntaxError + ";"; DESCRIPTION.Rule = tokDescripcion + tokIgual + tokCadena + tokPcoma ; //DESCRIPTION.ErrorRule = SyntaxError + ";"; LIFE.Rule = tokVida + tokIgual + EXP + tokPcoma ; //LIFE.ErrorRule = SyntaxError + ";"; DESTRUCTION.Rule = tokDestruir + tokIgual + EXP + tokPcoma ; //DESTRUCTION.ErrorRule = SyntaxError + ";"; FIGURES.Rule = MakePlusRule(FIGURES, tokComa, FIGURE) ; FIGURE.Rule = tokAllave + FIGUREBODIES + tokCllave ; FIGURE.ErrorRule = SyntaxError + "}"; FIGUREBODIES.Rule = MakePlusRule(FIGUREBODIES, FIGUREBODY) ; FIGUREBODY.Rule = NAME | SOURCE | LIFE | DESCRIPTION | DESTRUCTION | FIGURETYPE ; FIGURETYPE.Rule = tokTipo + tokIgual + FTYPE + tokPcoma ; FIGURETYPE.ErrorRule = SyntaxError + ";"; FTYPE.Rule = tokHero | tokEnemy ; EXP.Rule = EXP + tokMas + EXP | EXP + tokMenos + EXP | EXP + tokPor + EXP | EXP + "/" + EXP | tokNumero | tokApar + EXP + tokCpar | tokMenos + EXP ; DESIGNS.Rule = MakePlusRule(DESIGNS, tokComa, DESIGN) ; DESIGN.Rule = tokAllave + DESIGNBODIES + tokCllave ; DESIGN.ErrorRule = SyntaxError + "}"; DESIGNBODIES.Rule = MakePlusRule(DESIGNBODIES, DESIGNBODY) ; DESIGNBODY.Rule = NAME | SOURCE | POINTS | DESTRUCTION | DESIGNTYPE ; POINTS.Rule = tokCreditos + tokIgual + EXP + tokPcoma ; POINTS.ErrorRule = SyntaxError + ";"; DESIGNTYPE.Rule = tokTipo + tokIgual + DTYPE + tokPcoma ; DESIGNTYPE.ErrorRule = SyntaxError + ";"; DTYPE.Rule = tokMeta | tokBloque | tokBonus | tokBomba | tokArma ; RegisterOperators(1, Associativity.Left, tokMas, tokMenos); RegisterOperators(2, Associativity.Left, tokPor, tokDiv); RegisterOperators(3, "-()"); RegisterOperators(4, tokApar + tokCpar); this.MarkPunctuation(";", "{", "}", "(", ")", tokAconf.Text, tokAfigure.Text, tokAbackground.Text, tokAdesign.Text, tokCconf.Text, tokCfigure.Text, tokCbackground.Text, tokCdesign.Text); this.MarkTransient(BACKGROUND, BODYBACKGROUND, FIGUREBODY, DESIGNBODY, FTYPE, DTYPE, BODY, FIGURE, DESIGN, LABELBACKGROUND, LABELDESIGN, LABELFIGURE); this.Root = START; #endregion }
public void TestNumber_CSharp() { Parser parser; Token token; double eps = 0.0001; parser = TestHelper.CreateParser(TerminalFactory.CreateCSharpNumber("Number")); //Simple integers and suffixes token = parser.ParseInput("123 "); CheckType(token, typeof(int)); Assert.True(token.Details != null, "ScanDetails object not found in token."); Assert.True((int)token.Value == 123, "Failed to read int value"); token = parser.ParseInput(Int32.MaxValue.ToString()); CheckType(token, typeof(int)); Assert.True((int)token.Value == Int32.MaxValue, "Failed to read Int32.MaxValue."); token = parser.ParseInput(UInt64.MaxValue.ToString()); CheckType(token, typeof(ulong)); Assert.True((ulong)token.Value == UInt64.MaxValue, "Failed to read uint64.MaxValue value"); token = parser.ParseInput("123U "); CheckType(token, typeof(UInt32)); Assert.True((UInt32)token.Value == 123, "Failed to read uint value"); token = parser.ParseInput("123L "); CheckType(token, typeof(long)); Assert.True((long)token.Value == 123, "Failed to read long value"); token = parser.ParseInput("123uL "); CheckType(token, typeof(ulong)); Assert.True((ulong)token.Value == 123, "Failed to read ulong value"); //Hex representation token = parser.ParseInput("0x012 "); CheckType(token, typeof(Int32)); Assert.True((Int32)token.Value == 0x012, "Failed to read hex int value"); token = parser.ParseInput("0x12U "); CheckType(token, typeof(UInt32)); Assert.True((UInt32)token.Value == 0x012, "Failed to read hex uint value"); token = parser.ParseInput("0x012L "); CheckType(token, typeof(long)); Assert.True((long)token.Value == 0x012, "Failed to read hex long value"); token = parser.ParseInput("0x012uL "); CheckType(token, typeof(ulong)); Assert.True((ulong)token.Value == 0x012, "Failed to read hex ulong value"); //Floating point types token = parser.ParseInput("123.4 "); CheckType(token, typeof(double)); Assert.True(Math.Abs((double)token.Value - 123.4) < eps, "Failed to read double value #1"); token = parser.ParseInput("1234e-1 "); CheckType(token, typeof(double)); Assert.True(Math.Abs((double)token.Value - 1234e-1) < eps, "Failed to read double value #2"); token = parser.ParseInput("12.34e+01 "); CheckType(token, typeof(double)); Assert.True(Math.Abs((double)token.Value - 123.4) < eps, "Failed to read double value #3"); token = parser.ParseInput("0.1234E3 "); CheckType(token, typeof(double)); Assert.True(Math.Abs((double)token.Value - 123.4) < eps, "Failed to read double value #4"); token = parser.ParseInput("123.4f "); CheckType(token, typeof(float)); Assert.True(Math.Abs((Single)token.Value - 123.4) < eps, "Failed to read float(single) value"); token = parser.ParseInput("123.4m "); CheckType(token, typeof(decimal)); Assert.True(Math.Abs((decimal)token.Value - 123.4m) < Convert.ToDecimal(eps), "Failed to read decimal value"); token = parser.ParseInput("123. ", useTerminator: false); //should ignore dot and read number as int. compare it to python numbers - see below CheckType(token, typeof(int)); Assert.True((int)token.Value == 123, "Failed to read int value with trailing dot"); //Quick parse token = parser.ParseInput("1 "); CheckType(token, typeof(int)); //When going through quick parse path (for one-digit numbers), the NumberScanInfo record is not created and hence is absent in Attributes Assert.True(token.Details == null, "Quick parse test failed: ScanDetails object is found in token - quick parse path should not produce this object."); Assert.True((int)token.Value == 1, "Failed to read quick-parse value"); }
public ScriptdotnetGrammar(bool expressionGrammar) { #region 1. Terminals NumberLiteral n = TerminalFactory.CreateCSharpNumber("number"); IdentifierTerminal v = CreateScriptNetIdentifier("Identifier"); Terminal s = CreateScriptNetString("string"); Terminal @is = Symbol("is"); Terminal dot = Symbol(".", "dot"); Terminal less = Symbol("<"); Terminal greater = Symbol(">"); Terminal arrow = Symbol("->"); Terminal LSb = Symbol("["); Terminal RSb = Symbol("]"); Terminal LCb = Symbol("("); Terminal RCb = Symbol(")"); Terminal RFb = Symbol("}"); Terminal LFb = Symbol("{"); Terminal LMb = Symbol("<!"); Terminal RMb = Symbol("!>"); Terminal LGb = Symbol("<|"); Terminal RGb = Symbol("|>"); Terminal comma = Symbol(","); Terminal semicolon = Symbol(";"); Terminal colon = Symbol(":"); #endregion #region 2. Non-terminals #region 2.1 Expressions NonTerminal Expr = new NonTerminal("Expr", typeof(ScriptExpr)); NonTerminal ConstExpr = new NonTerminal("ConstExpr", typeof(ScriptConstExpr)); NonTerminal BinExpr = new NonTerminal("BinExpr", typeof(ScriptBinExpr)); NonTerminal UnaryExpr = new NonTerminal("UnaryExpr", typeof(ScriptUnaryExpr)); NonTerminal AssignExpr = new NonTerminal("AssignExpr", typeof(ScriptAssignExpr)); NonTerminal TypeConvertExpr = new NonTerminal("TypeConvertExpr", typeof(ScriptTypeConvertExpr)); NonTerminal IsExpr = new NonTerminal("IsExpr", typeof(ScriptIsExpr)); NonTerminal MetaExpr = new NonTerminal("MetaExpr", typeof(ScriptMetaExpr)); NonTerminal FuncDefExpr = new NonTerminal("FuncDefExpr", typeof(ScriptFunctionDefinition)); //typeof(ScriptFunctionDefExpression)); NonTerminal TypeExpr = new NonTerminal("TypeExpr", typeof(ScriptTypeExpr)); NonTerminal TypeConstructor = new NonTerminal("TypeConstructor", typeof(ScriptTypeConstructor)); NonTerminal FunctionCall = new NonTerminal("FunctionCall", typeof(ScriptFunctionCall)); NonTerminal ArrayResolution = new NonTerminal("ArrayResolution", typeof(ScriptArrayResolution)); NonTerminal BinOp = new NonTerminal("BinOp"); NonTerminal LUnOp = new NonTerminal("LUnOp"); NonTerminal RUnOp = new NonTerminal("RUnOp"); NonTerminal ArrayConstructor = new NonTerminal("ArrayConstructor", typeof(ScriptArrayConstructor)); NonTerminal MObjectConstructor = new NonTerminal("MObjectConstructor", typeof(ScriptMObject)); NonTerminal MObjectPart = new NonTerminal("MObjectPart", typeof(ScriptMObjectPart)); NonTerminal MObjectParts = new NonTerminal("MObjectPart", typeof(ScriptAst)); NonTerminal TypeList = new NonTerminal("TypeList", typeof(ScriptTypeExprList)); #endregion #region 2.2 QualifiedName //Expression List: expr1, expr2, expr3, .. NonTerminal ExprList = new NonTerminal("ExprList", typeof(ScriptExprList)); //A name in form: a.b.c().d[1,2].e .... NonTerminal NewStmt = new NonTerminal("NewStmt", typeof(ScriptNewStmt)); NonTerminal NewArrStmt = new NonTerminal("NewArrStmt", typeof(ScriptNewArrStmt)); NonTerminal QualifiedName = new NonTerminal("QualifiedName", typeof(ScriptQualifiedName)); NonTerminal GenericsPostfix = new NonTerminal("GenericsPostfix", typeof(ScriptGenericsPostfix)); NonTerminal GlobalList = new NonTerminal("GlobalList", typeof(ScriptGlobalList)); #endregion #region 2.3 Statement NonTerminal Condition = new NonTerminal("Condition", typeof(ScriptCondition)); NonTerminal Statement = new NonTerminal("Statement", typeof(ScriptStatement)); NonTerminal IfStatement = new NonTerminal("IfStatement", typeof(ScriptIfStatement)); NonTerminal WhileStatement = new NonTerminal("WhileStatement", typeof(ScriptWhileStatement)); NonTerminal ForStatement = new NonTerminal("ForStatement", typeof(ScriptForStatement)); NonTerminal ForEachStatement = new NonTerminal("ForEachStatement", typeof(ScriptForEachStatement)); NonTerminal OptionalExpression = new NonTerminal("OptionalExpression", typeof(ScriptExpr)); NonTerminal SwitchStatement = new NonTerminal("SwitchStatement", typeof(ScriptStatement)); NonTerminal SwitchStatements = new NonTerminal("SwitchStatements", typeof(ScriptSwitchStatement)); NonTerminal SwitchCaseStatement = new NonTerminal("SwitchCaseStatement", typeof(ScriptSwitchCaseStatement)); NonTerminal SwitchDefaultStatement = new NonTerminal("SwitchDefaultStatement", typeof(ScriptSwitchDefaultStatement)); NonTerminal UsingStatement = new NonTerminal("UsingStatement", typeof(ScriptUsingStatement)); NonTerminal TryCatchFinallyStatement = new NonTerminal("TryCatchFinallyStatement", typeof(ScriptTryCatchFinallyStatement)); NonTerminal FlowControlStatement = new NonTerminal("FlowControl", typeof(ScriptFlowControlStatement)); NonTerminal ExprStatement = new NonTerminal("ExprStatement", typeof(ScriptStatement)); //Block NonTerminal BlockStatement = new NonTerminal("BlockStatement", typeof(ScriptStatement)); NonTerminal Statements = new NonTerminal("Statements(Compound)", typeof(ScriptCompoundStatement)); #endregion #region 2.4 Program and Functions NonTerminal Prog = new NonTerminal("Prog", typeof(ScriptProg)); NonTerminal Element = new NonTerminal("Element", typeof(ScriptAst)); NonTerminal Elements = new NonTerminal("Elements", typeof(ScriptElements)); NonTerminal FuncDef = new NonTerminal("FuncDef", typeof(ScriptFunctionDefinition)); NonTerminal FuncContract = new NonTerminal("FuncContract", typeof(ScriptFuncContract)); NonTerminal ParameterList = new NonTerminal("ParamaterList", typeof(ScriptFuncParameters)); NonTerminal FuncContractPre = new NonTerminal("Pre Conditions", typeof(ScriptFuncContractPre)); NonTerminal FuncContractPost = new NonTerminal("Post Conditions", typeof(ScriptFuncContractPost)); NonTerminal FuncContractInv = new NonTerminal("Invariant Conditions", typeof(ScriptFuncContractInv)); #endregion #endregion #region 3. BNF rules #region 3.1 Expressions ConstExpr.Rule = Symbol("true") | "false" | "null" | s | n; BinExpr.Rule = Expr + BinOp + Expr | IsExpr; UnaryExpr.Rule = LUnOp + Expr; IsExpr.Rule = Expr + @is + TypeExpr; TypeConvertExpr.Rule = LCb + Expr + RCb + Expr.Q(); AssignExpr.Rule = QualifiedName + "=" + Expr | QualifiedName + "++" | QualifiedName + "--" | QualifiedName + ":=" + Expr | QualifiedName + "+=" + Expr | QualifiedName + "-=" + Expr; //TODO: MetaFeatures; // <[ ] + > because of conflict a[1]>2 MetaExpr.Rule = LMb + Elements + RMb; GlobalList.Rule = "global" + LCb + ParameterList + RCb; FuncDefExpr.Rule = "function" + LCb + ParameterList + RCb + GlobalList.Q() + FuncContract.Q() + BlockStatement; Expr.Rule = ConstExpr | BinExpr | UnaryExpr | QualifiedName | AssignExpr | NewStmt | FuncDefExpr | NewArrStmt | ArrayConstructor | MObjectConstructor | TypeConvertExpr | MetaExpr ; NewStmt.Rule = "new" + TypeConstructor; NewArrStmt.Rule = "new" + TypeExpr + ArrayResolution; BinOp.Rule = Symbol("+") | "-" | "*" | "/" | "%" | "^" | "&" | "|" | "&&" | "||" | "==" | "!=" | greater | less | ">=" | "<="; LUnOp.Rule = Symbol("~") | "-" | "!" | "$"; ArrayConstructor.Rule = LSb + ExprList + RSb; MObjectPart.Rule = v + arrow + Expr; MObjectParts.Rule = MakePlusRule(MObjectParts, comma, MObjectPart); MObjectConstructor.Rule = LSb + MObjectParts + RSb; OptionalExpression.Rule = Expr.Q(); #endregion #region 3.2 QualifiedName TypeExpr.Rule = //MakePlusRule(TypeExpr, dot, v); v + GenericsPostfix.Q() | TypeExpr + dot + (v + GenericsPostfix.Q()); GenericsPostfix.Rule = LGb + TypeList + RGb; FunctionCall.Rule = LCb + ExprList.Q() + RCb; ArrayResolution.Rule = LSb + ExprList + RSb; QualifiedName.Rule = v + (GenericsPostfix | ArrayResolution | FunctionCall).Star() | QualifiedName + dot + v + (GenericsPostfix | ArrayResolution | FunctionCall).Star(); ExprList.Rule = MakePlusRule(ExprList, comma, Expr); TypeList.Rule = MakePlusRule(TypeList, comma, TypeExpr); TypeConstructor.Rule = TypeExpr + FunctionCall; #endregion #region 3.3 Statement Condition.Rule = LCb + Expr + RCb; IfStatement.Rule = "if" + Condition + Statement + ("else" + Statement).Q(); WhileStatement.Rule = "while" + Condition + Statement; ForStatement.Rule = "for" + LCb + OptionalExpression + semicolon + OptionalExpression + semicolon + OptionalExpression + RCb + Statement; ForEachStatement.Rule = "foreach" + LCb + v + "in" + Expr + RCb + Statement; UsingStatement.Rule = "using" + LCb + Expr + RCb + BlockStatement; TryCatchFinallyStatement.Rule = "try" + BlockStatement + "catch" + LCb + v + RCb + BlockStatement + "finally" + BlockStatement; SwitchStatement.Rule = "switch" + LCb + Expr + RCb + LFb + SwitchStatements + RFb; ExprStatement.Rule = Expr + semicolon; FlowControlStatement.Rule = "break" + semicolon | "continue" + semicolon | "return" + Expr + semicolon | "throw" + Expr + semicolon; Statement.Rule = semicolon | IfStatement //1. If | WhileStatement //2. While | ForStatement //3. For | ForEachStatement //4. ForEach | UsingStatement //5. Using | SwitchStatement //6. Switch | BlockStatement //7. Block | TryCatchFinallyStatement //8. TryCatch | ExprStatement //9. Expr | FlowControlStatement; //10. FlowControl Statements.SetOption(TermOptions.IsList); Statements.Rule = Statements + Statement | Empty; BlockStatement.Rule = LFb + Statements + RFb; SwitchStatements.Rule = SwitchCaseStatement.Star() + SwitchDefaultStatement.Q(); SwitchCaseStatement.Rule = Symbol("case") + Expr + colon + Statements; SwitchDefaultStatement.Rule = "default" + colon + Statements; #endregion #region 3.4 Prog FuncContract.Rule = LSb + FuncContractPre + semicolon + FuncContractPost + semicolon + FuncContractInv + semicolon + RSb; FuncContractPre.Rule = "pre" + LCb + ExprList.Q() + RCb; FuncContractPost.Rule = "post" + LCb + ExprList.Q() + RCb; FuncContractInv.Rule = "invariant" + LCb + ExprList.Q() + RCb; ParameterList.Rule = MakeStarRule(ParameterList, comma, v); FuncDef.Rule = "function" + v + LCb + ParameterList + RCb + GlobalList.Q() + FuncContract.Q() + BlockStatement; Element.Rule = Statement | FuncDef; Elements.SetOption(TermOptions.IsList); Elements.Rule = Elements + Element | Empty; Prog.Rule = Elements + Eof; Terminal Comment = new CommentTerminal("Comment", "/*", "*/"); NonGrammarTerminals.Add(Comment); Terminal LineComment = new CommentTerminal("LineComment", "//", "\n"); NonGrammarTerminals.Add(LineComment); #endregion #endregion #region 4. Set starting symbol if (!expressionGrammar) { Root = Prog; // Set grammar root } else { Root = Expr; } #endregion #region 5. Operators precedence RegisterOperators(1, "=", "+=", "-=", ":="); RegisterOperators(2, "|", "||"); RegisterOperators(3, "&", "&&"); RegisterOperators(4, "==", "!=", ">", "<", ">=", "<="); RegisterOperators(5, "is"); RegisterOperators(6, "+", "-"); RegisterOperators(7, "*", "/", "%"); RegisterOperators(8, Associativity.Right, "^"); RegisterOperators(9, "~", "!", "$", "++", "--"); RegisterOperators(10, "."); //RegisterOperators(10, Associativity.Right, ".",",", ")", "(", "]", "[", "{", "}"); //RegisterOperators(11, Associativity.Right, "else"); #endregion #region 6. Punctuation symbols RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";"); #endregion }
public GrammarP1() : base(caseSensitive: true) { /*************** Comentarios ***************/ //No hay :D /*************** Reservados ***************/ MarkReservedWords("CONJ"); MarkReservedWords("RESERV"); MarkReservedWords("retorno"); MarkReservedWords("yytext"); MarkReservedWords("yyline"); MarkReservedWords("yyrow"); MarkReservedWords("error"); MarkReservedWords("int"); MarkReservedWords("float"); MarkReservedWords("string"); MarkReservedWords("char"); MarkReservedWords("bool"); var conj = ToTerm("CONJ"); var reserv = ToTerm("RESERV"); var retorno = ToTerm("retorno"); var yytext = ToTerm("yytext"); var yyline = ToTerm("yyline"); var yyrow = ToTerm("yyrow"); var rerror = ToTerm("error"); var rint = ToTerm("int"); var rfloat = ToTerm("float"); var rstring = ToTerm("string"); var rchar = ToTerm("char"); var rbool = ToTerm("bool"); var flecha = ToTerm("->"); var fin = ToTerm(";"); var dosp = ToTerm(":"); var coma = ToTerm(","); var apar = ToTerm("("); var cpar = ToTerm(")"); var acor = ToTerm("["); var ccor = ToTerm("]"); var and = ToTerm("."); var or = ToTerm("|"); var muchos = ToTerm("+"); var nada_muchos = ToTerm("*"); var nada = ToTerm("?"); //var barra = ToTerm("\\"); var salto = ToTerm("\\n"); var retorno_carro = ToTerm("\\r"); var tab = ToTerm("\\t"); var comillas_s = ToTerm("\\'"); var comillas_d = ToTerm("\\\""); var blanco = ToTerm("[:blanco:]"); var todo = ToTerm("[:todo:]"); /*************** No Terminales ***************/ var INICIO = new NonTerminal("INICIO", typeof(AstNode)); var CUERPO = new NonTerminal("CUERPO", typeof(AstNode)); var CODIGO = new NonTerminal("CODIGO", typeof(AstNode)); var SENTENCIA = new NonTerminal("SENTENCIA", typeof(AstNode)); var CONJUNTO = new NonTerminal("CONJUNTO", typeof(AstNode)); var SERIE = new NonTerminal("SERIE", typeof(AstNode)); var SERIE2 = new NonTerminal("SERIE2", typeof(AstNode)); var LISTA = new NonTerminal("LISTA", typeof(AstNode)); var SIMBOLO = new NonTerminal("SIMBOLO", typeof(AstNode)); var REGLA = new NonTerminal("REGLA", typeof(AstNode)); var METODO = new NonTerminal("METODO", typeof(AstNode)); var ER = new NonTerminal("ER", typeof(AstNode)); var ESCAPE = new NonTerminal("ESCAPE", typeof(AstNode)); var M1 = new NonTerminal("M1", typeof(AstNode)); var M2 = new NonTerminal("M2", typeof(AstNode)); var TIPO = new NonTerminal("TIPO", typeof(AstNode)); var RERROR = new NonTerminal("ERROR", typeof(AstNode)); var RESERVAR = new NonTerminal("RESERVAR", typeof(AstNode)); var RESERVADAS = new NonTerminal("RESERVADAS", typeof(AstNode)); var RESERVADA = new NonTerminal("RESERVADA", typeof(AstNode)); /*************** Terminales ***************/ NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero"); IdentifierTerminal id = TerminalFactory.CreateCSharpIdentifier("id"); var tstring = new StringLiteral("tstring", "\"", StringOptions.AllowsDoubledQuote); var tchar = new StringLiteral("tchar", "'", StringOptions.AllowsDoubledQuote); RegexBasedTerminal ascii = new RegexBasedTerminal("ascii", "[^\008\009\010\011\013\020\024\032\034\039\092\096\0239\0249]"); //AstNode numero.AstConfig.NodeType = typeof(AstNode); id.AstConfig.NodeType = typeof(AstNode); tstring.AstConfig.NodeType = typeof(AstNode); tchar.AstConfig.NodeType = typeof(AstNode); ascii.AstConfig.NodeType = typeof(AstNode); /*************** Gramatica ***************/ this.Root = INICIO; INICIO.Rule = CUERPO; CUERPO.Rule = ToTerm("%%") + CODIGO + ToTerm("%%"); CODIGO.Rule = MakeStarRule(CODIGO, SENTENCIA); SENTENCIA.Rule = CONJUNTO | REGLA | RERROR; CONJUNTO.Rule = conj + dosp + id + flecha + SERIE + fin | conj + dosp + id + flecha + LISTA + fin; //SERIE.Rule = SIMBOLO + ToTerm("~") + SIMBOLO; //SERIE.Rule = SERIE2; SERIE.Rule = SIMBOLO + ToTerm("~") + SIMBOLO; LISTA.Rule = MakeStarRule(LISTA, coma, SIMBOLO); SIMBOLO.Rule = SERIE | ESCAPE | numero | tstring | tchar | id | ascii; REGLA.Rule = id + flecha + ER + flecha + METODO + fin | id + flecha + ER + flecha + METODO + flecha + RESERVAR + fin | id + flecha + ER + flecha + METODO + fin + flecha + RESERVAR + fin; ER.Rule = ER + ER + and | ER + ER + or | ER + muchos | ER + nada_muchos | ER + nada | ESCAPE | tstring | tchar | numero | id; ESCAPE.Rule = salto | retorno_carro | tab | comillas_s | comillas_d | blanco | todo; /*ESCAPE.Rule = barra+ToTerm("n") | barra + ToTerm("r") | barra + ToTerm("t") | barra + ToTerm("'") | barra + ToTerm("\"") | blanco | todo;*/ METODO.Rule = M1 | M2; RESERVAR.Rule = reserv + acor + RESERVADAS + ccor; RESERVADAS.Rule = MakeStarRule(RESERVADAS, RESERVADA); RESERVADA.Rule = tstring + flecha + retorno + apar + id + coma + yyline + coma + yyrow + cpar + fin | id + flecha + retorno + apar + id + coma + yyline + coma + yyrow + cpar + fin; M1.Rule = retorno + apar + id + coma + yyline + coma + yyrow + cpar; M2.Rule = retorno + apar + id + coma + yytext + coma + TIPO + coma + yyline + coma + yyrow + cpar; TIPO.Rule = rint | rfloat | rstring | rchar | rbool; RERROR.Rule = rerror + flecha + ER + flecha + rerror + apar + yyline + coma + yyrow + coma + yytext + cpar + fin | id + flecha + ER + flecha + rerror + apar + yyline + coma + yyrow + coma + yytext + cpar + fin; /*************** Precedencia y Asociatividad ***************/ //RegisterOperators(1, or, and); //RegisterOperators(2, muchos, nada_muchos, nada); /*************** Errores ***************/ CODIGO.ErrorRule = SyntaxError + CODIGO; LISTA.ErrorRule = SyntaxError + LISTA; RESERVADAS.ErrorRule = SyntaxError + RESERVADAS; /*************** Eliminación ***************/ this.MarkPunctuation("%%", "->", ":", ";", ",", "~", "(", ")", "[", "]", "CONJ", "RESERV", "retorno"); this.MarkTransient(CUERPO, SENTENCIA, SIMBOLO, RESERVAR, METODO, TIPO); LanguageFlags = LanguageFlags.CreateAst; }
///-------------------------------------------------------------------------------- /// <summary>The default constructor sets up the overall grammar.</summary> /// /// <param name="solution">The solution containing model structure to add to the grammar.</param> ///-------------------------------------------------------------------------------- public CodeTemplateContentGrammar(Solution solution) { bool isFirstItem = true; this.LanguageFlags |= LanguageFlags.CreateAst; this.GrammarComments = "This grammar is used to parse the CONTENT section of an M+ code template."; #region "Literals, Symbols, Operators, Punctuation, etc." // literals StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral"); NumberLiteral Number = TerminalFactory.CreateCSharpNumber("Number"); Number.Options |= NumberOptions.AllowSign; IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier"); // symbols KeyTerm textOpen = ToTerm(LanguageTerms.TextOpenTag); KeyTerm evalOpen = ToTerm(LanguageTerms.EvalOpenTag); KeyTerm outputOpen = ToTerm(LanguageTerms.OutputOpenTag); KeyTerm propOpen = ToTerm(LanguageTerms.PropOpenTag); KeyTerm close = ToTerm(LanguageTerms.CloseTag); KeyTerm dot = ToTerm("."); KeyTerm comma = ToTerm(","); KeyTerm Lbr = ToTerm("{"); KeyTerm Rbr = ToTerm("}"); KeyTerm Lpar = ToTerm("("); KeyTerm Rpar = ToTerm(")"); KeyTerm slash = ToTerm("/"); // operators RegisterOperators(1, "||"); RegisterOperators(2, "&&"); RegisterOperators(3, "==", "!="); RegisterOperators(4, "<", ">", "<=", ">="); RegisterOperators(5, "."); RegisterOperators(6, "+", "-", "*", "/"); // delimiters and punctuation this.Delimiters = "{}[](),:;+-*/%&|^!~<>="; this.MarkPunctuation("=", ";", ",", "(", ")", "{", "}", ".", LanguageTerms.ProgressTerm, LanguageTerms.TraceTerm, LanguageTerms.DebugTerm, LanguageTerms.WhileTerm, LanguageTerms.VarTerm, LanguageTerms.ParamTerm, LanguageTerms.IfTerm, LanguageTerms.ElseTerm, LanguageTerms.WithTerm, LanguageTerms.ForeachTerm, LanguageTerms.BreakTerm, LanguageTerms.ContinueTerm, LanguageTerms.ClearTerm, LanguageTerms.ReturnTerm, LanguageTerms.SwitchTerm, LanguageTerms.CaseTerm, LanguageTerms.DefaultTerm, LanguageTerms.WhereTerm, LanguageTerms.InTerm, LanguageTerms.LimitTerm, LanguageTerms.SortTerm, LanguageTerms.FromTerm, LanguageTerms.TextOpenTag, LanguageTerms.EvalOpenTag, LanguageTerms.OutputOpenTag, LanguageTerms.PropOpenTag, LanguageTerms.CloseTag); // whitespace and line terminators this.LineTerminators = "\r\n\u2085\u2028\u2029"; this.WhitespaceChars = " \t\r\n\v\u2085\u2028\u2029"; // comments CommentTerminal singleLineComment = new CommentTerminal("singleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); CommentTerminal delimitedComment = new CommentTerminal("delimitedComment", "/*", "*/"); TextTerminal templateText = new TextTerminal("templateText", "<%%-", "%%>"); NonGrammarTerminals.Add(singleLineComment); NonGrammarTerminals.Add(delimitedComment); #endregion #region "Nodes" // high level nodes var template = new NonTerminal("template", typeof(TemplateNode)); var templateBlock = new NonTerminal("templateBlock"); // statements var statementList = new NonTerminal("statementList", typeof(StatementListNode)); var statement = new NonTerminal("statement"); var ifStatement = new NonTerminal("ifStatement", typeof(IfStatementNode)); var switchStatement = new NonTerminal("switchStatement", typeof(SwitchStatementNode)); var foreachStatement = new NonTerminal("foreachStatement", typeof(ForeachStatementNode)); var whileStatement = new NonTerminal("whileStatement", typeof(WhileStatementNode)); var withStatement = new NonTerminal("withStatement", typeof(WithStatementNode)); var breakStatement = new NonTerminal("breakStatement", typeof(BreakStatementNode)); var clearStatement = new NonTerminal("clearStatement", typeof(ClearTextStatementNode)); var returnStatement = new NonTerminal("returnStatement", typeof(ReturnStatementNode)); var continueStatement = new NonTerminal("continueStatement", typeof(ContinueStatementNode)); var currentItemAssignmentStatement = new NonTerminal("currentItemAssignmentStatement", typeof(CurrentItemAssignmentStatementNode)); var templatePropertyAssignmentStatement = new NonTerminal("templatePropertyAssignmentStatement", typeof(TemplatePropertyAssignmentStatementNode)); var debugStatement = new NonTerminal("debugStatement", typeof(DebugStatementNode)); var traceStatement = new NonTerminal("traceStatement", typeof(TraceStatementNode)); var logStatement = new NonTerminal("logStatement", typeof(LogStatementNode)); var progressStatement = new NonTerminal("progressStatement", typeof(ProgressStatementNode)); var varStatement = new NonTerminal("varStatement", typeof(VarStatementNode)); var paramStatement = new NonTerminal("paramStatement", typeof(ParamStatementNode)); var assignmentStatement = new NonTerminal("assignmentStatement", typeof(AssignmentStatementNode)); // clauses var elseClause = new NonTerminal("elseClause", typeof(ElseClauseNode)); var elseIfList = new NonTerminal("elseIfList", typeof(ElseIfListNode)); var elseIfClause = new NonTerminal("elseIfClause", typeof(ElseIfClauseNode)); var caseList = new NonTerminal("caseList", typeof(CaseListNode)); var caseClause = new NonTerminal("caseClause", typeof(CaseClauseNode)); var defaultClause = new NonTerminal("defaultClause", typeof(DefaultClauseNode)); var caseConditionList = new NonTerminal("caseConditionList", typeof(CaseConditionListNode)); var caseCondition = new NonTerminal("caseCondition", typeof(CaseConditionNode)); var foreachClause = new NonTerminal("foreachClause", typeof(ForeachClauseNode)); var whereClause = new NonTerminal("whereClause", typeof(WhereClauseNode)); var inClause = new NonTerminal("inClause", typeof(InClauseNode)); var limitClause = new NonTerminal("limitClause", typeof(LimitClauseNode)); var sortClause = new NonTerminal("sortClause", typeof(SortClauseNode)); var sortDirectionClause = new NonTerminal("sortDirectionClause", typeof(SortDirectionClauseNode)); var fromClause = new NonTerminal("fromClause", typeof(FromClauseNode)); var templateParameterList = new NonTerminal("templateParameterList", typeof(TemplateParameterListNode)); var templateParameter = new NonTerminal("templateParameter", typeof(TemplateParameterNode)); // expressions var expression = new NonTerminal("expression", typeof(ExpressionNode)); var binOp = new NonTerminal("binOp", "operator symbol", typeof(BinaryOperatorNode)); var mathOp = new NonTerminal("mathOp", "operator symbol", typeof(MathOperatorNode)); var literal = new NonTerminal("literal", typeof(LiteralNode)); var popContext = new NonTerminal("popContext", typeof(PopContextNode)); var thisContext = new NonTerminal("thisContext", typeof(ThisContextNode)); // properties var property = new NonTerminal("property"); var contentProperty = new NonTerminal("contentProperty"); var templateProperty = new NonTerminal("templateProperty", typeof(TemplatePropertyNode)); var inClauseItem = new NonTerminal("inClauseItem", typeof(InClauselItemNode)); var modelContext = new NonTerminal("modelContext", typeof(ModelContextNode)); var currentItem = new NonTerminal("currentItem", typeof(CurrentItemNode)); var modelProperty = new NonTerminal("modelProperty", typeof(ModelPropertyNode)); var assignableProperty = new NonTerminal("assignableProperty", typeof(AssignablePropertyNode)); var configurationProperty = new NonTerminal("configurationProperty", typeof(ConfigurationPropertyNode)); var contextHelper = new NonTerminal("contextHelper", typeof(ContextHelperNode)); var collectionHelper = new NonTerminal("collectionHelper", typeof(CollectionHelperNode)); var parameter = new NonTerminal("parameter", typeof(ParameterNode)); #endregion #region "Rules" // a template consists of any number of template blocks template.Rule = MakeStarRule(template, null, templateBlock); // a template block is a property or an evaluation (a statement list surrounded by eval tags) templateBlock.Rule = property | evalOpen + statementList + close; // a statement list consists of any number of statements statementList.Rule = MakeStarRule(statementList, null, statement); // a statement can be an if, switch, foreach, with, or a property statement.Rule = ifStatement | switchStatement | foreachStatement | whileStatement | withStatement | breakStatement | continueStatement | clearStatement | returnStatement | currentItemAssignmentStatement | templatePropertyAssignmentStatement | traceStatement | logStatement | varStatement | paramStatement | assignmentStatement | property | progressStatement; // var statement varStatement.Rule = ToTerm(LanguageTerms.VarTerm) + identifier | ToTerm(LanguageTerms.VarTerm) + identifier + "=" + parameter; // param statement paramStatement.Rule = ToTerm(LanguageTerms.ParamTerm) + identifier; // assignment statement assignmentStatement.Rule = identifier + "=" + parameter; // if statement ifStatement.Rule = ToTerm(LanguageTerms.IfTerm) + Lpar + expression + Rpar + Lbr + statementList + Rbr + elseIfList + elseClause; elseIfList.Rule = MakeStarRule(elseIfList, null, elseIfClause); elseIfClause.Rule = ToTerm(LanguageTerms.ElseTerm) + LanguageTerms.IfTerm + Lpar + expression + Rpar + Lbr + statementList + Rbr; elseClause.Rule = Empty | ToTerm(LanguageTerms.ElseTerm) + Lbr + statementList + Rbr; // break and return statements, etc. breakStatement.Rule = ToTerm(LanguageTerms.BreakTerm); continueStatement.Rule = ToTerm(LanguageTerms.ContinueTerm); clearStatement.Rule = ToTerm(LanguageTerms.ClearTerm); returnStatement.Rule = ToTerm(LanguageTerms.ReturnTerm); popContext.Rule = dot + dot + slash; thisContext.Rule = ToTerm(LanguageTerms.ThisTerm); // switch statement switchStatement.Rule = ToTerm(LanguageTerms.SwitchTerm) + Lpar + modelProperty + Rpar + Lbr + caseList + defaultClause + Rbr; caseList.Rule = MakePlusRule(caseList, null, caseClause); caseClause.Rule = caseConditionList + statementList + breakStatement; defaultClause.Rule = Empty | ToTerm(LanguageTerms.DefaultTerm) + ":" + statementList; caseConditionList.Rule = MakePlusRule(caseConditionList, null, caseCondition); caseCondition.Rule = ToTerm(LanguageTerms.CaseTerm) + literal + ":"; // a foreach statement consists of a foreach keyword, followed by a model context, // optionally followed by a where clause, and includes a set of statements // or, a foreach statement consists of a Record item foreachStatement.Rule = ToTerm(LanguageTerms.ForeachTerm) + Lpar + foreachClause + Rpar + Lbr + statementList + Rbr; foreachClause.Rule = modelContext + inClause + whereClause + limitClause + sortClause | ToTerm(LanguageTerms.RecordItem) + limitClause; inClause.Rule = Empty | ToTerm(LanguageTerms.InTerm) + inClauseItem; whereClause.Rule = Empty | ToTerm(LanguageTerms.WhereTerm) + expression; limitClause.Rule = Empty | ToTerm(LanguageTerms.LimitTerm) + Number; sortClause.Rule = Empty | ToTerm(LanguageTerms.SortTerm) + modelProperty + sortDirectionClause; sortDirectionClause.Rule = Empty | ToTerm(LanguageTerms.AscTerm) | ToTerm(LanguageTerms.DescTerm); // a while statement consists of a while keyword, followed by an expression, // and includes a set of statements whileStatement.Rule = ToTerm(LanguageTerms.WhileTerm) + Lpar + expression + Rpar + Lbr + statementList + Rbr; // current item assignment statement currentItemAssignmentStatement.Rule = currentItem + "=" + modelContext | currentItem + "=" + "null"; // template property assignment statement templatePropertyAssignmentStatement.Rule = ToTerm(LanguageTerms.TextProperty) + "=" + parameter; // debug statement debugStatement.Rule = ToTerm(LanguageTerms.DebugTerm) + Lpar + parameter + Rpar | ToTerm(LanguageTerms.DebugTerm) + Lpar + parameter + comma + parameter + Rpar; // trace statement traceStatement.Rule = ToTerm(LanguageTerms.TraceTerm) + Lpar + parameter + Rpar | ToTerm(LanguageTerms.TraceTerm) + Lpar + parameter + comma + parameter + Rpar; // log statement logStatement.Rule = ToTerm(LanguageTerms.LogTerm) + Lpar + parameter + comma + parameter + comma + parameter + Rpar; // a with statement consists of a with keyword, followed by a model context, // and includes a set of statements withStatement.Rule = ToTerm(LanguageTerms.WithTerm) + Lpar + modelContext + fromClause + Rpar + Lbr + statementList + Rbr | LanguageTerms.WithTerm + Lpar + currentItem + Rpar + Lbr + statementList + Rbr; fromClause.Rule = Empty | ToTerm(LanguageTerms.FromTerm) + contextHelper; // progress statement progressStatement.Rule = ToTerm(LanguageTerms.ProgressTerm) | LanguageTerms.ProgressTerm + Lpar + parameter + Rpar; // a context helper is one of the specifically supported internal methods to set model context contextHelper.Rule = modelContext + dot + LanguageTerms.FindMethod + Lpar + modelProperty + comma + parameter + Rpar | modelContext + dot + LanguageTerms.FindMethod + Lpar + parameter + Rpar | currentItem + dot + LanguageTerms.FindMethod + Lpar + modelProperty + comma + parameter + Rpar | currentItem + dot + LanguageTerms.FindMethod + Lpar + parameter + Rpar; // a property is a content property or an output property property.Rule = contentProperty | templateText; // a content property can be a template property, model property, or configuration property (template property is lowest precedence) contentProperty.Rule = propOpen + configurationProperty + close | propOpen + parameter + close; // a parameter is a model property or string literal parameter.Rule = modelProperty | literal | parameter + mathOp + parameter; // an in clause item is a collection from a model context, current item, or a special collection inClauseItem.Rule = modelContext | currentItem | collectionHelper; // a collection helper gets specialized collections collectionHelper.Rule = modelContext + dot + LanguageTerms.FindAllMethod + Lpar + modelProperty + comma + parameter + Rpar | currentItem + dot + LanguageTerms.FindAllMethod + Lpar + modelProperty + comma + parameter + Rpar | ToTerm(LanguageTerms.GetEntityAndBasesCollection) | ToTerm(LanguageTerms.GetBaseAndEntitiesCollection) | ToTerm(LanguageTerms.ExtendingEntitiesCollection) | ToTerm(LanguageTerms.PathRelationships); // a current item node is a valid name of a type of node in the model that can be assigned to isFirstItem = true; // add all CurrentItemTypeCode enums to currentItem rule foreach (string key in GrammarHelper.CurrentItemTypes.AllKeys) { if (isFirstItem == true) { currentItem.Rule = ToTerm(key); isFirstItem = false; } else { currentItem.Rule = currentItem.Rule | ToTerm(key); } } // add all ModelObject instances in model to currentItem rule if (solution != null) { foreach (string key in solution.ModelObjectNames.AllKeys) { currentItem.Rule = currentItem.Rule | ToTerm("Current" + key); } } // add all ModelObjectProperty instances in model to currentItem rule if (solution != null) { foreach (string key in solution.ModelObjectPropertyNames.AllKeys) { currentItem.Rule = currentItem.Rule | ToTerm("Current" + key); } } // a model context node is a valid name of a type of node in the model or a pop context directive modelContext.Rule = popContext | popContext + modelContext | thisContext | thisContext + dot + modelContext; // add all ModelContextTypeCode enums to modelContext rule foreach (string key in GrammarHelper.ModelContextTypes.AllKeys) { modelContext.Rule = modelContext.Rule | ToTerm(key); } // add all OtherModelContextTypeCode enums to modelContext rule foreach (string key in GrammarHelper.OtherModelContextTypes.AllKeys) { modelContext.Rule = modelContext.Rule | ToTerm(key); } // add all ModelObject instances in model to modelContext rule if (solution != null) { foreach (string key in solution.ModelObjectNames.AllKeys) { modelContext.Rule = modelContext.Rule | ToTerm(key); } } // add all ModelObjectProperty instances in model to assignableProperty rule if (solution != null) { foreach (string key in solution.ModelObjectPropertyNames.AllKeys) { modelContext.Rule = modelContext.Rule | ToTerm(key); } } // an assignable property is a model property that can have values assigned to it isFirstItem = true; // add all AssignablePropertyCode enums to assignableProperty rule foreach (string key in GrammarHelper.AssignableProperties.AllKeys) { if (isFirstItem == true) { assignableProperty.Rule = ToTerm(key); isFirstItem = false; } else { assignableProperty.Rule = assignableProperty.Rule | ToTerm(key); } } // add all ModelProperty instances in model to assignableProperty rule if (solution != null) { foreach (string key in solution.ModelPropertyNames.AllKeys) { assignableProperty.Rule = assignableProperty.Rule | ToTerm(key); } } // a model property is a valid property name of a node in the model (can refer to other nodes with the dot notation) modelProperty.Rule = assignableProperty | ToTerm(LanguageTerms.ItemIndexProperty) | ToTerm(LanguageTerms.TextProperty) | ToTerm(LanguageTerms.PathProperty) //| ToTerm(LanguageTerms.LibraryDirectoryProperty) | ToTerm(LanguageTerms.IsRelatedToProperty) | modelContext + dot + modelProperty | currentItem + dot + modelProperty | templateProperty | popContext + modelProperty | thisContext + dot + modelProperty | ToTerm(LanguageTerms.ColumnMethod) + Lpar + parameter + Rpar | ToTerm(LanguageTerms.FileMethod) + Lpar + parameter + Rpar | ToTerm(LanguageTerms.FileExistsMethod) + Lpar + parameter + Rpar | ToTerm(LanguageTerms.LogMethod) + Lpar + parameter + comma + parameter + Rpar | ToTerm(LanguageTerms.HasPropertyNamed) + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringStartsWith + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringEndsWith + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringContains + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringRegexReplace + Lpar + parameter + comma + parameter + Rpar | modelProperty + dot + LanguageTerms.StringRegexIsMatch + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringCamelCase + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringCapitalCase + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringCapitalWordCase + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringUnderscoreCase + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringToLower + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringToUpper + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringTrim + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringTrimStart + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringTrimEnd + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringReplace + Lpar + parameter + comma + parameter + Rpar | modelProperty + dot + LanguageTerms.StringFilter + Lpar + parameter + comma + parameter + Rpar | modelProperty + dot + LanguageTerms.StringFilterProtected + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringFilterIgnored + Lpar + Rpar | modelProperty + dot + LanguageTerms.StringSubstring + Lpar + parameter + comma + parameter + Rpar | modelProperty + dot + LanguageTerms.StringSubstring + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringIndexOf + Lpar + parameter + Rpar | modelProperty + dot + LanguageTerms.StringLength; // add all ReadOnlyPropertyCode enums to modelProperty rule foreach (string key in GrammarHelper.ReadOnlyProperties.AllKeys) { modelProperty.Rule = modelProperty.Rule | ToTerm(key); } // a configuration property is one of the specfically supported internal methods to process model data configurationProperty.Rule = ToTerm(LanguageTerms.TabMethod) + Number | ToTerm(LanguageTerms.UseTabsMethod) + "true" | ToTerm(LanguageTerms.UseTabsMethod) + "false" | ToTerm(LanguageTerms.TabStringMethod) + StringLiteral | ToTerm(LanguageTerms.UseProtectedAreasMethod) + "true" | ToTerm(LanguageTerms.UseProtectedAreasMethod) + "false" | ToTerm(LanguageTerms.ProtectedAreaStartMethod) + StringLiteral | ToTerm(LanguageTerms.ProtectedAreaEndMethod) + StringLiteral | ToTerm(LanguageTerms.UseIgnoredAreasMethod) + "true" | ToTerm(LanguageTerms.UseIgnoredAreasMethod) + "false" | ToTerm(LanguageTerms.IgnoredAreaStartMethod) + StringLiteral | ToTerm(LanguageTerms.IgnoredAreaEndMethod) + StringLiteral | ToTerm(LanguageTerms.UserMethod) | ToTerm(LanguageTerms.NowMethod); // a template property from the parser perspective is just an identifier, the interpreter will resolve template references templateProperty.Rule = identifier | identifier + Lpar + templateParameterList + Rpar; // a template parameter list consists of any number of template parameters delimited by commas templateParameterList.Rule = MakeStarRule(templateParameterList, comma, templateParameter); // template parameter templateParameter.Rule = identifier + "=" + parameter; // an expression can be a hierarchy of expressions with binary operators, model properties, and literals expression.Rule = literal | modelProperty | modelContext | currentItem | expression + binOp + expression | expression + mathOp + expression | Lpar + expression + Rpar; // a literal can be a number, string, character, true, false, or null literal.Rule = Number | StringLiteral | "true" | "false" | "null"; // binary operator binOp.Rule = ToTerm("||") | "&&" | "==" | "!=" | "<" | ">" | "<=" | ">="; // math operator mathOp.Rule = ToTerm("+") | "-" | "*" | "/"; #endregion // the template is the root of the grammar this.Root = template; // mark nodes to filter from the parse tree this.MarkTransient(statement, templateBlock, property, contentProperty); }
internal virtual void InitProductions() { #region Definitions var statement = new NonTerminal(XpressConstants.Tokens.NonTerminals.Statement); var expression = new NonTerminal(XpressConstants.Tokens.NonTerminals.Expression); var parenExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.ParenExpression); var relationalExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.RelationalExpression); var binaryAdditiveExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.BinaryAdditiveExpression); var binaryMultiplicityExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.BinaryMultiplicityExpression); var unaryExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.UnaryExpression); var conditionalOperator = new NonTerminal(XpressConstants.Tokens.NonTerminals.ConditionalOperator); var relationalOperator = new NonTerminal(XpressConstants.Tokens.NonTerminals.RelationalOperator); var binaryAdditiveOperator = new NonTerminal(XpressConstants.Tokens.NonTerminals.BinaryAdditiveOperator); var binaryMultiplicityOperator = new NonTerminal(XpressConstants.Tokens.NonTerminals.BinaryMultiplicityOperator); var unaryOperator = new NonTerminal(XpressConstants.Tokens.NonTerminals.UnaryOperator); var primaryExpression = new NonTerminal(XpressConstants.Tokens.NonTerminals.PrimaryExpression); var nullLiteral = new NonTerminal(XpressConstants.Tokens.NonTerminals.NullLiteral); var booleanLiteral = new NonTerminal(XpressConstants.Tokens.NonTerminals.BooleanLiteral); var identifier = TerminalFactory.CreateCSharpIdentifier(XpressConstants.Tokens.NonTerminals.Identifier); var numberLiteral = TerminalFactory.CreateCSharpNumber(XpressConstants.Tokens.NonTerminals.NumberLiteral); var stringLiteral = TerminalFactory.CreateCSharpString(XpressConstants.Tokens.NonTerminals.StringLiteral); var expressionBegin = ToTerm(XpressConstants.Tokens.Terminals.ExpressionBeginSymbol); var expressionEnd = ToTerm(XpressConstants.Tokens.Terminals.ExpressionEndSymbol); var conditionalAndOperator = ToTerm(XpressConstants.Tokens.Terminals.ConditionalAndOperator); var conditionalOrOperator = ToTerm(XpressConstants.Tokens.Terminals.ConditionalOrOperator); var relationalGreatThanOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalGreatThanOperator); var relationalLessThanOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalLessThanOperator); var relationalGreatThanOrEqualOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalGreatThanOrEqualOperator); var relationalLessThanOrEqualOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalLessThanOrEqualOperator); var relationalEqualityOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalEqualityOperator); var relationalNonEqualityOperator = ToTerm(XpressConstants.Tokens.Terminals.RelationalNonEqualityOperator); var binaryAdditionOperator = ToTerm(XpressConstants.Tokens.Terminals.BinaryAdditionOperator); var binarySubtrationOperator = ToTerm(XpressConstants.Tokens.Terminals.BinarySubtrationOperator); var binaryMultiplicationOperator = ToTerm(XpressConstants.Tokens.Terminals.BinaryMultiplicationOperator); var binaryDivisionOperator = ToTerm(XpressConstants.Tokens.Terminals.BinaryDivisionOperator); var binaryModuloOperator = ToTerm(XpressConstants.Tokens.Terminals.BinaryModuloOperator); var unaryNegationOperator = ToTerm(XpressConstants.Tokens.Terminals.UnaryNegationOperator); var nullValue = ToTerm(XpressConstants.Tokens.Terminals.NullValue); var booleanTrueValue = ToTerm(XpressConstants.Tokens.Terminals.BooleanTrueValue); var booleanFalseValue = ToTerm(XpressConstants.Tokens.Terminals.BooleanFalseValue); stringLiteral.AddStartEnd(XpressConstants.Tokens.Terminals.StringStartEndSymbol, StringOptions.NoEscapes); #endregion // BNF Root = statement; statement.Rule = expression; parenExpression.Rule = expressionBegin + expression + expressionEnd; expression.Rule = expression + conditionalOperator + relationalExpression | relationalExpression; conditionalOperator.Rule = conditionalAndOperator | conditionalOrOperator; relationalExpression.Rule = relationalExpression + relationalOperator + binaryAdditiveExpression | binaryAdditiveExpression; relationalOperator.Rule = relationalGreatThanOperator | relationalGreatThanOrEqualOperator | relationalLessThanOperator | relationalLessThanOrEqualOperator | relationalEqualityOperator | relationalNonEqualityOperator; binaryAdditiveExpression.Rule = binaryAdditiveExpression + binaryAdditiveOperator + binaryMultiplicityExpression | binaryMultiplicityExpression; binaryAdditiveOperator.Rule = binaryAdditionOperator | binarySubtrationOperator; binaryMultiplicityExpression.Rule = binaryMultiplicityExpression + binaryMultiplicityOperator + unaryExpression | unaryExpression; binaryMultiplicityOperator.Rule = binaryMultiplicationOperator | binaryDivisionOperator | binaryModuloOperator; unaryExpression.Rule = unaryOperator + primaryExpression | primaryExpression; unaryOperator.Rule = unaryNegationOperator; primaryExpression.Rule = identifier | numberLiteral | stringLiteral | booleanLiteral | nullLiteral | parenExpression; nullLiteral.Rule = nullValue; booleanLiteral.Rule = booleanTrueValue | booleanFalseValue; }
public AnalizadorPy() : base(caseSensitive: false) { #region expresiones regulares var identificador = TerminalFactory.CreateCSharpIdentifier("identificador"); var numero = TerminalFactory.CreateCSharpNumber("numero"); var val_false = Constantes.falso; var val_true = Constantes.verdadero; StringLiteral cadena = new StringLiteral("cadena", "\""); var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter); CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "/*", "*/"); CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "//", "\n", "\r\n"); NonGrammarTerminals.Add(COMENT_BLOQUE); NonGrammarTerminals.Add(COMENT_LINEA); #endregion #region palabras reservadas var tipoDecimal = Constantes.tipoDecimal; var tipoString = Constantes.tipoCadena; var tipoBoolean = Constantes.tipoBool; var tipoCaracter = Constantes.tipoChar; var tipoInt = Constantes.tipoEntero; var tipoVoid = Constantes.tipoVoid; var visiPublico = Constantes.publico; var visiPrivado = Constantes.privado; var visiProtegido = Constantes.protegido; var clase = Constantes.clase; var sobreescribir = Constantes.sobreescribir; #endregion #region declaproducciones NonTerminal FUN_SOBRE = new NonTerminal(Constantes.funSobre); NonTerminal TIPO = new NonTerminal(Constantes.tipo); NonTerminal FUNCION = new NonTerminal(Constantes.funcion); NonTerminal VISIBILIDAD = new NonTerminal(Constantes.visibilidad); NonTerminal CUERPO = new NonTerminal(Constantes.cuerpo); NonTerminal PARAMETRO = new NonTerminal(Constantes.parametro); NonTerminal L_PARAMETRO = new NonTerminal(Constantes.listaParametros); NonTerminal L_ELEMENTOS = new NonTerminal(Constantes.listaElementos); NonTerminal ATRIBUTO = new NonTerminal(Constantes.atributo); NonTerminal L_IDS = new NonTerminal(Constantes.listaIds); NonTerminal EXPRESION = new NonTerminal(Constantes.expresion); NonTerminal ELEMENTO = new NonTerminal(Constantes.elementoClase); NonTerminal CLASE = new NonTerminal(Constantes.clase); NonTerminal CUERPO_CLASE = new NonTerminal(Constantes.CUERPO_CLASE); NonTerminal PRINCIPAL = new NonTerminal(Constantes.principal); NonTerminal CONSTRUCTOR = new NonTerminal(Constantes.constructor); NonTerminal IMPRIMIR = new NonTerminal(Constantes.imprimir); NonTerminal DECLAPARA = new NonTerminal("DECLAPARA"); NonTerminal INSTRUCCIONES = new NonTerminal(Constantes.instrucciones); NonTerminal INSTRUCCION = new NonTerminal(Constantes.instruccion); NonTerminal DECLARACION = new NonTerminal(Constantes.declaracion); NonTerminal LPOSICIONES = new NonTerminal(Constantes.lposiciones); NonTerminal LEXPRESIONES = new NonTerminal(Constantes.lexpresiones); NonTerminal LFILAS = new NonTerminal(Constantes.lfilas); NonTerminal ASIGNACION = new NonTerminal(Constantes.asignacion); NonTerminal POSICION = new NonTerminal(Constantes.posicion); NonTerminal FILA = new NonTerminal(Constantes.fila); NonTerminal DECIMAL = new NonTerminal(Constantes.tipoDecimal); NonTerminal ENTERO = new NonTerminal(Constantes.tipoEntero); NonTerminal CADENA = new NonTerminal(Constantes.tipoCadena); NonTerminal CHAR = new NonTerminal(Constantes.tipoChar); NonTerminal BOOLEANO = new NonTerminal(Constantes.tipoBool); NonTerminal SIMB_ARIT = new NonTerminal(Constantes.simb_arit); NonTerminal SIMB_REL = new NonTerminal(Constantes.simb_rel); NonTerminal UNARIO = new NonTerminal(Constantes.unario); NonTerminal ID = new NonTerminal(Constantes.id); NonTerminal NEGATIVO = new NonTerminal(Constantes.negativo); NonTerminal RELACIONAL = new NonTerminal(Constantes.relacional); NonTerminal ARITMETICA = new NonTerminal(Constantes.aritmetica); NonTerminal LOGICA = new NonTerminal(Constantes.logica); NonTerminal LLAMADA = new NonTerminal(Constantes.llamada); NonTerminal POSVECTOR = new NonTerminal(Constantes.posvector); NonTerminal LISTAPUNTOS = new NonTerminal(Constantes.listapuntos); NonTerminal SIMB_LOG = new NonTerminal(Constantes.simb_log); NonTerminal MAS_MAS = new NonTerminal(Constantes.masmas); NonTerminal MENOS_MENOS = new NonTerminal(Constantes.menosmenos); NonTerminal ASIG_ARRAY = new NonTerminal(Constantes.asig_array); NonTerminal termino = new NonTerminal(Constantes.termino); NonTerminal RETORNO = new NonTerminal(Constantes.retorno); NonTerminal LISTACLASES = new NonTerminal(Constantes.l_clases); NonTerminal SUMA = new NonTerminal(Constantes.suma); NonTerminal RESTA = new NonTerminal(Constantes.resta); NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion); NonTerminal DIVISION = new NonTerminal(Constantes.division); NonTerminal POTENCIA = new NonTerminal(Constantes.potencia); NonTerminal MENOR = new NonTerminal(Constantes.menor); NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual); NonTerminal MAYOR = new NonTerminal(Constantes.mayor); NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual); NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual); NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA); NonTerminal XOR = new NonTerminal(Constantes.xorJava); NonTerminal AND = new NonTerminal(Constantes.andJava); NonTerminal NOT = new NonTerminal(Constantes.notJavaPython); NonTerminal OR = new NonTerminal(Constantes.orJava); NonTerminal INSTANCIA = new NonTerminal(Constantes.instancia); NonTerminal SALIR = new NonTerminal(Constantes.salir); NonTerminal CONTINUAR = new NonTerminal(Constantes.continuar); NonTerminal SI = new NonTerminal(Constantes.si); NonTerminal EXTRA = new NonTerminal(Constantes.extraSi); NonTerminal SINO = new NonTerminal(Constantes.sino); NonTerminal CUERPOSI = new NonTerminal(Constantes.cuerposi); NonTerminal L_EXTRAS = new NonTerminal(Constantes.lextra); NonTerminal MIENTRAS = new NonTerminal(Constantes.mientras); NonTerminal REPETIR = new NonTerminal(Constantes.repetir); NonTerminal HACER = new NonTerminal(Constantes.hacer); NonTerminal PARA = new NonTerminal(Constantes.para); NonTerminal LOOP = new NonTerminal(Constantes.loop); #endregion VISIBILIDAD.Rule = ToTerm(visiPrivado) | ToTerm(visiProtegido) | ToTerm(visiPublico); TIPO.Rule = ToTerm(tipoBoolean) | ToTerm(tipoCaracter) | ToTerm(tipoDecimal) | ToTerm(tipoInt) | ToTerm(tipoString) | identificador; L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador); DECLARACION.Rule = TIPO + L_IDS | TIPO + L_IDS + LPOSICIONES; POSICION.Rule = ToTerm("[") + EXPRESION + "]"; LPOSICIONES.Rule = MakePlusRule(LPOSICIONES, POSICION); FILA.Rule = ToTerm("{") + LEXPRESIONES + "}"; LFILAS.Rule = MakePlusRule(LFILAS, ToTerm(","), FILA); ASIGNACION.Rule = EXPRESION + ToTerm("=") + ">" + EXPRESION; INSTRUCCION.Rule = DECLARACION + Eos | CONTINUAR + Eos | SALIR + Eos | MIENTRAS + Eos | HACER | REPETIR | LOOP + Eos; INSTRUCCIONES.Rule = MakePlusRule(INSTRUCCIONES, INSTRUCCION); CUERPO.Rule = Indent + INSTRUCCIONES + Dedent; FUNCION.Rule = VISIBILIDAD + ToTerm("funcion") + TIPO + identificador + "[" + "]" + Eos + CUERPO; #region estructuras de control CONTINUAR.Rule = ToTerm(Constantes.continuar); SALIR.Rule = ToTerm(Constantes.salir); MIENTRAS.Rule = ToTerm(Constantes.mientras) + EXPRESION + ":" + Eos + CUERPO; HACER.Rule = ToTerm(Constantes.hacer) + ":" + Eos + CUERPO + ToTerm(Constantes.mientras) + EXPRESION + Eos; REPETIR.Rule = ToTerm(Constantes.repetir) + ":" + Eos + CUERPO + ToTerm(Constantes.hasta) + EXPRESION + Eos; LOOP.Rule = ToTerm(Constantes.loop) + ":" + Eos + CUERPO; #endregion #region expresion DECIMAL.Rule = numero; ENTERO.Rule = numero; CADENA.Rule = cadena; ID.Rule = identificador; CHAR.Rule = caracter; BOOLEANO.Rule = ToTerm(val_false) | ToTerm(val_true); ARITMETICA.Rule = SUMA | RESTA | MULTIPLICACION | DIVISION | POTENCIA; RELACIONAL.Rule = MENOR | MAYOR | MENORIGUAL | MAYORIGUAL | DISTINTOA | IGUALIGUAL; LOGICA.Rule = XOR | OR | AND | NOT; SUMA.Rule = EXPRESION + ToTerm(Constantes.suma) + EXPRESION; RESTA.Rule = EXPRESION + ToTerm(Constantes.resta) + EXPRESION; MULTIPLICACION.Rule = EXPRESION + ToTerm(Constantes.multiplicacion) + EXPRESION; DIVISION.Rule = EXPRESION + ToTerm(Constantes.division) + EXPRESION; POTENCIA.Rule = EXPRESION + ToTerm(Constantes.potencia) + EXPRESION; MENOR.Rule = EXPRESION + ToTerm(Constantes.menor) + EXPRESION; MENORIGUAL.Rule = EXPRESION + ToTerm(Constantes.menorIgual) + EXPRESION; MAYOR.Rule = EXPRESION + ToTerm(Constantes.mayor) + EXPRESION; MAYORIGUAL.Rule = EXPRESION + ToTerm(Constantes.mayorIgual) + EXPRESION; IGUALIGUAL.Rule = EXPRESION + ToTerm(Constantes.igualIgual) + EXPRESION; DISTINTOA.Rule = EXPRESION + ToTerm(Constantes.distintoA) + EXPRESION; XOR.Rule = EXPRESION + ToTerm(Constantes.xorPython) + EXPRESION; AND.Rule = EXPRESION + ToTerm(Constantes.andPython) + EXPRESION; NOT.Rule = ToTerm(Constantes.notJavaPython) + EXPRESION; OR.Rule = EXPRESION + ToTerm(Constantes.orPython) + EXPRESION; INSTANCIA.Rule = Constantes.nuevoPython + identificador + "[" + LEXPRESIONES + "]" | Constantes.nuevoPython + identificador + "[" + "]"; UNARIO.Rule = MAS_MAS | MENOS_MENOS; MAS_MAS.Rule = identificador + ToTerm(Constantes.masmas); MENOS_MENOS.Rule = identificador + ToTerm(Constantes.menosmenos); NEGATIVO.Rule = ToTerm("-") + EXPRESION; termino.Rule = ToTerm("(") + ARITMETICA + ")" | ToTerm("[") + RELACIONAL + "]" | ToTerm("{") + LOGICA + "}" | DECIMAL | ENTERO | ID | CADENA | BOOLEANO | CHAR | LLAMADA | POSVECTOR | ToTerm("(") + UNARIO + ")" | NEGATIVO | "{" + LFILAS + "}" | INSTANCIA; LLAMADA.Rule = identificador + ToTerm("[") + LEXPRESIONES + "]" | identificador + ToTerm("[") + "]"; POSVECTOR.Rule = identificador + LPOSICIONES; L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador); EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), termino); LEXPRESIONES.Rule = MakePlusRule(EXPRESION, ToTerm(","), EXPRESION); #endregion NonTerminal n = new NonTerminal("fdsfd"); n.Rule = termino + Eos; this.Root = n; }
public Gramatica() : base(caseSensitive: true) { //---------------------> Comentarios CommentTerminal COMENTARIO_SIMPLE = new CommentTerminal("comentario_simple", "!!", "\n", "\r\n"); CommentTerminal COMENTARIO_MULT = new CommentTerminal("comentario_mult", "<<", ">>"); NonGrammarTerminals.Add(COMENTARIO_SIMPLE); NonGrammarTerminals.Add(COMENTARIO_MULT); /*--------------------Definir Palabras Reservadas ----------------*/ MarkReservedWords("Importar"); MarkReservedWords("Definir"); MarkReservedWords("Double"); MarkReservedWords("String"); MarkReservedWords("Bool"); MarkReservedWords("Int"); MarkReservedWords("Char"); MarkReservedWords("Retorno"); MarkReservedWords("Vacio"); MarkReservedWords("Principal"); MarkReservedWords("Si"); MarkReservedWords("Sino"); MarkReservedWords("Selecciona"); MarkReservedWords("Defecto"); MarkReservedWords("Para"); MarkReservedWords("Hasta"); MarkReservedWords("Mientras"); MarkReservedWords("Detener"); MarkReservedWords("Continuar"); MarkReservedWords("Mostrar"); MarkReservedWords("DibujarAST"); MarkReservedWords("DibujarEXP"); MarkReservedWords("DibujarTS"); /*--------------------- (Opcional)Definir variables para palabras reservadas--*/ var mas = ToTerm("+"); var punto = ToTerm("."); var menos = ToTerm("-"); var por = ToTerm("*"); var division = ToTerm("/"); var potencia = ToTerm("^"); var igual = ToTerm("="); var porc = ToTerm("%"); var allave = ToTerm("{"); var cllave = ToTerm("}"); var apar = ToTerm("("); var cpar = ToTerm(")"); var coma = ToTerm(","); var dospuntos = ToTerm(":"); var puntocoma = ToTerm(";"); var llavea = ToTerm("{"); var llavec = ToTerm("}"); var trues = ToTerm("true"); var falses = ToTerm("false"); /*-------------relacionales------------------*/ var igualigual = ToTerm("=="); var diferente = ToTerm("!="); var mayor = ToTerm(">"); var menor = ToTerm("<"); var mayorigual = ToTerm(">="); var menorigual = ToTerm("<="); var incerteza = ToTerm("~"); var masmas = ToTerm("++"); var menosmenos = ToTerm("--"); /*--------------------expresiones logicas---------*/ var or = ToTerm("||"); var and = ToTerm("&&"); var not = ToTerm("!"); var xor = ToTerm("|&"); /*----------------------palabras-------*/ var importar = ToTerm("Importar"); var definir = ToTerm("Definir"); var vadouble = ToTerm("Double"); var vastring = ToTerm("String"); var varint = ToTerm("Int"); var vabool = ToTerm("Bool"); var vachar = ToTerm("Char"); var retorno = ToTerm("Retorno"); var vacio = ToTerm("Vacio"); var principal = ToTerm("Principal"); var si = ToTerm("Si"); var sino = ToTerm("Sino"); var selecciona = ToTerm("Selecciona"); var defecto = ToTerm("Defecto"); var para = ToTerm("Para"); var hasta = ToTerm("Hasta"); var mientras = ToTerm("Mientras"); var detener = ToTerm("Detener"); var continuar = ToTerm("Continuar"); var mostrar = ToTerm("Mostrar"); var dibast = ToTerm("DibujarAST"); var dibexp = ToTerm("DibujarEXP"); var dibts = ToTerm("DibujarTS"); /*--------------------- No Terminales --------*/ var INICIO = new NonTerminal("INICIO"); var LISTA = new NonTerminal("LISTA"); var ESTRUC = new NonTerminal("ESTRUC"); var DECLARACION = new NonTerminal("DECLARACION"); var DECLARACION2 = new NonTerminal("DECLARACION2"); var EXPRESION = new NonTerminal("EXPRESION"); var EXPRESION2 = new NonTerminal("EXPRESION2"); var CTIPO = new NonTerminal("CTIPO"); var VARIOS = new NonTerminal("VARIOS"); var ESTRUCTURA = new NonTerminal("ESTRUCTURA"); var ENCABEZADO = new NonTerminal("ENCABEZADO"); var TIPO = new NonTerminal("TIPO"); var CUERPO = new NonTerminal("CUERPO"); var ASIGNACION = new NonTerminal("ASIGNACION"); var ASIGNACION2 = new NonTerminal("ASIGNACION2"); var FUN = new NonTerminal("FUN"); var METOD = new NonTerminal("METOD"); var LISTA2 = new NonTerminal("LISTA2"); var DECLAPARA = new NonTerminal("DECLAPARA"); var PARAMETROS = new NonTerminal("PARAMETROS"); var ESTRUC2 = new NonTerminal("ESTRUC2"); var FUNPRIN = new NonTerminal("FUNPRIN"); var LISTA3 = new NonTerminal("LISTA3"); var ESTRUC3 = new NonTerminal("ESTRUC3"); var LLAMADAS = new NonTerminal("LLAMADAS"); var RETORN = new NonTerminal("RETORN"); var SENTSI = new NonTerminal("SENTSI"); var SENTSINO = new NonTerminal("SENTSINO"); var SENTHASTA = new NonTerminal("SENTHASTA"); var SENTMIENTRAS = new NonTerminal("SENTMIENTRAS"); var SENTPARA = new NonTerminal("SENTPARA"); var SENTSELECCIONA = new NonTerminal("SENTSELECCIONA"); var CASO = new NonTerminal("CASO"); var DEFECT = new NonTerminal("DEFECT"); var PRINT = new NonTerminal("PRINT"); var DIBAST = new NonTerminal("DIBAST"); var DIBEXP = new NonTerminal("DIBEXP"); var DIBTS = new NonTerminal("DIBTS"); var LLAMAR = new NonTerminal("LLAMAR"); var VARIOS2 = new NonTerminal("VARIOS2"); //---------------------> Terminales var tString = new StringLiteral("tString", "\"", StringOptions.AllowsDoubledQuote); var tchar = new StringLiteral("tchar", "\'", StringOptions.AllowsDoubledQuote); NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero"); IdentifierTerminal id = TerminalFactory.CreateCSharpIdentifier("id"); //---------------------> No Terminal Inicial this.Root = INICIO; //---------------------> Producciones ------------------------------------------ INICIO.Rule = ENCABEZADO + LISTA; ENCABEZADO.Rule = importar + id + punto + id + puntocoma + ENCABEZADO | definir + CTIPO + puntocoma + ENCABEZADO | Empty; LISTA.Rule = MakeStarRule(LISTA, ESTRUC); /*----------------------lo que puede llevar todo el programa-----------------*/ ESTRUC.Rule = DECLARACION | ASIGNACION | FUN | METOD | FUNPRIN ; /*---------------------------lo que llevan las funciones y metodos----------------------*/ LISTA2.Rule = MakeStarRule(LISTA2, ESTRUC2); ESTRUC2.Rule = DECLARACION2 | ASIGNACION2 | LLAMADAS | RETORN | SENTSI | SENTPARA | SENTMIENTRAS | SENTHASTA | SENTSELECCIONA | DIBEXP | DIBAST | DIBTS | PRINT; /*----------------------------puede llevar funcion principal y otros ---------*/ LISTA3.Rule = MakeStarRule(LISTA3, ESTRUC3); ESTRUC3.Rule = DECLARACION2 | ASIGNACION2 | LLAMADAS | detener + puntocoma | continuar + puntocoma | SENTSI | SENTPARA | SENTMIENTRAS | SENTHASTA | SENTSELECCIONA | DIBEXP | DIBAST | DIBTS | PRINT | RETORN; /*------------------------------DECLArACION y asignacion---------------------------*/ DECLARACION.Rule = TIPO + VARIOS + igual + EXPRESION + puntocoma | TIPO + VARIOS + puntocoma; ASIGNACION.Rule = id + igual + EXPRESION + puntocoma; DECLARACION2.Rule = TIPO + VARIOS + igual + EXPRESION + puntocoma | TIPO + VARIOS + puntocoma; ASIGNACION2.Rule = id + igual + EXPRESION + puntocoma; VARIOS.Rule = CTIPO + coma + VARIOS | CTIPO; VARIOS2.Rule = coma + EXPRESION + VARIOS2 | Empty; CTIPO.Rule = tString | tchar | numero | id; TIPO.Rule = vabool | vachar | vadouble | varint | vastring; /*---------------------metodos funciones----------------------*/ FUN.Rule = TIPO + id + apar + DECLAPARA + cpar + allave + LISTA2 + cllave; METOD.Rule = vacio + id + apar + DECLAPARA + cpar + allave + LISTA2 + cllave; PARAMETROS.Rule = EXPRESION | EXPRESION + coma + PARAMETROS | Empty; DECLAPARA.Rule = TIPO + id + coma + DECLAPARA | TIPO + id | Empty; LLAMAR.Rule = id + apar + PARAMETROS + cpar; /*-------------------funcion principal----------------------*/ FUNPRIN.Rule = vacio + principal + apar + cpar + allave + LISTA3 + cllave; /*--------------llamdas a funciones ----------*/ LLAMADAS.Rule = id + apar + PARAMETROS + cpar + puntocoma; /*----------------retornar-------------*/ RETORN.Rule = retorno + EXPRESION + puntocoma | retorno + puntocoma; /*----------------------sentencia si---------------*/ SENTSI.Rule = si + apar + EXPRESION + cpar + allave + LISTA3 + cllave + SENTSINO; SENTSINO.Rule = sino + allave + LISTA3 + cllave | Empty; /*-----------------sentencia selecciona-------------*/ SENTSELECCIONA.Rule = selecciona + apar + EXPRESION + cpar + llavea + CASO + DEFECT + cllave; CASO.Rule = EXPRESION + dospuntos + LISTA3 + CASO | Empty; DEFECT.Rule = defecto + dospuntos + LISTA3 | Empty; /*----------------------sentencia para-------------------*/ SENTPARA.Rule = para + apar + vadouble + id + igual + EXPRESION + puntocoma + EXPRESION + puntocoma + masmas + cpar + allave + LISTA3 + cllave | para + apar + vadouble + id + igual + EXPRESION + puntocoma + EXPRESION + puntocoma + menosmenos + cpar + allave + LISTA3 + cllave; /*-------------------------sentencia hasta ------------*/ SENTHASTA.Rule = hasta + apar + EXPRESION + cpar + allave + LISTA3 + cllave; /*------------sentencias mientras ---------------*/ SENTMIENTRAS.Rule = mientras + apar + EXPRESION + cpar + allave + LISTA3 + cllave; /*------------------------mostrar----*/ PRINT.Rule = mostrar + apar + tString + VARIOS2 + cpar + puntocoma; /*----------------funcion dibujar ast-----------*/ DIBAST.Rule = dibast + apar + id + cpar + puntocoma; /*--------------------funcion dibujar exp------*/ DIBEXP.Rule = dibexp + apar + EXPRESION2 + cpar + puntocoma; /*------------------------------------------dibujar ts-------------------*/ DIBTS.Rule = dibts + apar + cpar + puntocoma; EXPRESION.Rule = EXPRESION + or + EXPRESION | EXPRESION + and + EXPRESION | not + EXPRESION | EXPRESION + xor + EXPRESION | EXPRESION + igualigual + EXPRESION | EXPRESION + diferente + EXPRESION | EXPRESION + mayor + EXPRESION | EXPRESION + menor + EXPRESION | EXPRESION + mayorigual + EXPRESION | EXPRESION + menorigual + EXPRESION | EXPRESION + mas + EXPRESION | EXPRESION + menos + EXPRESION | EXPRESION + por + EXPRESION | EXPRESION + potencia + EXPRESION | EXPRESION + division + EXPRESION | EXPRESION + incerteza + EXPRESION | apar + EXPRESION + cpar | EXPRESION + porc + EXPRESION | id | LLAMAR | numero | tString | tchar | trues | falses | menos + EXPRESION; // | distinto + EXPRESION /*-----------------para dibujar expresion-----------------*/ EXPRESION2.Rule = EXPRESION2 + or + EXPRESION2 | EXPRESION2 + and + EXPRESION2 | not + EXPRESION2 | EXPRESION2 + xor + EXPRESION2 | EXPRESION2 + diferente + EXPRESION2 | EXPRESION2 + mayor + EXPRESION2 | EXPRESION2 + menor + EXPRESION2 | EXPRESION2 + mayorigual + EXPRESION2 | EXPRESION2 + menorigual + EXPRESION2 | EXPRESION2 + mas + EXPRESION2 | EXPRESION2 + menos + EXPRESION2 | EXPRESION2 + por + EXPRESION2 | EXPRESION2 + potencia + EXPRESION2 | EXPRESION2 + division + EXPRESION2 | EXPRESION2 + incerteza + EXPRESION2 | apar + EXPRESION2 + cpar | EXPRESION2 + igualigual + EXPRESION2 | EXPRESION2 + porc + EXPRESION2 | id | LLAMAR | numero | tString | tchar | trues | falses | menos + EXPRESION; // | distinto + EXPRESION //---------------------> Definir Asociatividad RegisterOperators(1, Associativity.Left, "||"); //OR RegisterOperators(2, Associativity.Left, "&&"); //AND RegisterOperators(7, Associativity.Left, "!"); //NOT RegisterOperators(7, Associativity.Left, "|&"); //NOT RegisterOperators(5, Associativity.Left, "+", "-"); //MAS, MENOS RegisterOperators(6, Associativity.Left, "*", "/", "%"); //POR, DIVIDIR RegisterOperators(6, Associativity.Right, "^"); //POTENCIA ESTRUC.ErrorRule = SyntaxError + ESTRUC; ESTRUC2.ErrorRule = SyntaxError + ESTRUC2; ESTRUC3.ErrorRule = SyntaxError + ESTRUC3; }
public SLAngGrammer() : base() { StringLiteral stringLiteral = TerminalFactory.CreateCSharpString("StringLiteral"); StringLiteral charLiteral = TerminalFactory.CreateCSharpChar("CharLiteral"); NumberLiteral number = TerminalFactory.CreateCSharpNumber("Number"); IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier"); CommentTerminal delimitedComment = new CommentTerminal("DelimitedComment", "/[", "]/"); CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "--", "\r", "\n", "\u2085", "\u2028", "\u2029"); NonGrammarTerminals.Add(SingleLineComment); NonGrammarTerminals.Add(delimitedComment); #region Terminals KeyTerm colon = ToTerm(":"); KeyTerm dot = ToTerm("."); KeyTerm comma = ToTerm(","); KeyTerm propertyIs = ToTerm("->"); KeyTerm lbr = ToTerm("{"); KeyTerm rbr = ToTerm("}"); KeyTerm lpar = ToTerm("("); KeyTerm rpar = ToTerm(")"); KeyTerm scopeIn = ToTerm("::"); KeyTerm suchThat = ToTerm("|"); KeyTerm _package = ToTerm("package"); KeyTerm context = ToTerm("context"); KeyTerm body = ToTerm("body"); KeyTerm def = ToTerm("def"); KeyTerm derive = ToTerm("derive"); KeyTerm In = ToTerm("in"); KeyTerm inv = ToTerm("inv"); KeyTerm let = ToTerm("let"); KeyTerm post = ToTerm("post"); KeyTerm pre = ToTerm("pre"); KeyTerm Static = ToTerm("static"); KeyTerm self = ToTerm("self"); KeyTerm result = ToTerm("result"); KeyTerm equalsTo = ToTerm("="); KeyTerm _null = ToTerm("null"); KeyTerm invalid = ToTerm("invalid"); KeyTerm not = ToTerm("not"); KeyTerm and = ToTerm("and"); KeyTerm or = ToTerm("or"); KeyTerm xor = ToTerm("xor"); #endregion #region NonTerminal var specification = new NonTerminal("specification"); var specificationBody = new NonTerminal("specificationBody"); var package = new NonTerminal("package"); var packages = new NonTerminal("packages"); var oclPackage = new NonTerminal("oclPackage"); var emofOclPackage = new NonTerminal("emofOclPackage"); var packageBody = new NonTerminal("packageBody"); var packageBodyItem = new NonTerminal("packageBodyItem"); var contextExp = new NonTerminal("contextExp"); var classType = new NonTerminal("classType"); var enumeration = new NonTerminal("enumeration"); var primitive = new NonTerminal("primitive"); var primitiveType = new NonTerminal("primitiveType"); var primitiveTypes = new NonTerminal("primitiveTypes"); var delimitedIdentifier = new NonTerminal("delimitedIdentifier"); var classSignature = new NonTerminal("classSignature"); var classBody = new NonTerminal("classBody"); var classBodyItem = new NonTerminal("classBodyItem"); var invExp = new NonTerminal("invExp"); var functionDefination = new NonTerminal("functionDefination"); var attributeDiclaration = new NonTerminal("attributeDiclaration"); var emofAttributeDiclaration = new NonTerminal("emofAttributeDiclaration"); var oclAttributeDiclaration = new NonTerminal("oclAttributeDiclaration"); var type = new NonTerminal("type"); var expression = new NonTerminal("expression"); var customType = new NonTerminal("customType"); var collectionTpye = new NonTerminal("collectionTpye"); var fullType = new NonTerminal("fullType"); var globalType = new NonTerminal("globalType"); var setType = new NonTerminal("setType"); var orderedSetType = new NonTerminal("orderedSetType"); var sequenceType = new NonTerminal("sequenceType"); var bagType = new NonTerminal("bagType"); var functionSignature = new NonTerminal("functionSignature"); var functionSignatureBody = new NonTerminal("functionSignatureBody"); var functionBody = new NonTerminal("functionBody"); var oclFunctionSignature = new NonTerminal("oclFunctionSignature"); var emofFunctionSignature = new NonTerminal("emofFunctionSignature"); var argumentList = new NonTerminal("argumentList"); var variableDiclaration = new NonTerminal("variableDiclaration"); var emofFunctionBody = new NonTerminal("emofFunctionBody"); var oclFunctionBody = new NonTerminal("oclFunctionBody"); var singleValueCollectionMember = new NonTerminal("singleValueCollectionMember"); var booleanValueCollection = new NonTerminal("booleanValueCollection"); var letExp = new NonTerminal("letExp"); var ifThenElseExp = new NonTerminal("ifThenElseExp"); var collectionValueExp = new NonTerminal("collectionValueExp"); var sum = new NonTerminal("sum"); var size = new NonTerminal("size"); var first = new NonTerminal("first"); var last = new NonTerminal("last"); var at = new NonTerminal("at"); var indexOf = new NonTerminal("indexOf"); var countOperation = new NonTerminal("countOperation"); var maxOperation = new NonTerminal("maxOperation"); var minOperation = new NonTerminal("minOperation"); var valueExp = new NonTerminal("valueExp"); var includesOperation = new NonTerminal("includesOperation"); var includesAllOperation = new NonTerminal("includesAllOperation"); var excludesOperation = new NonTerminal("excludesOperation"); var excludesAllOperation = new NonTerminal("excludesAllOperation"); var isEmptyOperation = new NonTerminal("isEmptyOperation"); var notEmptyOperation = new NonTerminal("notEmptyOperation"); var specialIteratorBodyExp = new NonTerminal("specialIteratorBodyExp"); var existsExp = new NonTerminal("existsExp"); var forAllExp = new NonTerminal("forAllExp"); var isUniqueExp = new NonTerminal("isUniqueExp"); var anyExp = new NonTerminal("anyExp"); var oneExp = new NonTerminal("oneExp"); var selectExp = new NonTerminal("selectExp"); var includingOperation = new NonTerminal("includingOperation"); var excludingOperation = new NonTerminal("excludingOperation"); var collect = new NonTerminal("collect"); var subOrderedSet = new NonTerminal("subOrderedSet"); var symmetricDifference = new NonTerminal("symmetricDifference"); var prepend = new NonTerminal("prepend"); var append = new NonTerminal("append"); var insertAt = new NonTerminal("insertAt"); var intersection = new NonTerminal("intersection"); var union = new NonTerminal("union"); var asBag = new NonTerminal("asBag"); var asSequence = new NonTerminal("asSequence"); var asOrderdSet = new NonTerminal("asOrderdSet"); var asSet = new NonTerminal("asSet"); var flatten = new NonTerminal("flatten"); var subSequence = new NonTerminal("subSequence"); var andExp = new NonTerminal("andExp"); var orExp = new NonTerminal("orExp"); var notExp = new NonTerminal("notExp"); var xorExp = new NonTerminal("xorExp"); var impliesExp = new NonTerminal("impliesExp"); var comparisonOperator = new NonTerminal("comparisonOperator"); var arithmaticOperator = new NonTerminal("arithmaticOperator"); var oclInvExp = new NonTerminal("oclInvExp"); var emofInvExp = new NonTerminal("emofInvExp"); var operationContextExp = new NonTerminal("operationContextExp"); var attributeContextExp = new NonTerminal("attributeContextExp"); var classContextExp = new NonTerminal("classContextExp"); var classContextSignature = new NonTerminal("classContextSignature"); var attributeContextbody = new NonTerminal("attributeContextbody"); var attributeContextbodyItem = new NonTerminal("attributeContextbodyItem"); var deriveExp = new NonTerminal("deriveExp"); var initExp = new NonTerminal("initExp"); var operationContextBodyExps = new NonTerminal("operationContextBodyExps"); var operationContextSignature = new NonTerminal("operationContextSignature"); var operationContextBodyItem = new NonTerminal("operationContextBodyItem"); var preCondition = new NonTerminal("preCondition"); var postCondition = new NonTerminal("postCondition"); var bodyExp = new NonTerminal("bodyExp"); var iterateExp = new NonTerminal("iterateExp"); var productExp = new NonTerminal("productExp"); var tupleExp = new NonTerminal("tupleExp"); var rejectExp = new NonTerminal("rejectExp"); var collection = new NonTerminal("collection"); var tuplElementList = new NonTerminal("tuplElementList"); var tupleElement = new NonTerminal("tupleElement"); var binaryOperator = new NonTerminal("binaryOperator"); var parameterList = new NonTerminal("parameterList"); var structuralExp = new NonTerminal("structuralExp"); var setLiteral = new NonTerminal("setLiteral"); var bagLiteral = new NonTerminal("orderedSetLiteral"); var orderedSetLiteral = new NonTerminal(""); var sequenceLiteral = new NonTerminal("sequenceLiteral"); var tupleLiteral = new NonTerminal("tupleLiteral"); var literalList = new NonTerminal("literalList"); var iteratorList = new NonTerminal("iteratorList"); var iteratorInitializationList = new NonTerminal("iteratorInitializationList"); var iteratorInitialization = new NonTerminal("iteratorInitialization"); var collectionValue = new NonTerminal("collectionValue"); var ArrayType = new NonTerminal("ArrayType"); var binaryBooleanOperator = new NonTerminal("binaryBooleanOperator"); var oclIsTypeOf = new NonTerminal("oclIsTypeOf"); var ValueExp = new NonTerminal("ValueExp"); var unValueExp = new NonTerminal("unValueExp"); var instanceMemberAccess = new NonTerminal("instanceMemberAccess"); var instanceMathodAccess = new NonTerminal("instanceMathodAccess"); #endregion #region Rules #region specification specification.Rule = "specification" + identifier + lbr + specificationBody + rbr; specificationBody.Rule = MakePlusRule(packages, package); #endregion #region package package.Rule = oclPackage | emofOclPackage; oclPackage.Rule = _package + identifier + packageBody + "endpackage"; emofOclPackage.Rule = _package + identifier + lbr + packageBody + rbr; packageBody.Rule = MakeStarRule(packageBody, null, packageBodyItem); packageBodyItem.Rule = primitive | enumeration | classType | contextExp | package; #endregion #region primitive primitive.Rule = "primitive" + primitiveTypes + identifier + "IDENTICAL"; primitiveTypes.Rule = ToTerm("Real") | ToTerm("Integer") | ToTerm("String") | ToTerm("Boolean"); #endregion #region enumeration enumeration.Rule = "enumeration" + identifier + lbr + delimitedIdentifier + rbr; delimitedIdentifier.Rule = MakePlusRule(delimitedIdentifier, comma, identifier); #endregion #region class classType.Rule = classSignature + lbr + classBody + rbr; classSignature.Rule = ToTerm("class") + identifier | ToTerm("abstract") + ToTerm("class") + identifier | ToTerm("abstract") + ToTerm("class") + identifier + ToTerm("extends") + identifier | ToTerm("class") + identifier + ToTerm("extends") + type; classBody.Rule = MakeStarRule(classBody, classBodyItem); classBodyItem.Rule = attributeDiclaration | functionDefination | invExp; #endregion #region attribute attributeDiclaration.Rule = oclAttributeDiclaration | emofAttributeDiclaration; oclAttributeDiclaration.Rule = def + colon + identifier + type + ReduceHere() | def + colon + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere() | def + colon + "attr" + identifier + type + PreferShiftHere() + equalsTo + expression + ReduceHere() | def + colon + "attr" + identifier + type + ReduceHere(); emofAttributeDiclaration.Rule = identifier + colon + type + ReduceHere() | ToTerm("component") + identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere() | ToTerm("component") + identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere() | identifier + colon + type + equalsTo + expression + ReduceHere() | identifier + colon + type + ToTerm("opposite") + identifier + ReduceHere() | identifier + colon + type + ToTerm("unique") + ToTerm("opposite") + identifier + ReduceHere() | identifier + colon + type + ToTerm("unique") + ReduceHere(); #endregion #region type type.Rule = primitiveTypes | customType; customType.Rule = fullType | globalType | ArrayType | collectionTpye | tupleExp; fullType.Rule = identifier + scopeIn + fullType | identifier + ReduceHere(); globalType.Rule = PreferShiftHere() + scopeIn + fullType | PreferShiftHere() + scopeIn + ArrayType; ArrayType.Rule = fullType + "[" + "*" + "]" | fullType + "[" + identifier + "]" | fullType + "[" + number + "]" | fullType + "[" + number + comma + number + "]" | fullType + "[" + number + comma + "*" + "]"; collectionTpye.Rule = setType | orderedSetType | sequenceType | bagType | collection; setType.Rule = "Set(" + customType + ")"; orderedSetType.Rule = "OrderedSet(" + customType + ")"; sequenceType.Rule = "Sequence(" + customType + ")"; bagType.Rule = "Bag(" + customType + ")"; collection.Rule = "Collection(" + customType + ")"; tupleExp.Rule = "Tuple" + lbr + argumentList + rbr; #endregion #region function functionDefination.Rule = functionSignature + functionBody; functionSignature.Rule = oclFunctionSignature | emofFunctionSignature; oclFunctionSignature.Rule = def + colon + functionSignatureBody; functionSignatureBody.Rule = identifier + lpar + argumentList + rpar + colon + type | identifier + lpar + argumentList + rpar + colon + type + ToTerm("ordered") + ToTerm("unique") | identifier + lpar + argumentList + rpar + colon; argumentList.Rule = MakeStarRule(argumentList, comma, variableDiclaration); variableDiclaration.Rule = identifier + PreferShiftHere() + colon + type; emofFunctionSignature.Rule = functionSignatureBody; functionBody.Rule = oclFunctionBody | emofFunctionBody; oclFunctionBody.Rule = equalsTo + expression; emofFunctionBody.Rule = equalsTo + lbr + expression + rbr; #endregion #region expression expression.Rule = valueExp | structuralExp; #endregion #region valueExp valueExp.Rule = // ValueExp + ReduceHere() | unValueExp + ReduceHere() | valueExp + PreferShiftHere() + binaryOperator + valueExp | ToTerm("not") + valueExp | lpar + valueExp + rpar; #endregion #region unValueExp unValueExp.Rule = booleanValueCollection | ToTerm("false") | ToTerm("true") | collectionValue | tupleLiteral | singleValueCollectionMember | collectionValueExp | iterateExp | stringLiteral | charLiteral | number | self | oclIsTypeOf | unValueExp + lpar + parameterList + rpar | instanceMemberAccess | instanceMathodAccess | ToTerm("-") + number; #endregion #region ValueExp ValueExp.Rule = fullType + dot + instanceMemberAccess | globalType + dot + instanceMemberAccess | ValueExp + dot + identifier + lpar + parameterList + rpar; #endregion #region instanceMemberAccess instanceMemberAccess.Rule = MakePlusRule(instanceMemberAccess, dot, identifier); instanceMathodAccess.Rule = unValueExp + dot + identifier + lpar + parameterList + rpar; #endregion #region parameterList parameterList.Rule = MakeStarRule(parameterList, comma, expression); #endregion #region booleanExp booleanValueCollection.Rule = includesOperation | includesAllOperation | excludesOperation | excludesAllOperation | isEmptyOperation | notEmptyOperation | existsExp | forAllExp | isUniqueExp | anyExp | oneExp; #endregion #region oclBuildInMethods oclIsTypeOf.Rule = valueExp + dot + ToTerm("oclIsTypeOf") + lpar + type + rpar; #endregion #region binaryOperator binaryOperator.Rule = comparisonOperator | arithmaticOperator | binaryBooleanOperator; arithmaticOperator.Rule = ToTerm("/") | ToTerm("div") | ToTerm("*") | ToTerm("+") | ToTerm("-"); comparisonOperator.Rule = ToTerm(">") | ToTerm("<") | ToTerm(">=") | ToTerm("<=") | ToTerm("<>") | equalsTo; binaryBooleanOperator.Rule = ToTerm("and") | ToTerm("or") | ToTerm("xor") | ToTerm("implies"); #endregion #region booleanValueCollection includesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includes") + lpar + valueExp + rpar; includesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("includesAll") + lpar + identifier + rpar; excludesOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludes") + lpar + identifier + rpar; excludesAllOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excludesAll") + lpar + identifier + rpar; isEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isEmpty") + lpar + rpar; notEmptyOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("notEmpty") + lpar + rpar; existsExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("exists") + lpar + specialIteratorBodyExp + rpar; forAllExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("forAll") + lpar + specialIteratorBodyExp + rpar; isUniqueExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("isUnique") + lpar + specialIteratorBodyExp + rpar; anyExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("any") + lpar + specialIteratorBodyExp + rpar; oneExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("one") + lpar + specialIteratorBodyExp + rpar; specialIteratorBodyExp.Rule = delimitedIdentifier + colon + type + suchThat + valueExp | argumentList + suchThat + valueExp | valueExp; #endregion #region collectionValue collectionValue.Rule = setLiteral | bagLiteral | orderedSetLiteral | sequenceLiteral; setLiteral.Rule = "Set" + lbr + literalList + rbr | "Set" + lpar + type + rpar + lbr + literalList + rbr; bagLiteral.Rule = "Bag" + lbr + literalList + rbr | "Bag" + lpar + type + rpar + lbr + literalList + rbr; orderedSetLiteral.Rule = "OrderedSet" + lbr + literalList + rbr | "OrderedSet" + lpar + type + rpar + lbr + literalList + rbr; sequenceLiteral.Rule = "Sequence" + lbr + literalList + rbr | "Sequence" + lpar + type + rpar + lbr + literalList + rbr; literalList.Rule = MakeStarRule(literalList, comma, valueExp); tupleLiteral.Rule = "Tuple" + lbr + tuplElementList + rbr; tuplElementList.Rule = MakePlusRule(tuplElementList, comma, tupleElement); tupleElement.Rule = variableDiclaration + equalsTo + valueExp | identifier + equalsTo + valueExp; collectionValueExp.Rule = includingOperation | excludingOperation | selectExp | rejectExp | union | intersection | insertAt | append | prepend | symmetricDifference | subOrderedSet | collect | productExp | subSequence | flatten | asSet | asOrderdSet | asSequence | asBag; includingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("including") + lpar + identifier + rpar; excludingOperation.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("excluding") + lpar + identifier + rpar; selectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("select") + lpar + specialIteratorBodyExp + rpar; rejectExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("reject") + lpar + specialIteratorBodyExp + rpar; union.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("union") + lpar + valueExp + rpar; intersection.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("intersection") + lpar + identifier + rpar; insertAt.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("insertAt") + lpar + number + comma + identifier + rpar; append.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("append") + lpar + identifier + rpar; prepend.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("prepend") + lpar + identifier + rpar; symmetricDifference.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("symmetricDifference") + lpar + identifier + rpar; subOrderedSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subOrderedSet") + lpar + number + comma + number + rpar; collect.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + specialIteratorBodyExp + rpar | valueExp + PreferShiftHere() + propertyIs + ToTerm("collect") + lpar + identifier + rpar | valueExp + dot + identifier + lpar + argumentList + rpar | valueExp + PreferShiftHere() + propertyIs + identifier + lpar + argumentList + rpar; productExp.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("product") + lpar + identifier + rpar; subSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("subSequence") + lpar + number + comma + number + rpar; flatten.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("flatten") + lpar + rpar; asSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSet") + lpar + rpar; asOrderdSet.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asOrderdSet") + lpar + rpar; asSequence.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asSequence") + lpar + rpar; asBag.Rule = valueExp + PreferShiftHere() + propertyIs + ToTerm("asBag") + lpar + rpar; #endregion #region singleValueCollectionMember singleValueCollectionMember.Rule = maxOperation | minOperation | countOperation | at | indexOf | first | last | sum | size; maxOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "max" + lpar + rpar; minOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "min" + lpar + rpar; countOperation.Rule = valueExp + PreferShiftHere() + propertyIs + "count" + lpar + identifier + rpar; at.Rule = valueExp + PreferShiftHere() + propertyIs + "at" + lpar + identifier + rpar; indexOf.Rule = valueExp + PreferShiftHere() + propertyIs + "indexOf" + lpar + identifier + rpar; first.Rule = valueExp + PreferShiftHere() + propertyIs + "first" + lpar + rpar; last.Rule = valueExp + PreferShiftHere() + propertyIs + "last" + lpar + rpar; sum.Rule = valueExp + PreferShiftHere() + propertyIs + "sum" + lpar + rpar; size.Rule = valueExp + PreferShiftHere() + propertyIs + "size" + lpar + rpar; #endregion #region iterateExp iterateExp.Rule = valueExp + PreferShiftHere() + propertyIs + "iterate" + lpar + iteratorList + ";" + iteratorInitializationList + suchThat + expression + rpar; iteratorList.Rule = MakePlusRule(iteratorList, comma, variableDiclaration); iteratorInitializationList.Rule = MakePlusRule(iteratorInitializationList, comma, iteratorInitialization); iteratorInitialization.Rule = variableDiclaration + equalsTo + valueExp; #endregion #region structuralExp structuralExp.Rule = ifThenElseExp | letExp; #endregion #region ifThenElseExp ifThenElseExp.Rule = "if" + valueExp + "then" + expression + "endif" | "if" + valueExp + "then" + expression + "else" + expression + "endif"; #endregion #region letExp letExp.Rule = let + variableDiclaration + equalsTo + valueExp + In + expression | let + identifier + equalsTo + valueExp + In + expression; #endregion #region invExp invExp.Rule = oclInvExp | emofInvExp; oclInvExp.Rule = inv + identifier + colon + expression | inv + colon + expression; emofInvExp.Rule = "invariant" + lbr + expression + rbr; #endregion #region contextExp contextExp.Rule = classContextExp | attributeContextExp | operationContextExp; #endregion #region classContextExp classContextExp.Rule = classContextSignature + classBody; classContextSignature.Rule = context + type | context + identifier + colon + type; classBody.Rule = MakePlusRule(classBody, null, classBodyItem); classBodyItem.Rule = invExp | attributeDiclaration | functionDefination; #endregion #region attributeContextExp attributeContextExp.Rule = context + type + colon + type + attributeContextbody; attributeContextbody.Rule = MakePlusRule(attributeContextbody, null, attributeContextbodyItem); attributeContextbodyItem.Rule = initExp | deriveExp; #endregion #region initExp initExp.Rule = ToTerm("init") + colon + equalsTo + valueExp; #endregion #region deriveExp deriveExp.Rule = ToTerm("derive") + colon + expression; #endregion #region operationContextExp operationContextExp.Rule = operationContextSignature + invExp + operationContextBodyExps; operationContextSignature.Rule = context + customType + PreferShiftHere() + scopeIn + functionSignature; operationContextBodyExps.Rule = MakePlusRule(operationContextBodyExps, null, operationContextBodyItem); operationContextBodyItem.Rule = preCondition | bodyExp | postCondition; #endregion #region preCondition preCondition.Rule = pre + identifier + colon + valueExp | pre + colon + valueExp; #endregion #region bodyExp bodyExp.Rule = body + colon + expression; #endregion #region postCondition postCondition.Rule = post + colon + valueExp | post + identifier + colon + valueExp; #endregion #endregion #region Operator,punctuation MarkPunctuation(",", "(", ")", "{", "}", "[", "]", ":"); MarkMemberSelect(".", "->"); //dot, propertyIs); RegisterOperators(1, lpar, rpar); RegisterOperators(2, "let", "in"); RegisterOperators(3, letExp, In); RegisterOperators(4, dot, scopeIn); RegisterOperators(5, not); RegisterOperators(6, "*", "/"); RegisterOperators(7, letExp, In); RegisterOperators(8, dot, scopeIn); RegisterOperators(9, "+", "-"); RegisterOperators(10, "<", ">", "<=", ">="); RegisterOperators(11, "=", "<>"); RegisterOperators(12, and); RegisterOperators(12, "div", "implies"); RegisterOperators(13, or); RegisterOperators(14, xor); RegisterOperators(15, "=", "<>"); #endregion this.Root = specification; }
public GramaticaPython() : base(caseSensitive: false) { #region expresiones regulares var identificador = TerminalFactory.CreateCSharpIdentifier("identificador"); var numero = TerminalFactory.CreateCSharpNumber("numero"); var val_false = Constantes.falso; var val_true = Constantes.verdadero; StringLiteral cadena = new StringLiteral("cadena", "\""); var caracter = TerminalFactory.CreateCSharpChar(Constantes.caracter); CommentTerminal COMENT_BLOQUE = new CommentTerminal("COMENTARIO BLOQUE", "/*", "*/"); CommentTerminal COMENT_LINEA = new CommentTerminal("COMENTARIO LINEA", "//", "\n", "\r\n"); NonGrammarTerminals.Add(COMENT_BLOQUE); NonGrammarTerminals.Add(COMENT_LINEA); #endregion NonTerminal EXPRESION = new NonTerminal(Constantes.expresion); NonTerminal DECIMAL = new NonTerminal(Constantes.tipoDecimal); NonTerminal ENTERO = new NonTerminal(Constantes.tipoEntero); NonTerminal CADENA = new NonTerminal(Constantes.tipoCadena); NonTerminal CHAR = new NonTerminal(Constantes.tipoChar); NonTerminal BOOLEANO = new NonTerminal(Constantes.tipoBool); NonTerminal SIMB_ARIT = new NonTerminal(Constantes.simb_arit); NonTerminal SIMB_REL = new NonTerminal(Constantes.simb_rel); NonTerminal UNARIO = new NonTerminal(Constantes.unario); NonTerminal ID = new NonTerminal(Constantes.id); NonTerminal NEGATIVO = new NonTerminal(Constantes.negativo); NonTerminal RELACIONAL = new NonTerminal(Constantes.relacional); NonTerminal ARITMETICA = new NonTerminal(Constantes.aritmetica); NonTerminal LOGICA = new NonTerminal(Constantes.logica); NonTerminal LLAMADA = new NonTerminal(Constantes.llamada); NonTerminal POSVECTOR = new NonTerminal(Constantes.posvector); NonTerminal LISTAPUNTOS = new NonTerminal(Constantes.listapuntos); NonTerminal SIMB_LOG = new NonTerminal(Constantes.simb_log); NonTerminal MAS_MAS = new NonTerminal(Constantes.masmas); NonTerminal MENOS_MENOS = new NonTerminal(Constantes.menosmenos); NonTerminal ASIG_ARRAY = new NonTerminal(Constantes.asig_array); NonTerminal termino = new NonTerminal(Constantes.termino); NonTerminal L_IDS = new NonTerminal(Constantes.listaIds); NonTerminal SUMA = new NonTerminal(Constantes.suma); NonTerminal RESTA = new NonTerminal(Constantes.resta); NonTerminal MULTIPLICACION = new NonTerminal(Constantes.multiplicacion); NonTerminal DIVISION = new NonTerminal(Constantes.division); NonTerminal POTENCIA = new NonTerminal(Constantes.potencia); NonTerminal MENOR = new NonTerminal(Constantes.menor); NonTerminal MENORIGUAL = new NonTerminal(Constantes.menorIgual); NonTerminal MAYOR = new NonTerminal(Constantes.mayor); NonTerminal MAYORIGUAL = new NonTerminal(Constantes.mayorIgual); NonTerminal IGUALIGUAL = new NonTerminal(Constantes.igualIgual); NonTerminal DISTINTOA = new NonTerminal(Constantes.distintoA); NonTerminal XOR = new NonTerminal(Constantes.xorJava); NonTerminal AND = new NonTerminal(Constantes.andJava); NonTerminal NOT = new NonTerminal(Constantes.notJavaPython); NonTerminal OR = new NonTerminal(Constantes.orJava); NonTerminal INSTANCIA = new NonTerminal(Constantes.instancia); NonTerminal POSICION = new NonTerminal(Constantes.posicion); NonTerminal FILA = new NonTerminal(Constantes.fila); NonTerminal LPOSICIONES = new NonTerminal(Constantes.lposiciones); NonTerminal LEXPRESIONES = new NonTerminal(Constantes.lexpresiones); NonTerminal LFILAS = new NonTerminal(Constantes.lfilas); #region expresion POSICION.Rule = ToTerm("[") + EXPRESION + "]"; LPOSICIONES.Rule = MakePlusRule(LPOSICIONES, POSICION); FILA.Rule = ToTerm("{") + LEXPRESIONES + "}"; LEXPRESIONES.Rule = MakePlusRule(LEXPRESIONES, ToTerm(","), EXPRESION); LFILAS.Rule = MakePlusRule(LFILAS, ToTerm(","), FILA); DECIMAL.Rule = numero; ENTERO.Rule = numero; CADENA.Rule = cadena; ID.Rule = identificador; CHAR.Rule = caracter; BOOLEANO.Rule = ToTerm(val_false) | ToTerm(val_true); ARITMETICA.Rule = SUMA | RESTA | MULTIPLICACION | DIVISION | POTENCIA; RELACIONAL.Rule = MENOR | MAYOR | MENORIGUAL | MAYORIGUAL | DISTINTOA | IGUALIGUAL; LOGICA.Rule = XOR | OR | AND | NOT; SUMA.Rule = EXPRESION + ToTerm(Constantes.suma) + EXPRESION; RESTA.Rule = EXPRESION + ToTerm(Constantes.resta) + EXPRESION; MULTIPLICACION.Rule = EXPRESION + ToTerm(Constantes.multiplicacion) + EXPRESION; DIVISION.Rule = EXPRESION + ToTerm(Constantes.division) + EXPRESION; POTENCIA.Rule = EXPRESION + ToTerm(Constantes.potencia) + EXPRESION; MENOR.Rule = EXPRESION + ToTerm(Constantes.menor) + EXPRESION; MENORIGUAL.Rule = EXPRESION + ToTerm(Constantes.menorIgual) + EXPRESION; MAYOR.Rule = EXPRESION + ToTerm(Constantes.mayor) + EXPRESION; MAYORIGUAL.Rule = EXPRESION + ToTerm(Constantes.mayorIgual) + EXPRESION; IGUALIGUAL.Rule = EXPRESION + ToTerm(Constantes.igualIgual) + EXPRESION; DISTINTOA.Rule = EXPRESION + ToTerm(Constantes.distintoA) + EXPRESION; XOR.Rule = EXPRESION + ToTerm(Constantes.xorJava) + EXPRESION; AND.Rule = EXPRESION + ToTerm(Constantes.andJava) + EXPRESION; NOT.Rule = ToTerm(Constantes.notJavaPython) + EXPRESION; OR.Rule = EXPRESION + ToTerm(Constantes.orJava) + EXPRESION; INSTANCIA.Rule = Constantes.nuevo + identificador + "(" + LEXPRESIONES + ")" | Constantes.nuevo + identificador + "(" + ")"; UNARIO.Rule = MAS_MAS | MENOS_MENOS; MAS_MAS.Rule = identificador + ToTerm(Constantes.masmas); MENOS_MENOS.Rule = identificador + ToTerm(Constantes.menosmenos); NEGATIVO.Rule = ToTerm("-") + EXPRESION; termino.Rule = //ARITMETICA //| RELACIONAL // | LOGICA DECIMAL | ENTERO | ID | CADENA | BOOLEANO | CHAR; //| LLAMADA //| POSVECTOR //| UNARIO //| ToTerm("(") + EXPRESION + ")" //| NEGATIVO //| "{" + LFILAS + "}" //| INSTANCIA; LLAMADA.Rule = identificador + ToTerm("(") + LEXPRESIONES + ")" | identificador + ToTerm("(") + ")"; POSVECTOR.Rule = identificador + LPOSICIONES; L_IDS.Rule = MakePlusRule(L_IDS, ToTerm(","), identificador); EXPRESION.Rule = MakePlusRule(EXPRESION, ToTerm("."), termino); NonTerminal n = new NonTerminal("fdsfd"); n.Rule = EXPRESION; #endregion Root = n; }
public Gramatica() : base(caseSensitive: true) { #region Terminales //comentarios CommentTerminal simple = new CommentTerminal("simple", "//", "\n", "\r\n"); CommentTerminal multiple = new CommentTerminal("multiple", "/*", "*/"); NonGrammarTerminals.Add(simple); NonGrammarTerminals.Add(multiple); //tipos de datos var entero = ToTerm("Int", "Int"); var cadena = ToTerm("String", "String"); var doble = ToTerm("Double", "Double"); var booleano = ToTerm("Bool", "Bool"); var caracter = ToTerm("Char", "Char"); var vacio = ToTerm("Void", "Void"); //palabras reservadas var importar = ToTerm("Import", "Import"); var retornar = ToTerm("Return", "Return"); var imprimir = ToTerm("Print", "Print"); var principal = ToTerm("Main", "Main"); var comparar = ToTerm("CompareTo", "CompareTo"); var obtenerUsuario = ToTerm("GetUser", "GetUser"); //palabras reservadas de sentencias de control var si = ToTerm("If", "If"); var sino = ToTerm("Else", "Else"); var cambiar = ToTerm("Switch", "Switch"); var caso = ToTerm("Case", "Case"); var defecto = ToTerm("Default", "Default"); var quebrar = ToTerm("Break", "Break"); var para = ToTerm("For", "For"); var mientras = ToTerm("While", "While"); var hacer = ToTerm("Do", "Do"); //operadores aritmeticos var sumar = ToTerm("+", "+"); var restar = ToTerm("-", "-"); var multiplicar = ToTerm("*", "*"); var dividir = ToTerm("/", "/"); var modular = ToTerm("%", "%"); var elevar = ToTerm("^", "^"); var asignacion = ToTerm("=", "="); var incremento = ToTerm("++", "++"); var decremento = ToTerm("--", "--"); //operadores relacionales var menorQue = ToTerm("<", "<"); var mayorQue = ToTerm(">", ">"); var menorIgual = ToTerm("<=", "<="); var mayorIgual = ToTerm(">=", ">="); var equivalente = ToTerm("==", "=="); var noEquivalente = ToTerm("!=", "!="); //operadores logicos var and = ToTerm("&&", "&&"); var or = ToTerm("||", "||"); var xor = ToTerm("|&", "|&"); var not = ToTerm("!", "!"); //punctuation mark var finSentencia = ToTerm(";", ";"); var parentesisA = ToTerm("(", "("); var parentesisC = ToTerm(")", ")"); var llaveA = ToTerm("{", "{"); var llaveC = ToTerm("}", "}"); var dosPuntos = ToTerm(":", ":"); var corcheteA = ToTerm("[", "["); var corcheteC = ToTerm("]", "]"); var coma = ToTerm(",", ","); var punto = ToTerm(".", "."); //valores var numero = TerminalFactory.CreateCSharpNumber("numero"); var identificador = TerminalFactory.CreateCSharpIdentifier("identificador"); var cad = TerminalFactory.CreateCSharpString("cadena"); var falso = ToTerm("False", "falso"); var verdadero = ToTerm("True", "verdadero"); var car = TerminalFactory.CreateCSharpChar("caracter"); #endregion #region Precedencias y puntuaciones this.MarkPunctuation(finSentencia, parentesisA, parentesisC, llaveA, llaveC, dosPuntos, coma, punto); RegisterOperators(1, Associativity.Left, sumar, restar); RegisterOperators(2, Associativity.Left, multiplicar, modular, dividir); RegisterOperators(3, Associativity.Right, elevar); RegisterOperators(5, equivalente, noEquivalente, menorQue, menorIgual, mayorQue, mayorIgual); RegisterOperators(6, Associativity.Left, or); RegisterOperators(7, Associativity.Left, xor); RegisterOperators(8, Associativity.Left, and); RegisterOperators(9, Associativity.Left, not); RegisterOperators(10, parentesisA, parentesisC); #endregion #region No Terminales NonTerminal INICIO = new NonTerminal("INICIO"); NonTerminal DECLARACION = new NonTerminal("DECLARACION"); NonTerminal PRINCIPAL = new NonTerminal("PRINCIPAL"); NonTerminal ASIGNACION = new NonTerminal("ASIGNACION"); NonTerminal WHILE = new NonTerminal("WHILE"); NonTerminal DO_WHILE = new NonTerminal("DO_WHILE"); NonTerminal IF = new NonTerminal("IF"); NonTerminal ELSE = new NonTerminal("ELSE"); NonTerminal FOR = new NonTerminal("FOR"); NonTerminal SWITCH = new NonTerminal("SWITCH"); NonTerminal LISTA_ACCIONES = new NonTerminal("LISTA_ACCIONES"); NonTerminal ACCION = new NonTerminal("ACCION"); NonTerminal IMPORT = new NonTerminal("IMPORT"); NonTerminal ENCABEZADO = new NonTerminal("ENCABEZADO"); NonTerminal TIPO_DATO = new NonTerminal("TIPO_DATO"); NonTerminal LISTA_VARS = new NonTerminal("LISTA_VARS"); NonTerminal EXPRESION_LOGICA = new NonTerminal("EXPRESION_LOGICA"); NonTerminal EXPRESION_RELACIONAL = new NonTerminal("EXPRESION_RELACIONAL"); NonTerminal EXPRESION = new NonTerminal("EXPRESION"); NonTerminal DECLARACION_ARREGLO = new NonTerminal("DECLARACION_ARREGLO"); NonTerminal ASIGNACION_ARREGLO = new NonTerminal("ASIGNACION_ARREGLO"); NonTerminal LISTA_DATOS = new NonTerminal("LISTA_DATOS"); NonTerminal ASIGNACION_POSICION = new NonTerminal("ASIGNACION_POSICION"); NonTerminal SENTENCIA = new NonTerminal("SENTENCIA"); NonTerminal LISTA_SENTENCIAS = new NonTerminal("LISTA_SENTENCIAS"); NonTerminal PROCEDIMIENTO = new NonTerminal("PROCEDIMIENTO"); NonTerminal LISTA_PARAMETROS = new NonTerminal("LISTA_PARAMETROS"); NonTerminal PARAMETRO = new NonTerminal("PARAMETRO"); NonTerminal FUNCION_PRINT = new NonTerminal("FUNCION_PRINT"); NonTerminal FUNCION_COMPARAR = new NonTerminal("FUNCION_COMPARAR"); NonTerminal RETORNO = new NonTerminal("RETORNO"); NonTerminal OBTENER_USUARIO = new NonTerminal("OBTENER_USUARIO"); NonTerminal OPERADOR_RELACIONAL = new NonTerminal("OPERADOR_RELACIONAL"); NonTerminal LLAMADA = new NonTerminal("LLAMADA"); NonTerminal DINCREMENTO = new NonTerminal("DINCREMENTO"); NonTerminal CASE = new NonTerminal("CASE"); NonTerminal DEFAULT = new NonTerminal("DEFAULT"); NonTerminal CUERPO_SWITCH = new NonTerminal("CUERPO_SWITCH"); NonTerminal LISTA_CASE = new NonTerminal("LISTA_CASE"); NonTerminal VALOR = new NonTerminal("VALOR"); NonTerminal OPCION_SENTENCIAS = new NonTerminal("OPCION_SENTENCIAS"); #endregion #region reglas gramaticales //Encabezado ENCABEZADO.Rule = MakePlusRule(ENCABEZADO, IMPORT) | IMPORT; IMPORT.Rule = importar + cad + finSentencia; // Cuerpo principal this.Root = INICIO; INICIO.Rule = ENCABEZADO + LISTA_ACCIONES | ENCABEZADO | LISTA_ACCIONES; LISTA_ACCIONES.Rule = MakePlusRule(LISTA_ACCIONES, ACCION) | ACCION; ACCION.Rule = DECLARACION | PROCEDIMIENTO | PRINCIPAL | ASIGNACION | DECLARACION_ARREGLO | ASIGNACION_POSICION | DINCREMENTO + finSentencia | FUNCION_PRINT + finSentencia; PRINCIPAL.Rule = principal + dosPuntos + vacio + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | principal + dosPuntos + TIPO_DATO + parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | principal + dosPuntos + vacio + parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | principal + dosPuntos + TIPO_DATO + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC; // Sintaxis de las Declaraciones TIPO_DATO.Rule = entero | doble | cadena | caracter | booleano; LISTA_VARS.Rule = MakePlusRule(LISTA_VARS, coma, identificador); DECLARACION.Rule = LISTA_VARS + dosPuntos + TIPO_DATO + asignacion + EXPRESION_LOGICA + finSentencia | identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION_LOGICA + finSentencia | LISTA_VARS + dosPuntos + TIPO_DATO + finSentencia | identificador + dosPuntos + TIPO_DATO + finSentencia; // Sintaxis de las Asignaciones ASIGNACION.Rule = identificador + asignacion + EXPRESION_LOGICA + finSentencia | identificador + asignacion + llaveA + LISTA_DATOS + llaveC + finSentencia; // Sintaxis de los arreglos DECLARACION_ARREGLO.Rule = identificador + dosPuntos + TIPO_DATO + corcheteA + EXPRESION + corcheteC + finSentencia | identificador + dosPuntos + TIPO_DATO + corcheteA + EXPRESION + corcheteC + asignacion + ASIGNACION_ARREGLO + finSentencia; LISTA_DATOS.Rule = MakePlusRule(LISTA_DATOS, coma, EXPRESION_LOGICA) | EXPRESION_LOGICA; ASIGNACION_ARREGLO.Rule = llaveA + LISTA_DATOS + llaveC | identificador; ASIGNACION_POSICION.Rule = identificador + corcheteA + EXPRESION + corcheteC + asignacion + EXPRESION_LOGICA + finSentencia; //Sintaxis de Metodos y Funciones PROCEDIMIENTO.Rule = identificador + dosPuntos + TIPO_DATO + parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | identificador + dosPuntos + vacio + parentesisA + LISTA_PARAMETROS + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | identificador + dosPuntos + TIPO_DATO + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC | identificador + dosPuntos + vacio + parentesisA + parentesisC + llaveA + OPCION_SENTENCIAS + llaveC; PARAMETRO.Rule = identificador + dosPuntos + TIPO_DATO | identificador + dosPuntos + TIPO_DATO + corcheteA + corcheteC; LISTA_PARAMETROS.Rule = MakePlusRule(LISTA_PARAMETROS, coma, PARAMETRO) | PARAMETRO; LISTA_SENTENCIAS.Rule = MakePlusRule(LISTA_SENTENCIAS, SENTENCIA) | SENTENCIA; OPCION_SENTENCIAS.Rule = LISTA_SENTENCIAS | Empty; SENTENCIA.Rule = DECLARACION | ASIGNACION | DECLARACION_ARREGLO | ASIGNACION_POSICION | IF | FOR | SWITCH | WHILE | DO_WHILE | FUNCION_PRINT + finSentencia | DINCREMENTO + finSentencia | LLAMADA + finSentencia | quebrar + finSentencia | RETORNO; RETORNO.Rule = retornar + EXPRESION_LOGICA + finSentencia | retornar + finSentencia; //Funciones nativas FUNCION_PRINT.Rule = imprimir + parentesisA + EXPRESION_LOGICA + parentesisC; FUNCION_COMPARAR.Rule = punto + comparar + parentesisA + EXPRESION + parentesisC; OBTENER_USUARIO.Rule = obtenerUsuario + parentesisA + parentesisC; //If Else IF.Rule = si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC | si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC | si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC + ELSE | si + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC + ELSE; ELSE.Rule = sino + llaveA + LISTA_SENTENCIAS + llaveC | sino + llaveA + llaveC; //While WHILE.Rule = mientras + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC | mientras + parentesisA + EXPRESION_LOGICA + parentesisC + llaveA + llaveC; //Do While DO_WHILE.Rule = hacer + llaveA + LISTA_SENTENCIAS + llaveC + mientras + parentesisA + EXPRESION_LOGICA + parentesisC + finSentencia | hacer + llaveA + llaveC + mientras + parentesisA + EXPRESION_LOGICA + parentesisC + finSentencia; //For FOR.Rule = para + parentesisA + identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION + finSentencia + EXPRESION_LOGICA + finSentencia + DINCREMENTO + parentesisC + llaveA + LISTA_SENTENCIAS + llaveC | para + parentesisA + identificador + dosPuntos + TIPO_DATO + asignacion + EXPRESION + finSentencia + EXPRESION_LOGICA + finSentencia + DINCREMENTO + parentesisC + llaveA + llaveC; DINCREMENTO.Rule = identificador + incremento | identificador + decremento; //Switch SWITCH.Rule = cambiar + parentesisA + identificador + parentesisC + llaveA + CUERPO_SWITCH + llaveC; CUERPO_SWITCH.Rule = LISTA_CASE | LISTA_CASE + DEFAULT; LISTA_CASE.Rule = MakePlusRule(LISTA_CASE, CASE) | CASE; CASE.Rule = caso + VALOR + dosPuntos + LISTA_SENTENCIAS | caso + VALOR + dosPuntos; VALOR.Rule = cad | numero; DEFAULT.Rule = defecto + dosPuntos + LISTA_SENTENCIAS | defecto + dosPuntos; //Llamadas LLAMADA.Rule = identificador + parentesisA + parentesisC | identificador + parentesisA + LISTA_DATOS + parentesisC; // Expresiones EXPRESION_LOGICA.Rule = EXPRESION_LOGICA + and + EXPRESION_LOGICA | EXPRESION_LOGICA + or + EXPRESION_LOGICA | EXPRESION_LOGICA + xor + EXPRESION_LOGICA | not + EXPRESION_LOGICA | EXPRESION_RELACIONAL; EXPRESION_RELACIONAL.Rule = EXPRESION + OPERADOR_RELACIONAL + EXPRESION | EXPRESION; OPERADOR_RELACIONAL.Rule = menorQue | menorIgual | mayorQue | mayorIgual | equivalente | noEquivalente; EXPRESION.Rule = EXPRESION + sumar + EXPRESION | EXPRESION + restar + EXPRESION | EXPRESION + multiplicar + EXPRESION | EXPRESION + dividir + EXPRESION | EXPRESION + modular + EXPRESION | EXPRESION + elevar + EXPRESION | restar + EXPRESION | parentesisA + EXPRESION_LOGICA + parentesisC | identificador + corcheteA + EXPRESION + corcheteC | identificador | LLAMADA | OBTENER_USUARIO | verdadero | falso | cad | car | numero | identificador + FUNCION_COMPARAR | identificador + corcheteA + EXPRESION + corcheteC + FUNCION_COMPARAR; #endregion }
//TerminalSet _skipTokensInPreview = new TerminalSet(); //used in token preview for conflict resolution public ExpressionGrammar() { //this.GrammarComments = "NOTE: This grammar is just a demo, and it is a broken demo.\r\n" + // "Demonstrates token preview technique to help parser resolve conflicts.\r\n"; #region Lexical structure StringLiteral StringLiteral = TerminalFactory.CreateCSharpString("StringLiteral"); StringLiteral CharLiteral = TerminalFactory.CreateCSharpChar("CharLiteral"); NumberLiteral Number = TerminalFactory.CreateCSharpNumber("Number"); IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("Identifier"); CommentTerminal SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029"); CommentTerminal DelimitedComment = new CommentTerminal("DelimitedComment", "/*", "*/"); NonGrammarTerminals.Add(SingleLineComment); NonGrammarTerminals.Add(DelimitedComment); //Temporarily, treat preprocessor instructions like comments CommentTerminal ppInstruction = new CommentTerminal("ppInstruction", "#", "\n"); NonGrammarTerminals.Add(ppInstruction); //Symbols Terminal colon = new Terminal(":"); //ToTerm(":", "colon"); Terminal semi = ToTerm(";"); //, "semi"); NonTerminal semi_opt = new NonTerminal("semi?"); semi_opt.Rule = Empty | semi; Terminal dot = ToTerm("."); //, "dot"); Terminal comma = ToTerm(","); //, "comma"); NonTerminal comma_opt = new NonTerminal("comma_opt", Empty | comma); NonTerminal commas_opt = new NonTerminal("commas_opt"); commas_opt.Rule = MakeStarRule(commas_opt, null, comma); Terminal qmark = ToTerm("?");//, "qmark"); NonTerminal qmark_opt = new NonTerminal("qmark_opt", Empty | qmark); Terminal Lbr = ToTerm("{"); Terminal Rbr = ToTerm("}"); Terminal Lpar = ToTerm("("); Terminal Rpar = ToTerm(")"); Terminal tgoto = ToTerm("goto"); Terminal yld = ToTerm("yield"); Terminal Lparx = ToTerm("(*"); #endregion #region NonTerminals //B.2.1. Basic concepts var qual_name_with_targs = new NonTerminal("qual_name_with_targs"); var base_type_list = new NonTerminal("base_type_list"); var generic_dimension_specifier = new NonTerminal("generic_dimension_specifier"); var qual_name_segment = new NonTerminal("qual_name_segment"); var qual_name_segments_opt = new NonTerminal("qual_name_segments_opt"); var type_or_void = new NonTerminal("type_or_void", "type or void"); var builtin_type = new NonTerminal("builtin_type", "built-in type"); var type_ref_list = new NonTerminal("type_ref_list"); var identifier_ext = new NonTerminal("identifier_ext"); var identifier_or_builtin = new NonTerminal("identifier_or_builtin"); //B.2.2. Types var type_ref = new NonTerminal("type_ref"); var type_argument_list = new NonTerminal("type_argument_list"); var typearg_or_gendimspec_list = new NonTerminal("typearg_or_gendimspec_list"); var type_argument_list_opt = new NonTerminal("type_argument_list_opt"); var integral_type = new NonTerminal("integral_type"); //B.2.4. Expressions var argument = new NonTerminal("argument"); var argument_list = new NonTerminal("argument_list"); var argument_list_opt = new NonTerminal("argument_list_opt"); var expression = new NonTerminal("expression", "expression"); var expression_list = new NonTerminal("expression_list"); var expression_opt = new NonTerminal("expression_opt"); var conditional_expression = new NonTerminal("conditional_expression"); var lambda_expression = new NonTerminal("lambda_expression"); var query_expression = new NonTerminal("query_expression"); var unary_operator = new NonTerminal("unary_operator"); var assignment_operator = new NonTerminal("assignment_operator"); var primary_expression = new NonTerminal("primary_expression"); var unary_expression = new NonTerminal("unary_expression"); var pre_incr_decr_expression = new NonTerminal("pre_incr_decr_expression"); var post_incr_decr_expression = new NonTerminal("post_incr_decr_expression"); var literal = new NonTerminal("literal"); var parenthesized_expression = new NonTerminal("parenthesized_expression"); var member_access = new NonTerminal("member_access"); var member_access_segment = new NonTerminal("member_access_segment"); var member_access_segments_opt = new NonTerminal("member_access_segments_opt"); var array_indexer = new NonTerminal("array_indexer"); var argument_list_par = new NonTerminal("argument_list_par"); var argument_list_par_opt = new NonTerminal("argument_list_par_opt"); var incr_or_decr = new NonTerminal("incr_or_decr"); var incr_or_decr_opt = new NonTerminal("incr_or_decr_opt"); var creation_args = new NonTerminal("creation_args"); var object_creation_expression = new NonTerminal("object_creation_expression"); var anonymous_object_creation_expression = new NonTerminal("anonymous_object_creation_expression"); var typeof_expression = new NonTerminal("typeof_expression"); var checked_expression = new NonTerminal("checked_expression"); var unchecked_expression = new NonTerminal("unchecked_expression"); var default_value_expression = new NonTerminal("default_value_expression"); //var anonymous_method_expression = new NonTerminal("anonymous_method_expression"); var elem_initializer = new NonTerminal("elem_initializer"); var elem_initializer_list = new NonTerminal("elem_initializer_list"); var elem_initializer_list_ext = new NonTerminal("elem_initializer_list_ext"); var initializer_value = new NonTerminal("initializer_value"); var anonymous_object_initializer = new NonTerminal("anonymous_object_initializer"); var member_declarator = new NonTerminal("member_declarator"); var member_declarator_list = new NonTerminal("member_declarator_list"); var unbound_type_name = new NonTerminal("unbound_type_name"); var generic_dimension_specifier_opt = new NonTerminal("generic_dimension_specifier_opt"); var bin_op_expression = new NonTerminal("bin_op_expression"); var typecast_expression = new NonTerminal("typecast_expression"); var bin_op = new NonTerminal("bin_op", "operator symbol"); //B.2.5. Statements var statement = new NonTerminal("statement", "statement"); var statement_list = new NonTerminal("statement_list"); var statement_list_opt = new NonTerminal("statement_list_opt"); var declaration_statement = new NonTerminal("declaration_statement"); var embedded_statement = new NonTerminal("embedded_statement"); var selection_statement = new NonTerminal("selection_statement"); var iteration_statement = new NonTerminal("iteration_statement"); var block = new NonTerminal("block"); var statement_expression = new NonTerminal("statement_expression"); var statement_expression_list = new NonTerminal("statement_expression_list"); var local_variable_declaration = new NonTerminal("local_variable_declaration"); //var local_constant_declaration = new NonTerminal("local_constant_declaration"); var local_variable_type = new NonTerminal("local_variable_type"); var local_variable_declarator = new NonTerminal("local_variable_declarator"); //var local_variable_declarators = new NonTerminal("local_variable_declarators"); var if_statement = new NonTerminal("if_statement"); var else_clause_opt = new NonTerminal("else_clause_opt"); var while_statement = new NonTerminal("while_statement"); var do_statement = new NonTerminal("do_statement"); var for_statement = new NonTerminal("for_statement"); var for_initializer_opt = new NonTerminal("for_initializer_opt"); var for_condition_opt = new NonTerminal("for_condition_opt"); var for_iterator_opt = new NonTerminal("for_iterator_opt"); var break_statement = new NonTerminal("break_statement"); var continue_statement = new NonTerminal("continue_statement"); var return_statement = new NonTerminal("return_statement"); var identifier_opt = new NonTerminal("identifier_opt"); var resource_acquisition = new NonTerminal("resource_acquisition"); //namespaces, compilation units var qualified_identifier = new NonTerminal("qualified_identifier"); var qualified_alias_member = new NonTerminal("qualified_alias_member"); //B.2.9. Arrays var rank_specifier = new NonTerminal("rank_specifier"); var rank_specifiers = new NonTerminal("rank_specifiers"); var rank_specifiers_opt = new NonTerminal("rank_specifiers_opt"); var dim_specifier = new NonTerminal("dim_specifier"); var dim_specifier_opt = new NonTerminal("dim_specifier_opt"); var list_initializer = new NonTerminal("array_initializer"); var list_initializer_opt = new NonTerminal("array_initializer_opt"); var new_opt = new NonTerminal("new_opt"); #endregion #region operators, punctuation and delimiters RegisterOperators(1, "||"); RegisterOperators(2, "&&"); RegisterOperators(3, "|"); RegisterOperators(4, "^"); RegisterOperators(5, "&"); RegisterOperators(6, "==", "!="); RegisterOperators(7, "<", ">", "<=", ">=", "is", "as"); RegisterOperators(8, "<<", ">>"); RegisterOperators(9, "+", "-"); RegisterOperators(10, "*", "/", "%"); RegisterOperators(-3, "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="); RegisterOperators(-2, "?"); RegisterOperators(-1, "??"); this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":"); //this.MarkTransient(/*namespace_member_declaration, member_declaration, type_declaration,*/ statement, embedded_statement, expression, // literal, bin_op, primary_expression, expression); //this.AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>="); //this.AddTermsReportGroup("typename", "bool", "decimal", "float", "double", "string", "object", // "sbyte", "byte", "short", "ushort", "int", "uint", "long", "ulong", "char"); //this.AddTermsReportGroup("statement", "if", "switch", "do", "while", "for", "foreach", "continue", "goto", "return", "try", "yield", // "break", "throw", "unchecked", "using"); //this.AddTermsReportGroup("type declaration", "public", "private", "protected", "static", "internal", "sealed", "abstract", "partial", // "class", "struct", "delegate", "interface", "enum"); //this.AddTermsReportGroup("member declaration", "virtual", "override", "readonly", "volatile", "extern"); //this.AddTermsReportGroup("constant", Number, StringLiteral, CharLiteral); //this.AddTermsReportGroup("constant", "true", "false", "null"); //this.AddTermsReportGroup("unary operator", "+", "-", "!", "~"); //this.AddToNoReportGroup(comma, semi); //this.AddToNoReportGroup("var", "const", "new", "++", "--", "this", "base", "checked", "lock", "typeof", "default", // "{", "}", "["); // #endregion #region "<" conflict resolution //var gen_lt = new NonTerminal("gen_lt"); //gen_lt.Rule = CustomActionHere(this.ResolveLessThanConflict) + "<"; #endregion // RULES //B.2.1. Basic concepts //qual_name_with_targs is an alias for namespace-name, namespace-or-type-name, type-name, generic_dimension_specifier.Rule = /*gen_lt +*/ commas_opt + ">"; qual_name_segments_opt.Rule = MakeStarRule(qual_name_segments_opt, null, qual_name_segment); identifier_or_builtin.Rule = identifier | builtin_type; identifier_ext.Rule = identifier_or_builtin | "this" | "base"; qual_name_segment.Rule = dot + identifier | "::" + identifier | type_argument_list; //generic_dimension_specifier.Rule = lt + commas_opt + ">"; generic_dimension_specifier.Rule = /*gen_lt +*/ commas_opt + ">"; qual_name_with_targs.Rule = identifier_or_builtin + qual_name_segments_opt; type_argument_list.Rule = /*gen_lt +*/ type_ref_list + ">"; type_argument_list_opt.Rule = Empty | type_argument_list; typearg_or_gendimspec_list.Rule = type_argument_list | generic_dimension_specifier_opt; //B.2.2. Types type_or_void.Rule = /*qual_name_with_targs |*/ "void"; builtin_type.Rule = integral_type | "bool" | "decimal" | "float" | "double" | "string" | "object"; type_ref.Rule = type_or_void + qmark_opt + rank_specifiers_opt + typearg_or_gendimspec_list; type_ref_list.Rule = MakePlusRule(type_ref_list, comma, type_ref); var comma_list_opt = new NonTerminal("comma_list_opt"); comma_list_opt.Rule = MakeStarRule(comma_list_opt, null, comma); rank_specifier.Rule = "[" + comma_list_opt + "]"; rank_specifiers.Rule = MakePlusRule(rank_specifiers, null, rank_specifier); rank_specifiers_opt.Rule = rank_specifiers.Q(); integral_type.Rule = ToTerm("sbyte") | "byte" | "short" | "ushort" | "int" | "uint" | "long" | "ulong" | "char"; //B.2.4. Expressions argument.Rule = expression | "ref" + identifier | "out" + identifier; argument_list.Rule = MakePlusRule(argument_list, comma, argument); argument_list_opt.Rule = Empty | argument_list; expression.Rule = conditional_expression | bin_op_expression | typecast_expression | primary_expression; expression_opt.Rule = Empty | expression; expression_list.Rule = MakePlusRule(expression_list, comma, expression); unary_operator.Rule = ToTerm("+") | "-" | "!" | "~" | "*"; assignment_operator.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>="; conditional_expression.Rule = expression /*+ PreferShiftHere()*/ + qmark + expression + colon + expression;// + ReduceThis(); bin_op_expression.Rule = expression + bin_op + expression; typecast_expression.Rule = parenthesized_expression + primary_expression; primary_expression.Rule = literal | unary_expression | parenthesized_expression | member_access | pre_incr_decr_expression | post_incr_decr_expression | object_creation_expression | anonymous_object_creation_expression | typeof_expression | checked_expression | unchecked_expression | default_value_expression /*| anonymous_method_expression*/; unary_expression.Rule = unary_operator + primary_expression; dim_specifier.Rule = "[" + expression_list + "]"; dim_specifier_opt.Rule = dim_specifier.Q(); literal.Rule = Number | StringLiteral | CharLiteral | "true" | "false" | "null"; parenthesized_expression.Rule = Lpar + expression + Rpar; pre_incr_decr_expression.Rule = incr_or_decr + member_access; post_incr_decr_expression.Rule = member_access + incr_or_decr; //joined invocation_expr and member_access; for member access left the most general variant member_access.Rule = identifier_ext + member_access_segments_opt; member_access_segments_opt.Rule = MakeStarRule(member_access_segments_opt, null, member_access_segment); member_access_segment.Rule = dot + identifier | array_indexer | argument_list_par | type_argument_list; array_indexer.Rule = "[" + expression_list + "]"; argument_list_par.Rule = Lpar + argument_list_opt + Rpar; argument_list_par_opt.Rule = Empty | argument_list_par; list_initializer.Rule = Lbr + elem_initializer_list_ext + Rbr; list_initializer_opt.Rule = list_initializer.Q(); elem_initializer.Rule = initializer_value | identifier + "=" + initializer_value; elem_initializer_list.Rule = MakePlusRule(elem_initializer_list, comma, elem_initializer); elem_initializer_list_ext.Rule = Empty | elem_initializer_list + comma_opt; initializer_value.Rule = expression | list_initializer; //delegate, anon-object, object object_creation_expression.Rule = "new" + qual_name_with_targs + qmark_opt + creation_args + list_initializer_opt; creation_args.Rule = dim_specifier | rank_specifier | argument_list_par; anonymous_object_creation_expression.Rule = "new" + anonymous_object_initializer; anonymous_object_initializer.Rule = Lbr + Rbr | Lbr + member_declarator_list + comma_opt + Rbr; member_declarator.Rule = expression | identifier + "=" + expression; member_declarator_list.Rule = MakePlusRule(member_declarator_list, comma, member_declarator); //typeof typeof_expression.Rule = "typeof" + Lpar + type_ref + Rpar; generic_dimension_specifier_opt.Rule = Empty /*| gen_lt*/ + commas_opt + ">"; //checked, unchecked checked_expression.Rule = "checked" + parenthesized_expression; unchecked_expression.Rule = "unchecked" + parenthesized_expression; //default-value default_value_expression.Rule = "default" + Lpar + type_ref + Rpar; bin_op.Rule = ToTerm("<") | "||" | "&&" | "|" | "^" | "&" | "==" | "!=" | ">" | "<=" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%" | "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^=" | "<<=" | ">>=" | "is" | "as" | "??"; //Queries query_expression.Rule = "from"; //B.2.5. Statements statement.Rule = /*labeled_statement |*/ declaration_statement | embedded_statement; statement.ErrorRule = SyntaxError + semi; //skip all until semicolon statement_list.Rule = MakePlusRule(statement_list, null, statement); statement_list_opt.Rule = Empty | statement_list; declaration_statement.Rule = local_variable_declaration + semi /*| local_constant_declaration*/ + semi; local_variable_declaration.Rule = local_variable_type /*+ local_variable_declarators*/; local_variable_type.Rule = member_access | "var"; // | builtin_type; //to fix the conflict, changing to member-access here local_variable_declarator.Rule = identifier | identifier + "=" + initializer_value; //local_variable_declarators.Rule = MakePlusRule(local_variable_declarators, comma, local_variable_declarator); //local_constant_declaration.Rule = "const" + type_ref /*+ constant_declarators*/; //embedded_statement embedded_statement.Rule = block | semi /*empty_statement*/ | statement_expression + semi | selection_statement | iteration_statement /* | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement*/; block.Rule = Lbr + statement_list_opt + Rbr; //selection (if and switch) selection_statement.Rule = if_statement /*| switch_statement*/; if_statement.Rule = ToTerm("if") + Lpar + expression + Rpar + embedded_statement + else_clause_opt; else_clause_opt.Rule = Empty /*| PreferShiftHere()*/ + "else" + embedded_statement; iteration_statement.Rule = while_statement | do_statement | for_statement /*| foreach_statement*/; while_statement.Rule = "while" + parenthesized_expression + embedded_statement; do_statement.Rule = "do" + embedded_statement + "while" + parenthesized_expression + semi; for_statement.Rule = "for" + Lpar + for_initializer_opt + semi + for_condition_opt + semi + for_iterator_opt + Rpar + embedded_statement; for_initializer_opt.Rule = Empty | local_variable_declaration | statement_expression_list; for_condition_opt.Rule = Empty | expression; for_iterator_opt.Rule = Empty | statement_expression_list; break_statement.Rule = "break" + semi; continue_statement.Rule = "continue" + semi; return_statement.Rule = "return" + expression_opt + semi; identifier_opt.Rule = Empty | identifier; resource_acquisition.Rule = local_variable_declaration | expression; statement_expression.Rule = object_creation_expression | member_access | member_access + assignment_operator + expression | pre_incr_decr_expression | post_incr_decr_expression ; statement_expression_list.Rule = MakePlusRule(statement_expression_list, comma, statement_expression); incr_or_decr_opt.Rule = Empty | ToTerm("++") | "--"; incr_or_decr.Rule = ToTerm("++") | "--"; //B.2.6. Namespaces this.Root = block; qualified_identifier.Rule = MakePlusRule(qualified_identifier, dot, identifier); base_type_list.Rule = MakePlusRule(base_type_list, comma, qual_name_with_targs); new_opt.Rule = Empty | "new"; //_skipTokensInPreview.UnionWith(new Terminal[] { dot, identifier, comma, ToTerm("::"), comma, ToTerm("["), ToTerm("]") }); }
public AnalizadorTree() : base(caseSensitive: false) { //Comentarios CommentTerminal COMENTARIO_SIMPLE = new CommentTerminal("comentario_simple", "##", "\n", "\r\n"); CommentTerminal COMENTARIO_MULT = new CommentTerminal("comentario_mult", "{--", "--}"); NonGrammarTerminals.Add(COMENTARIO_SIMPLE); NonGrammarTerminals.Add(COMENTARIO_MULT); //Palabras Reservadas MarkReservedWords("importar"); MarkReservedWords("__constructor"); MarkReservedWords("super"); MarkReservedWords("self"); MarkReservedWords("publico"); MarkReservedWords("privado"); MarkReservedWords("protegido"); MarkReservedWords("/**Sobreescribir**/"); MarkReservedWords("metodo"); MarkReservedWords("funcion"); MarkReservedWords("clase"); MarkReservedWords("si"); MarkReservedWords("si_no_si"); MarkReservedWords("si_no"); MarkReservedWords("elegir"); MarkReservedWords("caso"); MarkReservedWords("defecto"); MarkReservedWords("para"); MarkReservedWords("hacer"); MarkReservedWords("mientras"); MarkReservedWords("repetir"); MarkReservedWords("hasta"); MarkReservedWords("loop"); MarkReservedWords("nuevo"); MarkReservedWords("return"); MarkReservedWords("salir"); MarkReservedWords("continuar"); MarkReservedWords("true"); MarkReservedWords("false"); MarkReservedWords("void"); MarkReservedWords("entero"); MarkReservedWords("decimal"); MarkReservedWords("caracter"); MarkReservedWords("cadena"); MarkReservedWords("booleano"); MarkReservedWords("out_String"); MarkReservedWords("parseInt"); MarkReservedWords("parseDouble"); MarkReservedWords("intToStr"); MarkReservedWords("doubleToStr"); MarkReservedWords("doubleToInt"); MarkReservedWords("imprimir"); //Palabras reservadas var importar = ToTerm("importar"); var constructor = ToTerm("__constructor"); var super = ToTerm("super"); var self = ToTerm("self"); var publico = ToTerm("publico"); var privado = ToTerm("privado"); var protegido = ToTerm("protegido"); var sobreescribir = ToTerm("/**Sobreescribir**/"); var metodo = ToTerm("metodo"); var funcion = ToTerm("funcion"); var clase = ToTerm("clase"); var si = ToTerm("si"); var sinosi = ToTerm("si_no_si"); var sino = ToTerm("si_no"); var selector = ToTerm("elegir"); var caso = ToTerm("caso"); var defecto = ToTerm("defecto"); var para = ToTerm("para"); var hacer = ToTerm("hacer"); var mientras = ToTerm("mientras"); var repetir = ToTerm("repetir"); var hasta = ToTerm("hasta"); var loop = ToTerm("loop"); var nuevo = ToTerm("nuevo"); var retornar = ToTerm("return"); var quiebre = ToTerm("salir"); var continuar = ToTerm("continuar"); var verdadero = ToTerm("true"); var falso = ToTerm("false"); var vacio = ToTerm("void"); var num = ToTerm("entero"); var dec = ToTerm("decimal"); var caracter = ToTerm("caracter"); var str = ToTerm("cadena"); var boolean = ToTerm("booleano"); var outStr = ToTerm("out_String"); var parseInt = ToTerm("parseInt"); var parseDouble = ToTerm("parseDouble"); var intToStr = ToTerm("intToStr"); var doubleToStr = ToTerm("doubleToStr"); var doubleToInt = ToTerm("doubleToInt"); var mostrar = ToTerm("imprimir"); //Signos var asignar = ToTerm("=>"); var apar = ToTerm("("); var cpar = ToTerm(")"); var acor = ToTerm("["); var ccor = ToTerm("]"); var coma = ToTerm(","); var punto = ToTerm("."); var dosp = ToTerm(":"); //No Terminales var INICIO = new NonTerminal("INICIO"); var IMPORTACIONES = new NonTerminal("IMPORTACIONES"); var IMPORTAR = new NonTerminal("IMPORTAR"); var LISTA_ARCHIVOS = new NonTerminal("LISTA_ARCHIVOS"); var ARCHIVO = new NonTerminal("ARCHIVO"); var CLASES = new NonTerminal("CLASES"); var CLASE = new NonTerminal("CLASE"); var BCUERPO = new NonTerminal("BCUERPO"); var CUERPO = new NonTerminal("CUERPO"); var METODO = new NonTerminal("METODO"); var VISIBILIDAD = new NonTerminal("VISIBILIDAD"); var DECLARACIONES = new NonTerminal("DECLARACIONES"); var LISTA_IDS = new NonTerminal("IDS"); var BLOQUE = new NonTerminal("BLOQUE"); var LISTA_SENTENCIAS = new NonTerminal("SENTENCIAS"); var SENTENCIA = new NonTerminal("SENTENCIA"); var DECLARAR = new NonTerminal("DECLARAR"); var asignarR = new NonTerminal("asignarR"); var CONTROL = new NonTerminal("CONTROL"); var IF1 = new NonTerminal("IF1"); var IF2 = new NonTerminal("IF2"); var IF3 = new NonTerminal("IF3"); var IF4 = new NonTerminal("IF4"); var IF5 = new NonTerminal("IF5"); var SWITCH = new NonTerminal("SWITCH"); var CASOS = new NonTerminal("CASOS"); var BCASO = new NonTerminal("BCASO"); var CASO = new NonTerminal("CASO"); var ECASO = new NonTerminal("ECASO"); var DEFECTO = new NonTerminal("DEFECTO"); var WHILE = new NonTerminal("WHILE"); var DO_WHILE = new NonTerminal("DO_WHILE"); var FOR = new NonTerminal("FOR"); var LOOP = new NonTerminal("LOOP"); var REPEAT = new NonTerminal("REPEAT"); var BANDERA = new NonTerminal("BANDERA"); var EXP = new NonTerminal("EXP"); var EXPS = new NonTerminal("EXPS"); var ACCESO = new NonTerminal("ACCESO"); var TACCESO = new NonTerminal("TACCESO"); var TIPO = new NonTerminal("TIPO"); var LLAMADA = new NonTerminal("LLAMADA"); var TPROC = new NonTerminal("TPROC"); var CUERPOS = new NonTerminal("CUERPOS"); var VARIABLES = new NonTerminal("VARIABLES"); var RETORNO = new NonTerminal("RETORNO"); var INTERRUMPIR = new NonTerminal("INTERRUMPIR"); var CONTINUAR = new NonTerminal("CONTINUAR"); var LISTA_PARAMETROS = new NonTerminal("LISTA_PARAMETROS"); var PARAMETRO = new NonTerminal("PARAMETRO"); var PARAM = new NonTerminal("PARAM"); var DECLARACION = new NonTerminal("DECLARACION"); var ASIGNACION = new NonTerminal("ASIGNACION"); var DIMENSION = new NonTerminal("DIMENSION"); var NATIVAS = new NonTerminal("NATIVAS"); var CADENA = new NonTerminal("CADENA"); var IMPRIMIR = new NonTerminal("IMPRIMIR"); var EXCEPTION = new NonTerminal("EXCEPTION"); var Fasignar = new NonTerminal("Fasignar"); var DIM = new NonTerminal("DIM"); var DIM2 = new NonTerminal("DIM"); var INDICES = new NonTerminal("INDICES"); var AID = new NonTerminal("AID"); var Tasignar = new NonTerminal("EXP"); var CRECE = new NonTerminal("CRECE"); var ARR = new NonTerminal("ARR"); var A = new NonTerminal("A"); var NARREGLO = new NonTerminal("NARREGLO"); var DARREGLO = new NonTerminal("NARREGLO"); var NUMEROS = new NonTerminal("INDICES"); var NUEVO = new NonTerminal("NUEVO"); var SUPER = new NonTerminal("SUPER"); var ESTE = new NonTerminal("ESTE"); //Terminales Expresiones Regulares RegexBasedTerminal archivo = new RegexBasedTerminal("archivo", "[a-zA-Z][0-9a-zA-Z]*.(tree|olc)"); RegexBasedTerminal ruta = new RegexBasedTerminal("ruta", "C://([a-zA-Z][0-9a-zA-Z]*/)*[a-zA-Z][0-9a-zA-Z]*.(tree|olc)"); RegexBasedTerminal url = new RegexBasedTerminal("url", "http://([a-zA-Z][0-9a-zA-Z]*/)*[a-zA-Z][0-9a-zA-Z]*.(tree|olc)"); NumberLiteral numero = TerminalFactory.CreateCSharpNumber("numero"); IdentifierTerminal id = TerminalFactory.CreateCSharpIdentifier("id"); var tstring = new StringLiteral("cadena", "\"", StringOptions.AllowsDoubledQuote); var tchar = new StringLiteral("caracter", "'", StringOptions.AllowsDoubledQuote); //No Terminal Inicial this.Root = INICIO; //Producciones INICIO.Rule = IMPORTACIONES + CLASES | CLASES; IMPORTACIONES.Rule = MakeStarRule(IMPORTACIONES, IMPORTAR); IMPORTAR.Rule = importar + LISTA_ARCHIVOS + Eos; LISTA_ARCHIVOS.Rule = MakeStarRule(LISTA_ARCHIVOS, coma, ARCHIVO); ARCHIVO.Rule = ruta | archivo | url; CLASES.Rule = MakeStarRule(CLASES, CLASE); CLASE.Rule = clase + id + acor + id + ccor + dosp + Eos + BCUERPO | clase + id + acor + ccor + dosp + Eos + BCUERPO; BCUERPO.Rule = Indent + CUERPOS + Dedent; CUERPOS.Rule = MakeStarRule(CUERPOS, CUERPO); CUERPO.Rule = VISIBILIDAD + DECLARACION + Eos | METODO | constructor + acor + LISTA_PARAMETROS + ccor + dosp + Eos + BLOQUE | DECLARACION + Eos | ASIGNACION + Eos; METODO.Rule = sobreescribir + Eos + VISIBILIDAD + TPROC + id + acor + LISTA_PARAMETROS + ccor + dosp + Eos + BLOQUE | VISIBILIDAD + TPROC + id + acor + LISTA_PARAMETROS + ccor + dosp + Eos + BLOQUE | sobreescribir + Eos + TPROC + id + acor + LISTA_PARAMETROS + ccor + dosp + Eos + BLOQUE | TPROC + id + acor + LISTA_PARAMETROS + ccor + dosp + Eos + BLOQUE; VISIBILIDAD.Rule = publico | privado | protegido; LISTA_PARAMETROS.Rule = MakeStarRule(LISTA_PARAMETROS, coma, PARAMETRO); PARAMETRO.Rule = TIPO + id + ARR; ARR.Rule = MakeStarRule(ARR, A); A.Rule = acor + ccor; DECLARACION.Rule = TIPO + LISTA_IDS + asignarR | TIPO + LISTA_IDS | TIPO + DARREGLO; DARREGLO.Rule = id + NUMEROS; NUMEROS.Rule = MakeStarRule(NUMEROS, DIM2); DIM2.Rule = acor + numero + ccor; asignarR.Rule = asignar + EXP; ASIGNACION.Rule = ACCESO + asignar + EXP; INDICES.Rule = MakeStarRule(INDICES, DIM); LISTA_IDS.Rule = LISTA_IDS + coma + id | id; BLOQUE.Rule = Indent + LISTA_SENTENCIAS + Dedent; LISTA_SENTENCIAS.Rule = MakeStarRule(LISTA_SENTENCIAS, SENTENCIA); SENTENCIA.Rule = DECLARACION + Eos | self + punto + ASIGNACION + Eos | ASIGNACION + Eos | CONTROL | ACCESO + Eos | INTERRUMPIR + Eos | CONTINUAR + Eos | RETORNO + Eos | NATIVAS + Eos | IMPRIMIR + Eos | SUPER + Eos; SUPER.Rule = super + punto + ASIGNACION | super + punto + ACCESO | super + acor + EXPS + ccor; IMPRIMIR.Rule = mostrar + acor + EXP + ccor | outStr + acor + EXP + ccor; NATIVAS.Rule = parseInt + acor + EXP + ccor | parseDouble + acor + EXP + ccor | intToStr + acor + EXP + ccor | doubleToStr + acor + EXP + ccor | doubleToInt + acor + EXP + ccor; INTERRUMPIR.Rule = quiebre; CONTINUAR.Rule = continuar; RETORNO.Rule = retornar + EXP; LLAMADA.Rule = id + acor + EXPS + ccor; CONTROL.Rule = IF1 | IF2 | IF3 | IF5 | SWITCH | WHILE | DO_WHILE | FOR | LOOP | REPEAT; IF1.Rule = si + EXP + dosp + Eos + BLOQUE; IF2.Rule = si + EXP + dosp + Eos + BLOQUE + sino + dosp + Eos + BLOQUE; IF3.Rule = si + EXP + dosp + Eos + BLOQUE + IF4; IF5.Rule = si + EXP + dosp + Eos + BLOQUE + IF4 + sino + dosp + Eos + BLOQUE; IF4.Rule = IF4 + sinosi + EXP + dosp + Eos + BLOQUE | sinosi + EXP + dosp + Eos + BLOQUE; SWITCH.Rule = selector + caso + EXP + dosp + Eos + BCASO; BCASO.Rule = Indent + CASOS + DEFECTO + Dedent | Indent + CASOS + Dedent; CASOS.Rule = MakeStarRule(CASOS, CASO); CASO.Rule = EXP + dosp + Eos + BLOQUE; DEFECTO.Rule = defecto + dosp + Eos + BLOQUE; WHILE.Rule = mientras + EXP + dosp + Eos + BLOQUE; DO_WHILE.Rule = hacer + dosp + Eos + BLOQUE + mientras + EXP + Eos; REPEAT.Rule = repetir + dosp + Eos + BLOQUE + hasta + EXP + Eos; Fasignar.Rule = DECLARACION | ASIGNACION; FOR.Rule = para + acor + Fasignar + dosp + EXP + dosp + EXP + ccor + dosp + Eos + BLOQUE; LOOP.Rule = loop + dosp + Eos + BLOQUE; TPROC.Rule = funcion + TIPO + ARR | metodo; TIPO.Rule = vacio | num | dec | caracter | str | boolean | id; NARREGLO.Rule = id + INDICES; EXP.Rule = EXP + EXP + ToTerm("or") | EXP + EXP + ToTerm("and") | EXP + EXP + ToTerm("xor") | EXP + EXP + ToTerm("==") | EXP + EXP + ToTerm("!=") | EXP + EXP + ToTerm(">") | EXP + EXP + ToTerm("<") | EXP + EXP + ToTerm(">=") | EXP + EXP + ToTerm("<=") | EXP + EXP + ToTerm("+") | EXP + EXP + ToTerm("-") | EXP + EXP + ToTerm("*") | EXP + EXP + ToTerm("/") | EXP + EXP + ToTerm("pow") | apar + EXP + cpar | acor + EXP + ccor | EXP + ToTerm("-") | EXP + ToTerm("not") | CRECE | NUEVO | LLAMADA | NATIVAS | super + punto + ACCESO | self + punto + ACCESO | ACCESO | numero | tstring | tchar | BANDERA; BANDERA.Rule = falso | verdadero; NUEVO.Rule = nuevo + id + acor + EXPS + ccor; ACCESO.Rule = MakeStarRule(ACCESO, punto, TACCESO); TACCESO.Rule = LLAMADA | id | NARREGLO; DIM.Rule = acor + EXP + ccor; EXPS.Rule = MakeStarRule(EXPS, coma, EXP); CRECE.Rule = EXP + ToTerm("++") | EXP + ToTerm("--"); //Definir Asociatividad RegisterOperators(1, Associativity.Left, "or"); //OR,NOR RegisterOperators(2, Associativity.Left, "and"); //AND,NAND RegisterOperators(3, Associativity.Left, "xor"); //XOR RegisterOperators(4, Associativity.Right, "not"); //NOT RegisterOperators(5, Associativity.Left, "==", "!=", ">", "<", ">=", "<="); //MAYORQUES,MENORQUES,IGUAL,DIFERENTE RegisterOperators(6, Associativity.Left, "+", "-"); //MAS,MENOS RegisterOperators(7, Associativity.Left, "*", "/"); //POR,DIVIDIR,MOD RegisterOperators(8, Associativity.Right, "-"); //UNARIO RegisterOperators(9, Associativity.Left, "pow"); //POTENCIA RegisterOperators(10, Associativity.Left, "++", "--"); //Manejo de Errores Lexicos y Sintacticos SENTENCIA.ErrorRule = SyntaxError + SENTENCIA; CUERPO.ErrorRule = SyntaxError + CUERPO; CASOS.ErrorRule = SyntaxError + CASO; //Eliminacion de caracters, no terminales que son estorbos this.MarkPunctuation("(", ")", ":", "=>", ",", ".", "[", "]", "://", "/"); this.MarkPunctuation("clase", "si", "si_no_si", "si_no", "elegir", "caso", "defecto", "hacer", "mientras", "loop", "repetir", "para", "return", "continuar", "salir"); this.MarkTransient(AID, asignarR, IMPORTACIONES, IMPORTAR, ARCHIVO, TACCESO, SENTENCIA, DIM, DIM2, CONTROL, TIPO, DEFECTO); }
public Gramatica() : base(caseSensitive: true) { #region ER var numero = TerminalFactory.CreateCSharpNumber("numero"); IdentifierTerminal id = new IdentifierTerminal("id"); StringLiteral cadena = TerminalFactory.CreateCSharpString("cadena"); var caracter = TerminalFactory.CreateCSharpChar("caracter"); #endregion #region Terminales /* OPERADORES ARITMETICOS */ var mas = ToTerm("+"); var menos = ToTerm("-"); var por = ToTerm("*"); var div = ToTerm("/"); /* OPERADORES COMPARAR */ var igual = ToTerm("=="); var menor = ToTerm("<"); var mayor = ToTerm(">"); var menor_igual = ToTerm("<="); var mayor_igual = ToTerm(">="); var diferente = ToTerm("!="); /* OPERADORES LOGICOS * var or = ToTerm("||"); * var and = ToTerm("&&"); * var not = ToTerm("!"); * var nand = ToTerm("!&&"); * var nor = ToTerm("!||"); * var xor = ToTerm("|&"); */ /* TIPOS DE DATOS */ var tipo_cadena = ToTerm("cadena"); var tipo_caracter = ToTerm("caracter"); var tipo_entero = ToTerm("entero"); var tipo_doble = ToTerm("doble"); var tipo_bool = ToTerm("boolean"); /* SENTENCIAS DE CONTROL */ var sentencia_si = ToTerm("si"); var sentencia_sino = ToTerm("sino"); var sentencia_para = ToTerm("para"); var sentencia_mientras = ToTerm("mientras"); var sentencia_hacer = ToTerm("hacer"); #endregion #region No Terminales NonTerminal S = new NonTerminal("S"), PROGRAMA = new NonTerminal("PROGRAMA"), SENTENCIA = new NonTerminal("SENTENCIA"), CONDICION = new NonTerminal("CONDICION"), INICIO_PARA = new NonTerminal("INICIO PARA"), FIN_PARA = new NonTerminal("FIN PARA"), SI = new NonTerminal("SI"), SINO = new NonTerminal("SINO"), PARA = new NonTerminal("PARA"), MIENTRAS = new NonTerminal("MIENTRAS"), HACER = new NonTerminal("HACER"), L_ID = new NonTerminal("LST ID"), ASIGNACION = new NonTerminal("ASIGNACION"), COMPARACION = new NonTerminal("COMPARACION"), DECLARACION = new NonTerminal("DECLARAR"), COMPARAR = new NonTerminal("COMPARAR"), TIPO = new NonTerminal("TIPO"), E = new NonTerminal("E"); #endregion #region Gramatica S.Rule = PROGRAMA; PROGRAMA.Rule = MakePlusRule(PROGRAMA, SENTENCIA); SENTENCIA.Rule = SI | PARA | MIENTRAS | HACER | ASIGNACION; /* * si ( CONDICION ) ¿ SENTENCIA ? sino ¿ SENTENCIA ? * para ( INICIO_PARA ; FIN_PARA; CONDICION) ¿ SENTENCIA ? * mientras ( CONDICION ) ¿ SENTENCIA ? * hacer ¿ SENTENCIA ? mientras ( CONDICION ) $ */ SI.Rule = sentencia_si + ToTerm("(") + COMPARACION + ToTerm(")") + ToTerm("¿") + SENTENCIA + ToTerm("?") + sentencia_sino + ToTerm("¿") + SENTENCIA + ToTerm("?"); PARA.Rule = sentencia_para + ToTerm("(") + ASIGNACION + ToTerm(";") + COMPARACION + ToTerm(";") + COMPARACION + ToTerm(")") + ToTerm("¿") + SENTENCIA + ToTerm("?"); MIENTRAS.Rule = sentencia_mientras + ToTerm("(") + COMPARACION + ToTerm(")") + ToTerm("¿") + SENTENCIA + ToTerm("?"); HACER.Rule = sentencia_hacer + ToTerm("¿") + SENTENCIA + ToTerm("?") + sentencia_mientras + ToTerm("(") + COMPARACION + ToTerm(")") + ToTerm("$"); /* * CONDICION -> COMPARACION * INICIO_PARA -> ASIGNACION * FIN_PARA -> COMPARACION */ ASIGNACION.Rule = DECLARACION + ToTerm("=") + E + ToTerm("$"); DECLARACION.Rule = TIPO + id; COMPARACION.Rule = E + COMPARAR + E; TIPO.Rule = tipo_cadena | tipo_caracter | tipo_doble | tipo_entero | tipo_bool; COMPARAR.Rule = igual | menor | mayor | menor_igual | mayor_igual | diferente; E.Rule = E + mas + E | E + menos + E | E + por + E | E + div + E | ToTerm("(") + E + ToTerm(")") | numero | id | cadena | caracter; #endregion #region Preferencias this.Root = S; this.RegisterOperators(20, Associativity.Left, mas, menos); this.RegisterOperators(30, Associativity.Left, por, div); this.MarkPunctuation("(", ")", ",", ";", "=", "¿", "?", "$"); this.MarkTransient(S, SENTENCIA, TIPO); #endregion }
private void InitializeSyntax() { #region Identifiers var id_literal = TerminalFactory.CreateCSharpIdentifier("IDENTIFICADOR"); var number_literal = TerminalFactory.CreateCSharpNumber("NUMERO"); var string_literal = TerminalFactory.CreateCSharpString("CADENA"); var true_literal = ToTerm("TRUE", "LOGICO_TRUE"); var false_literal = ToTerm("FALSE", "LOGICO_FALSE"); #endregion #region NonTerminal NonTerminal program = new NonTerminal("PROGRAMA"); NonTerminal define_dec = new NonTerminal("DEFINIR"); NonTerminal define_list = new NonTerminal("DEFINICIONES"); NonTerminal import_dec = new NonTerminal("IMPORTAR"); NonTerminal import_list = new NonTerminal("IMPORTACIONES"); NonTerminal member = new NonTerminal("MIEMBRO"); NonTerminal member_list = new NonTerminal("MIEMBROS"); NonTerminal var_dec = new NonTerminal("VARIABLE"); NonTerminal var_type = new NonTerminal("TIPO"); NonTerminal var_dec_list = new NonTerminal("VARIABLES"); NonTerminal var_dec_list_names = new NonTerminal("LISTA_VARIABLES"); NonTerminal var_dec_asign = new NonTerminal("VARIABLE_DECLARACION"); NonTerminal function_dec = new NonTerminal("FUNCION"); NonTerminal function_type = new NonTerminal("TIPO_FUNCION"); NonTerminal parameters = new NonTerminal("PARAMETROS"); NonTerminal parameter = new NonTerminal("PARAMETRO"); NonTerminal var_asign = new NonTerminal("ASIGNACION_VARIABLE"); NonTerminal print = new NonTerminal("MOSTRAR"); NonTerminal statements = new NonTerminal("SENTENCIAS"); NonTerminal statement = new NonTerminal("SENTENCIA"); NonTerminal op = new NonTerminal("OPERANDO"); NonTerminal ar = new NonTerminal("OPERACION"); NonTerminal operand = new NonTerminal("OPERANDO"); NonTerminal ao = new NonTerminal("AR_OP"); NonTerminal expression = new NonTerminal("EXPRESION"); NonTerminal co = new NonTerminal("COMPARADOR"); NonTerminal bo = new NonTerminal("OPERADOR_BOOLEANO"); NonTerminal scope = new NonTerminal("AMBITO"); NonTerminal if_block = new NonTerminal("SI"); NonTerminal else_dec = new NonTerminal("SINO"); #endregion #region Gramaticas #region Program NonTerminal program_member = new NonTerminal("MIEMBRO_PROGRAMA"); program.Rule = MakeStarRule(program, program_member); program_member.Rule = import_dec + ";" | define_dec + ";" | var_dec + ToTerm(";") | function_dec; #endregion #region Import import_dec.Rule = "Importar" + string_literal; #endregion #region Definir define_dec.Rule = "Definir" + string_literal | "Definir" + number_literal; #endregion #region Funciones function_dec.Rule = ToTerm("Vacio") + id_literal + ToTerm("(") + parameters + ToTerm(")") + scope | var_type + id_literal + ToTerm("(") + parameters + ToTerm(")") + scope; function_type.Rule = var_type | ToTerm("Vacio"); parameters.Rule = MakeStarRule(parameters, ToTerm(","), parameter); parameter.Rule = var_type + id_literal; NonTerminal func_call = new NonTerminal("LLAMADA_FUNCION"); NonTerminal func_call_params = new NonTerminal("PARAMETROS_LLAMADA"); func_call.Rule = id_literal + ToTerm("(") + func_call_params + ToTerm(")"); func_call_params.Rule = MakeStarRule(func_call_params, ToTerm(","), expression); NonTerminal func_return = new NonTerminal("RETORNO") { Rule = "Retorno" + expression | "Retorno" }; #endregion #region Variables var_dec.Rule = var_type + var_dec_list_names | var_type + var_dec_list_names + ToTerm("=") + expression; var_type.Rule = ToTerm("Int") | ToTerm("Char") | ToTerm("Bool") | ToTerm("String") | ToTerm("Double"); var_dec_list_names.Rule = MakePlusRule(var_dec_list_names, ToTerm(","), id_literal); var_asign.Rule = id_literal + ToTerm("=") + expression; #endregion #region Expresion op.Rule = string_literal | number_literal | id_literal | true_literal | false_literal | func_call; ar.Rule = ar + ToTerm("+") + ar | ar + ToTerm("-") + ar | ar + ToTerm("*") + ar | ar + ToTerm("/") + ar | ar + ToTerm("^") + ar | ar + ToTerm("~") + ar | ar + ToTerm("%") + ar | ToTerm("(") + ar + ToTerm(")") | ToTerm("-") + ar | op; ao.Rule = ToTerm("+") | ToTerm("-") | ToTerm("/") | ToTerm("*"); expression.Rule = expression + bo + expression | ToTerm("!") + operand | operand; operand.Rule = ar | ar + co + ar; bo.Rule = ToTerm("&&") | ToTerm("||") | ToTerm("|&"); co.Rule = ToTerm(">") | ToTerm(">=") | ToTerm("<") | ToTerm("<=") | ToTerm("==") | ToTerm("!="); #endregion #region print print.Rule = ToTerm("Mostrar") + ToTerm("(") + func_call_params + ToTerm(")"); #endregion #region If Else if_block.Rule = ToTerm("Si") + "(" + expression + ")" + scope | ToTerm("Si") + "(" + expression + ")" + scope + else_dec; else_dec.Rule = ToTerm("Sino") + scope; #endregion #region While NonTerminal while_block = new NonTerminal("MIENTRAS") { Rule = "Mientras" + ToTerm("(") + expression + ToTerm(")") + scope }; #endregion #region Repetir NonTerminal repeat_block = new NonTerminal("REPETIR") { Rule = ToTerm("Hasta") + ToTerm("(") + expression + ToTerm(")") + scope }; #endregion #region Para NonTerminal for_var_asign = new NonTerminal("VARIABLE") { Rule = ToTerm("Double") + id_literal + "=" + expression }; NonTerminal for_var_action = new NonTerminal("ACCION_FOR") { Rule = ToTerm("++") | ToTerm("--") }; NonTerminal for_block = new NonTerminal("PARA") { Rule = ToTerm("Para") + ToTerm("(") + for_var_asign + ";" + expression + ";" + for_var_action + ToTerm(")") + scope }; #endregion #region Break NonTerminal break_stmt = new NonTerminal("DETENER") { Rule = ToTerm("Detener") }; #endregion #region Continue NonTerminal continue_stmt = new NonTerminal("CONTINUAR") { Rule = ToTerm("Continuar") }; #endregion #region Selecciona NonTerminal switch_block = new NonTerminal("SELECCIONA"); NonTerminal switch_body = new NonTerminal("CASOS"); NonTerminal case_block = new NonTerminal("CASO"); NonTerminal def_block = new NonTerminal("DEFECTO"); NonTerminal case_list = new NonTerminal("LISTA_CASOS"); switch_block.Rule = "Selecciona" + ToTerm("(") + expression + ToTerm(")") + switch_body; case_block.Rule = expression + ToTerm(":") + statements; case_list.Rule = MakePlusRule(case_list, case_block); switch_body.Rule = ToTerm("{") + case_list + def_block + ToTerm("}") | ToTerm("{") + case_list + ToTerm("}"); def_block.Rule = "Defecto" + ToTerm(":") + statements; #endregion #region Statements scope.Rule = ToTerm("{") + statements + ToTerm("}"); statements.Rule = MakeStarRule(statements, statement); statement.Rule = var_dec + ";" | var_asign + ";" | if_block | switch_block | while_block | repeat_block | for_block | func_call + ";" | func_return + ";" | print + ";" | continue_stmt + ";" | break_stmt + ";"; statement.ErrorRule = SyntaxError + ";" | SyntaxError + "}"; #endregion #endregion #region Preferencias MarkReservedWords("Importar", "Definir", "Int", "String", "Bool", "Char", "Double", "Vacio", "Si", "Sino", "true", "false", "Retorno", "Continuar", "Detener", "Mientras", "Para"); MarkTransient(scope, member, member_list, statement, var_type, for_var_action); RegisterBracePair("(", ")"); RegisterBracePair("{", "}"); RegisterOperators(1, Associativity.Left, ToTerm("+"), ToTerm("-")); RegisterOperators(2, Associativity.Left, ToTerm("/"), ToTerm("*"), ToTerm("%")); RegisterOperators(3, Associativity.Left, ToTerm("^")); //comparissons RegisterOperators(4, Associativity.Left, ToTerm("<"), ToTerm(">"), ToTerm("<="), ToTerm(">="), ToTerm("~")); //booleans RegisterOperators(5, Associativity.Left, ToTerm("||")); RegisterOperators(6, Associativity.Left, ToTerm("|&")); RegisterOperators(7, Associativity.Left, ToTerm("&&")); RegisterOperators(8, Associativity.Right, ToTerm("!")); RegisterOperators(9, Associativity.Left, ToTerm("("), ToTerm(")")); Root = program; #endregion }
public Gramatica() : base(false) //no es case sensitive { #region Terminales #region Comentarios CommentTerminal comentarioLinea = new CommentTerminal("comentarioLinea", "$$", "\n", "\r\n"); CommentTerminal comentarioBloque = new CommentTerminal("comentarioBloque", "$#", "#$"); base.NonGrammarTerminals.Add(comentarioLinea); base.NonGrammarTerminals.Add(comentarioBloque); #endregion #region ExpresionesRegulares IdentifierTerminal id = new IdentifierTerminal("id"); //NumberLiteral number = new NumberLiteral("number"); var number = TerminalFactory.CreateCSharpNumber("number"); StringLiteral cadena = new StringLiteral("cadena", "\"", StringOptions.AllowsAllEscapes); StringLiteral caracter = new StringLiteral("caracter", "\'", StringOptions.IsChar); #endregion #region PalabrasReservadas KeyTerm miEntero = ToTerm("entero"), miDecimal = ToTerm("decimal"), miCadena = ToTerm("cadena"), miCaracter = ToTerm("caracter"), miBooleano = ToTerm("booleano"), miVacio = ToTerm("vacio"), miPrincipal = ToTerm("principal", "miPrincipal"), miRetorno = ToTerm("retorno"), miRomper = ToTerm("romper"), miDefecto = ToTerm("defecto"), miContinuar = ToTerm("continuar"), miIf = ToTerm("si"), miElse = ToTerm("sino"), miDo = ToTerm("hacer"), miWhile = ToTerm("mientras"), miFor = ToTerm("repetir"), miHasta = ToTerm("hasta"), miPrint = ToTerm("imprimir"), miVerdadero = ToTerm("verdadero", "miVerdadero"), miFalso = ToTerm("falso", "miFalso") ; MarkReservedWords("entero", "decimal", "cadena", "caracter", "booleano", "vacio", "principal", "retorno", "defecto", "continuar", "si", "sino", "hacer", "mientras", "repetir", "hasta", "imprimir", "verdadero", "falso"); #endregion #region Simbolos Terminal parizq = ToTerm("("), parder = ToTerm(")"), llaveizq = ToTerm("{"), llaveder = ToTerm("}"), mas = ToTerm("+"), menos = ToTerm("-"), por = ToTerm("*"), div = ToTerm("/"), potencia = ToTerm("^"), modulo = ToTerm("%"), coma = ToTerm(","), punto = ToTerm("."), ptComa = ToTerm(";"), igual = ToTerm("="), masMas = ToTerm("++"), menosMenos = ToTerm("--"), miOr = ToTerm("||"), miAnd = ToTerm("&&"), not = ToTerm("!"), igualIgual = ToTerm("=="), diferente = ToTerm("!="), mayorQue = ToTerm(">"), mayorIgualQue = ToTerm(">="), menorQue = ToTerm("<"), menorIgualQue = ToTerm("<=") ; #endregion #endregion #region NoTerminales NonTerminal S = new NonTerminal("S"), CUERPO = new NonTerminal("CUERPO"), CAMPOS = new NonTerminal("CAMPOS"), METODO = new NonTerminal("METODO"), SENTENCIAS = new NonTerminal("SENTENCIAS"), LISTA_SENTENCIA = new NonTerminal("LISTA_SENTENCIA"), DECLARACION = new NonTerminal("DECLARACION"), ASIGNACION = new NonTerminal("ASIGNACION"), LISTA_IDS = new NonTerminal("LISTA_IDS"), LISTA_PARAM = new NonTerminal("LISTA_PARAM"), PARAMETRO = new NonTerminal("PARAMETRO"), LISTA_ATRI = new NonTerminal("LISTA_ATRI"), ATRIBUTO = new NonTerminal("ATRIBUTO"), SENTENCIA = new NonTerminal("SENTENCIA"), SENTENCIA_IF = new NonTerminal("SENTENCIA_IF"), SENTENCIA_WHILE = new NonTerminal("SENTENCIA_WHILE"), SENTENCIA_BREAK = new NonTerminal("SENTENCIA_BREAK"), SENTENCIA_CONTINUE = new NonTerminal("SENTENCIA_CONTINUE"), SENTENCIA_RETURN = new NonTerminal("SENTENCIA_RETURN"), SENTENCIA_PRINT = new NonTerminal("SENTENCIA_PRINT"), SENTENCIA_CLASE = new NonTerminal("SENTENCIA_CLASE"), LLAMADA = new NonTerminal("LLAMADA"), ACCESO = new NonTerminal("ACCESO"), EXP = new NonTerminal("EXP"), EXP_ARIT = new NonTerminal("EXP_ARIT"), EXP_REL = new NonTerminal("EXP_REL"), EXP_LOG = new NonTerminal("EXP_LOG"), LISTA_ARG = new NonTerminal("LISTA_ARG"), TIPO = new NonTerminal("TIPO"), TIPO_PRIM = new NonTerminal("TIPO_PRIM") ; #endregion #region GramaticaAntigua //NonTerminal S = new NonTerminal("S"), // I = new NonTerminal("I"), // CUERPO = new NonTerminal("CUERPO"), // DECLARACION_GLOBAL = new NonTerminal("DECLARACION_GLOBAL"), // LISTA_IDS = new NonTerminal("LISTA_IDS"), // METODO = new NonTerminal("METODO"), // MT_ENCABEZADO = new NonTerminal("MT_ENCABEZADO"), // MT_CUERPO = new NonTerminal("MT_CUERPO"), // SENTENCIA = new NonTerminal("SENTENCIA"), // ASIGNACION = new NonTerminal("ASIGNACION"), // DECLARACION_LOCAL = new NonTerminal("DECLARACION_LOCAL"), // MT_LLAMADA = new NonTerminal("MT_LLAMADA"), // //PLOT = new NonTerminal("PLOT"), // //IMG = new NonTerminal("IMG"), // MT_RETURN = new NonTerminal("MT_RETURN"), // E = new NonTerminal("E")//, //MT_PARAMETROS = new NonTerminal("MT_PARAMETROS"), //FUNCION = new NonTerminal("FUNCION"), //FUNC_CUERPO = new NonTerminal("FUNC_CUERPO"), //SENTENCIA2 = new NonTerminal("SENTENCIA2"), //FUNC_RETURN = new NonTerminal("FUNC_RETURN"), //CONSTANTES = new NonTerminal("CONSTANTES"), //DIMENSION = new NonTerminal("DIMENSION"), //MAIN = new NonTerminal("MAIN"), //MAIN_CUERPO = new NonTerminal("MAIN_CUERPO"), //SENTENCIA3 = new NonTerminal("SENTENCIA3") ; #endregion S.Rule = CUERPO; CUERPO.Rule = MakePlusRule(CUERPO, CAMPOS); CAMPOS.Rule = METODO | DECLARACION + ptComa; //| id //| SENTENCIA_CLASE ; METODO.Rule = TIPO + id + parizq + LISTA_PARAM + parder + SENTENCIAS | id + id + parizq + LISTA_PARAM + parder + SENTENCIAS | TIPO + id + parizq + parder + SENTENCIAS | id + id + parizq + parder + SENTENCIAS | miPrincipal + parizq + parder + SENTENCIAS ; LISTA_PARAM.Rule = MakePlusRule(LISTA_PARAM, coma, PARAMETRO); PARAMETRO.Rule = TIPO + id; //Lista de atributos //atributo SENTENCIAS.Rule = llaveizq + LISTA_SENTENCIA + llaveder; LISTA_SENTENCIA.Rule = MakePlusRule(LISTA_SENTENCIA, SENTENCIA); SENTENCIA.Rule = DECLARACION + ptComa /*| ASIGNACION + ptComa | ACCESO + ptComa*/ | LLAMADA + ptComa | SENTENCIA_IF /*| SENTENCIA_WHILE*/ | SENTENCIA_RETURN + ptComa /*| SENTENCIA_BREAK + ptComa | SENTENCIA_CONTINUE + ptComa*/ | SENTENCIA_PRINT + ptComa //| SENTENCIA_CLASE + ptComa ; DECLARACION.Rule = TIPO + LISTA_IDS + "=" + EXP | TIPO + LISTA_IDS | id + id ; /*ASIGNACION.Rule = LISTA_IDS + "=" + EXP | id + "." + id + "=" + EXP | ;*/ LISTA_IDS.Rule = MakePlusRule(LISTA_IDS, coma, id); SENTENCIA_IF.Rule = miIf + parizq + EXP + parder + SENTENCIAS | miIf + parizq + EXP + parder + SENTENCIAS + miElse + SENTENCIAS ; /*SENTENCIA_WHILE.Rule = miWhile + parizq + EXP + parder + SENTENCIAS * ;*/ SENTENCIA_RETURN.Rule = miRetorno + EXP | miRetorno; /*SENTENCIA_BREAK.Rule = miRomper; * * SENTENCIA_CONTINUE.Rule = miContinuar;*/ SENTENCIA_PRINT.Rule = miPrint + parizq + EXP + parder; //Pendiente sentencia struct LLAMADA.Rule = id + parizq + LISTA_ARG + parder | id + parizq + parder ; /*ACCESO.Rule = id + "." + id;*/ EXP.Rule = EXP_ARIT //YAPP | EXP_LOG //YAP | EXP_REL //YAP | TIPO_PRIM //YAPP // | ACCESO | parizq + EXP + parder //YAP | LLAMADA //YAP ; EXP_LOG.Rule = EXP + miOr + EXP | EXP + miAnd + EXP | not + EXP ; EXP_REL.Rule = EXP + igualIgual + EXP | EXP + diferente + EXP | EXP + menorQue + EXP | EXP + mayorQue + EXP | EXP + menorIgualQue + EXP | EXP + mayorIgualQue + EXP ; EXP_ARIT.Rule = menos + EXP //YAPP | EXP + mas + EXP //YAPP | EXP + menos + EXP //YAPP | EXP + por + EXP //YAPP | EXP + div + EXP //YAPP | EXP + modulo + EXP //YAPP | EXP + potencia + EXP //YAPP | EXP + menosMenos | EXP + masMas ; TIPO_PRIM.Rule = number //YAPP | cadena | caracter | miVerdadero | miFalso | id ; LISTA_ARG.Rule = MakeStarRule(LISTA_ARG, coma, EXP); TIPO.Rule = miBooleano | miCaracter | miCadena | miEntero //YA | miDecimal | miVacio ; this.Root = S; #region Precedencia RegisterOperators(1, Associativity.Right, igual); RegisterOperators(2, Associativity.Left, miOr); RegisterOperators(3, Associativity.Left, miAnd); RegisterOperators(4, Associativity.Left, igualIgual, diferente); RegisterOperators(5, Associativity.Left, menorQue, menorIgualQue, mayorQue, mayorIgualQue); RegisterOperators(6, Associativity.Left, mas, menos); RegisterOperators(7, Associativity.Left, por, div, modulo); RegisterOperators(8, Associativity.Right, potencia); RegisterOperators(9, Associativity.Right, masMas, menosMenos, not); MarkPunctuation(parizq, parder, llaveder, llaveizq, ptComa, coma, igual, punto); #endregion }
public Language() : base(false) { CommentTerminal LINE_COMMENT = new CommentTerminal("LINE_COMMENT", ">>", "\n", "\r\n"); CommentTerminal BLOCK_COMMENT = new CommentTerminal("BLOCK_COMMENT", "<-", "->"); NonGrammarTerminals.Add(BLOCK_COMMENT); NonGrammarTerminals.Add(LINE_COMMENT); ////----------------------------------Terminals with precedence KeyTerm increase = ToTerm("++"); KeyTerm decrease = ToTerm("--"); KeyTerm plus = ToTerm("+"); KeyTerm minus = ToTerm("-"); KeyTerm by = ToTerm("*"); KeyTerm divided = ToTerm("/"); KeyTerm power = ToTerm("^"); KeyTerm lessThan = ToTerm("<"); KeyTerm greaterThan = ToTerm(">"); KeyTerm lessThanEqual = ToTerm("<="); KeyTerm greaterThanEqual = ToTerm(">="); KeyTerm doubleEqual = ToTerm("=="); KeyTerm different = ToTerm("!="); KeyTerm not = ToTerm("!"); KeyTerm and = ToTerm("&&"); KeyTerm or = ToTerm("||"); ////----------------------------------precedence this.RegisterOperators(1, Associativity.Left, or); this.RegisterOperators(2, Associativity.Left, and); this.RegisterOperators(3, Associativity.Left, not); this.RegisterOperators(4, Associativity.Left, doubleEqual, different, lessThan, lessThanEqual, greaterThan, greaterThanEqual); this.RegisterOperators(5, Associativity.Left, plus, minus); this.RegisterOperators(6, Associativity.Left, by, divided); this.RegisterOperators(7, Associativity.Left, power); //Regex var integer = new RegexBasedTerminal("int", "[0-9]+"); var tdouble = TerminalFactory.CreateCSharpNumber("double"); var String = TerminalFactory.CreateCSharpString("string"); var caracter = TerminalFactory.CreateCSharpChar("char"); var boolean = new RegexBasedTerminal("bool", "(true)|(false)"); var iden = TerminalFactory.CreateCSharpIdentifier("id"); var hexa = new RegexBasedTerminal("hexa", "^(\\#)[0-9A-F]+$"); //Non terminals var START = new NonTerminal("START"); var BODY = new NonTerminal("BODY"); var DECLARATION = new NonTerminal("DECLARATION"); var DECLARATION2 = new NonTerminal("DECLARATION2"); var ASSIGNATION = new NonTerminal("ASSIGNATION"); var ASSIGN2 = new NonTerminal("ASSIGN2"); var INDEX = new NonTerminal("INDEX"); var DATATYPE = new NonTerminal("DATATYPE"); var OBJECT = new NonTerminal("OBJECT"); var ASSIGN = new NonTerminal("ASSIGN"); var ARRAY = new NonTerminal("ARRAY"); var ARRAY2 = new NonTerminal("ARRAY2"); var ARRAYASIGN = new NonTerminal("ARRAYASIGN"); var ARRAYASIGN2 = new NonTerminal("ARRAYASIGN2"); var ARRAYASIGN3 = new NonTerminal("ARRAYASIGN3"); var ARRAYLIST = new NonTerminal("ARRAYLIST"); var NATIVE = new NonTerminal("NATIVE"); var PRINT = new NonTerminal("PRINT"); var SHOW = new NonTerminal("SHOW"); var IF = new NonTerminal("IF"); var ELSE = new NonTerminal("ELSE"); var FOR = new NonTerminal("FOR"); var REPEAT = new NonTerminal("REPEAT"); var WHILE = new NonTerminal("WHILE"); var VARMANAGMENT = new NonTerminal("VARMANAGMENT"); var UPDATE = new NonTerminal("UPDATE"); var ESINGLE = new NonTerminal("ESINGLE"); var E = new NonTerminal("E"); var ID = new NonTerminal("ID"); var IDPLUS = new NonTerminal("IDPLUS"); var ARRAYS = new NonTerminal("ARRAYS"); var DOWHILE = new NonTerminal("DOWHILE"); var SWITCH = new NonTerminal("SWITCH"); var CASE = new NonTerminal("CASE"); var DEFAULT = new NonTerminal("DEFAULT"); var CASELIST = new NonTerminal("CASELIST"); var FUNCTION = new NonTerminal("FUNCTION"); var FUNCTIONARGS = new NonTerminal("FUNCTIONARGS"); var VISIBILITY = new NonTerminal("VISIBILITY"); var OVERRIDE = new NonTerminal("OVERRIDE"); var PARAMLIST = new NonTerminal("PARAMLIST"); var PARAM = new NonTerminal("PARAM"); var OPTIONAL = new NonTerminal("OPTIONAL"); var RETURN = new NonTerminal("RETURN"); var RETOPTION = new NonTerminal("RETOPTION"); var LISTMETHODS = new NonTerminal("LISTMETHODS"); var CLASS = new NonTerminal("CLASS"); var EXTENDS = new NonTerminal("EXTENDS"); var EXTENDSLIST = new NonTerminal("EXTENDSLIST"); var CALLFUNC = new NonTerminal("CALLFUNC"); var ADDFIGURE = new NonTerminal("ADDFIGURE"); var GEOMETRICAS = new NonTerminal("GEOMETRICAS"); var COLOR = new NonTerminal("COLOR"); var FIGURE = new NonTerminal("FIGURE"); var MAIN = new NonTerminal("MAIN"); var CLASSIMPLEMENTATION = new NonTerminal("CLASSIMPLEMENTATION"); var CFUNCLIST = new NonTerminal("CFUNCLIST"); var LISTCLASSMETHODS = new NonTerminal("LISTCLASSMETHODS"); var LISTCLASSMETHODS2 = new NonTerminal("LISTCLASSMETHODS2"); var LISTOBJECTS = new NonTerminal("LISTCLASSMETHODS2"); ////----------------------------------Innecesary nodes this.MarkPunctuation(".", "(", ")", "{", "}", "[", "]", ";", "=", ",", "importar", "if", "for", "repeat", "mientras", "show", "hacer", "comprobar", "salir", "caso", ":", "print", "defecto", "clase", "addfigure", "main", "return"); this.MarkTransient(DECLARATION2, LISTCLASSMETHODS2, CLASSIMPLEMENTATION, BODY, ASSIGN2, COLOR, ARRAY2, ARRAYASIGN, ARRAYASIGN2, ARRAYASIGN3, NATIVE, VARMANAGMENT, ESINGLE, ASSIGN, ARRAY, ADDFIGURE, RETOPTION); //----------------------------------Grammar START.Rule = MakePlusRule(START, CLASS); CLASS.Rule = "clase" + iden + EXTENDSLIST + "{" + CLASSIMPLEMENTATION + "}"; CLASS.ErrorRule = SyntaxError + "}"; CLASS.ErrorRule = SyntaxError + ";"; CLASSIMPLEMENTATION.Rule = MakeStarRule(CLASSIMPLEMENTATION, LISTCLASSMETHODS); EXTENDSLIST.Rule = MakeStarRule(EXTENDSLIST, ToTerm(","), EXTENDS); EXTENDS.Rule = ToTerm("importar") + ID; LISTMETHODS.Rule = MakePlusRule(LISTMETHODS, BODY); BODY.Rule = ID + ";" | FIGURE | ADDFIGURE | DECLARATION | ASSIGNATION | UPDATE + ";" | PRINT | SHOW | IF | FOR | REPEAT | WHILE | DOWHILE | SWITCH | OPTIONAL + ";" | Empty | CALLFUNC; //methods inside a function DECLARATION.Rule = DATATYPE + DECLARATION2 + ";"; DECLARATION.ErrorRule = SyntaxError + ";"; DECLARATION2.Rule = LISTOBJECTS | ToTerm("array") + ARRAYS; LISTOBJECTS.Rule = MakePlusRule(LISTOBJECTS, ToTerm(","), OBJECT); ARRAYS.Rule = ID + ARRAY; ASSIGN.Rule = ToTerm("=") + E | Empty; ASSIGNATION.Rule = ID + ASSIGN2 + ";"; ASSIGNATION.ErrorRule = SyntaxError + ";"; ASSIGN2.Rule = ToTerm("=") + E | "[" + E + "]" + ASSIGN2; PRINT.Rule = ToTerm("print") + "(" + E + ")" + ";"; PRINT.ErrorRule = SyntaxError + ";"; SHOW.Rule = ToTerm("show") + "(" + E + "," + E + ")" + ";"; SHOW.ErrorRule = SyntaxError + ";"; IF.Rule = ToTerm("if") + "(" + E + ")" + "{" + LISTMETHODS + "}" + ELSE; IF.ErrorRule = SyntaxError + "}"; IF.ErrorRule = SyntaxError + ";"; ELSE.Rule = ToTerm("else") + IF | ToTerm("else") + "{" + LISTMETHODS + "}" | Empty; FOR.Rule = ToTerm("for") + "(" + VARMANAGMENT + E + ";" + UPDATE + ")" + "{" + LISTMETHODS + "}"; FOR.ErrorRule = SyntaxError + "}"; FOR.ErrorRule = SyntaxError + ";"; REPEAT.Rule = ToTerm("repeat") + "(" + E + ")" + "{" + LISTMETHODS + "}"; REPEAT.ErrorRule = SyntaxError + "}"; REPEAT.ErrorRule = SyntaxError + ";"; VARMANAGMENT.Rule = DECLARATION | ASSIGNATION; UPDATE.Rule = ESINGLE + increase | ESINGLE + decrease; WHILE.Rule = ToTerm("mientras") + "(" + E + ")" + "{" + LISTMETHODS + "}"; WHILE.ErrorRule = SyntaxError + "}"; WHILE.ErrorRule = SyntaxError + ";"; DOWHILE.Rule = ToTerm("hacer") + "{" + LISTMETHODS + "}" + ToTerm("mientras") + "(" + E + ")" + ";"; DOWHILE.ErrorRule = SyntaxError + "}"; DOWHILE.ErrorRule = SyntaxError + ";"; SWITCH.Rule = ToTerm("comprobar") + "(" + E + ")" + "{" + CASELIST + DEFAULT + "}"; SWITCH.ErrorRule = SyntaxError + "}"; SWITCH.ErrorRule = SyntaxError + ";"; CASELIST.Rule = MakePlusRule(CASELIST, CASE); CASE.Rule = ToTerm("caso") + E + ":" + LISTMETHODS + ToTerm("salir") + ";"; DEFAULT.Rule = ToTerm("defecto") + ":" + LISTMETHODS + ToTerm("salir") + ";" | Empty; OPTIONAL.Rule = RETURN | ToTerm("continue"); RETURN.Rule = ToTerm("return") + RETOPTION; RETOPTION.Rule = Empty | E; CALLFUNC.Rule = iden + "(" + CFUNCLIST + ")" + ";"; CFUNCLIST.Rule = MakeStarRule(CFUNCLIST, ToTerm(","), E); CALLFUNC.ErrorRule = SyntaxError + ";"; ADDFIGURE.Rule = ToTerm("addfigure") + "(" + GEOMETRICAS + ")" + ";"; GEOMETRICAS.Rule = ToTerm("circle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("triangle") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("square") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")" | ToTerm("line") + "(" + COLOR + "," + E + "," + E + "," + E + "," + E + "," + E + ")"; GEOMETRICAS.ErrorRule = SyntaxError + ";"; COLOR.Rule = Empty | E; //it can be a string or id FIGURE.Rule = ToTerm("figure") + "(" + E + ")" + ";"; //Methods inside a class LISTCLASSMETHODS.Rule = VISIBILITY + LISTCLASSMETHODS2 | MAIN; LISTCLASSMETHODS2.Rule = DECLARATION | FUNCTION; MAIN.Rule = ToTerm("main") + "(" + ")" + "{" + LISTMETHODS + "}"; FUNCTION.Rule = iden + FUNCTIONARGS + "(" + PARAMLIST + ")" + "{" + LISTMETHODS + "}"; FUNCTION.ErrorRule = SyntaxError + "}"; FUNCTION.ErrorRule = SyntaxError + ";"; FUNCTIONARGS.Rule = DATATYPE + OVERRIDE | ToTerm("array") + DATATYPE + INDEX + OVERRIDE | ToTerm("void"); VISIBILITY.Rule = Empty | ToTerm("publico") | ToTerm("privado"); OVERRIDE.Rule = Empty | ToTerm("override"); PARAMLIST.Rule = MakeStarRule(PARAMLIST, ToTerm(","), PARAM); PARAM.Rule = iden + iden | DATATYPE + iden; //datatypes DATATYPE.Rule = ToTerm("int") | "bool" | "string" | "double" | "char" | iden; OBJECT.Rule = ID + ASSIGN; //Making arrays ARRAY.Rule = "=" + ARRAYASIGN | Empty; ARRAYASIGN.Rule = ToTerm("{") + ARRAYASIGN2 + "}"; ARRAYASIGN2.Rule = ARRAYASIGN3 | ARRAYLIST; ARRAYASIGN3.Rule = ARRAYASIGN | MakePlusRule(ARRAYASIGN3, ToTerm(","), ARRAYASIGN); ARRAYLIST.Rule = MakePlusRule(ARRAYLIST, ToTerm(","), E); //Making EXP E.Rule = E + plus + E | E + minus + E | E + by + E | E + divided + E | E + power + E | E + doubleEqual + E | E + different + E | E + lessThan + E | E + greaterThan + E | E + lessThanEqual + E | E + greaterThanEqual + E | E + or + E | E + and + E | not + E | ESINGLE | ToTerm("(") + E + ")" | minus + E; ESINGLE.Rule = NATIVE | ID | ToTerm("new") + iden + "(" + CFUNCLIST + ")"; INDEX.Rule = INDEX + ToTerm("[") + E + "]" | Empty; ID.Rule = iden + IDPLUS; IDPLUS.Rule = INDEX | Empty | "(" + CFUNCLIST + ")" | "." + ID; NATIVE.Rule = integer | caracter | String | boolean | tdouble; this.Root = START; }
public QAsmGrammar() { NumberLiteral = TerminalFactory.CreateCSharpNumber(NUMBER_LITERAL); NumberLiteral.Options = NumberOptions.AllowSign; Identifier = new IdentifierTerminal("identifier", @"_", "_"); StringLiteral = new StringLiteral(STRING_LITERAL, "\"", StringOptions.AllowsAllEscapes); NonGrammarTerminals.Add(new CommentTerminal("line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029")); MarkPunctuation("[", "]", ";", "::", ":", "&", ".", "(", ")", ",", "{", "}", "@"); RegisterOperators(1, "+", "-"); RegisterOperators(2, "*", "/"); RegisterBracePair("[", "]"); RegisterBracePair("{", "}"); RegisterKeyTerms(); CreateNonTerminals(); directives.Rule = MakeStarRule(directives, null, directive); directive.Rule = instruction | declareFunction; instruction.Rule = iConst | iExtern | iLet | iIf | iBool | iRet | iMov | iAdd | iCalld; #region Instructions iConst.Rule = kConst + variableQualifier + "," + constExpr + ";"; iExtern.Rule = kExtern + variableQualifier + ";"; iLet.Rule = kLet + variableQualifier + ";"; iBool.Rule = kBool + valueAccessor + ";"; iRet.Rule = kRet + ";" | kRet + valueAccessor + ";"; iMov.Rule = kMov + destinationOperand + "," + valueAccessor + ";"; iAdd.Rule = kAdd + destinationOperand + "," + valueAccessor + ";"; iCalld.Rule = kCall + valueAccessor + "," + callparamsList + ";" | kCall + valueAccessor + ";"; #endregion #region CodeBlocks declareFunction.Rule = Identifier + "(" + paramsList + ")" + codeBlock; paramsList.Rule = MakeStarRule(paramsList, ToTerm(","), variableQualifier); codeBlock.Rule = ToTerm("[") + directives + ToTerm("]"); iIf.Rule = kIf + codeBlock + codeBlock + ToTerm(";"); #endregion variableQualifier.Rule = Identifier + typeAccessor | Identifier; typeAccessor.Rule = ToTerm(":") + builtinType | ToTerm(":") + Identifier; builtinType.Rule = kByte | kWord | kDword | kQword | kString; constExpr.Rule = NumberLiteral | StringLiteral | boolLiteral; boolLiteral.Rule = kTrue | kFalse; functionPointer.Rule = Identifier + "::" + Identifier; variableHandle.Rule = ToTerm("&") + Identifier; valueAccessor.Rule = memoryAccessor | variableHandle | Identifier | NumberLiteral | boolLiteral | functionPointer; memoryAccessor.Rule = ToTerm("@") + "(" + valueDisplacementOptional + ")" + typeAccessor | ToTerm("@") + "(" + valueDisplacementOptional + ")"; valueDisplacementOptional.Rule = valueAccessor + binOp + NumberLiteral | valueAccessor; destinationOperand.Rule = memoryAccessor | variableQualifier; binOp.Rule = ToTerm("+") | ToTerm("-"); callparamsList.Rule = MakePlusRule(callparamsList, ToTerm(","), valueAccessor); // Marks all the rules that are able to be reduced, reducing the depth of the parsetree MarkTransient(directive, builtinType, instruction, valueAccessor, boolLiteral, destinationOperand, binOp); SyntaxParser = new Parser(this); }
public ReportingLanguage() : base(false) { // 1. Terminals var numberLiteral = TerminalFactory.CreateCSharpNumber("Number"); var boolean = new ConstantTerminal("Boolean"); boolean.Add("true", true); boolean.Add("false", false); boolean.Priority = 10; var nil = new ConstantTerminal("Null"); nil.Add("null", null); nil.Add("nothing", null); nil.Priority = 10; var identifier = new IdentifierTerminal("Identifier"); var stringLiteral = new StringLiteral("String", "'", StringFlags.AllowsDoubledQuote); stringLiteral.AddStartEnd("\"", StringFlags.AllowsAllEscapes); Terminal dot = Symbol(".", "dot"); Terminal less = Symbol("<"); Terminal greater = Symbol(">"); Terminal LCb = Symbol("("); Terminal RCb = Symbol(")"); Terminal RFb = Symbol("}"); Terminal LFb = Symbol("{"); Terminal comma = Symbol(","); // Terminal LSb = Symbol("["); // Terminal RSb = Symbol("]"); var exclamationMark = Symbol("!"); Terminal and = Symbol("and"); and.Priority = 10; Terminal or = Symbol("or"); or.Priority = 10; var UserSection = Symbol("User"); var GlobalSection = Symbol("Globals"); var ParameterSection = Symbol("Parameters"); var FieldsSection = Symbol("Fields"); // 2. Non-terminals var FieldRef = new NonTerminal("FieldRef"); var userSectionStmt = new NonTerminal("UserSectionStmt"); var globalSectionStmt = new NonTerminal("GlobalSectionStmt"); var parameterSectionStmt = new NonTerminal("ParameterSectionStmt"); var fieldsSectionStmt = new NonTerminal("FieldsSectionStmt"); var QualifiedName = new NonTerminal("QualifiedName"); var FunctionExpression = new NonTerminal("FunctionExpression"); var Condition = new NonTerminal("Condition"); var Conditional = new NonTerminal("IfThen"); var Expr = new NonTerminal("Expr"); var BinOp = new NonTerminal("BinOp"); var LUnOp = new NonTerminal("LUnOp"); var ExprList = new NonTerminal("ExprList"); var BinExpr = new NonTerminal("BinExpr", typeof(BinExprNode)); var ProgramLine = new NonTerminal("ProgramLine"); var Program = new NonTerminal("Program", typeof(StatementListNode)); // 3. BNF rules #region Reporting userSectionStmt.Rule = UserSection + exclamationMark + Symbol("UserId") | UserSection + exclamationMark + Symbol("Language"); globalSectionStmt.Rule = GlobalSection + exclamationMark + Symbol("PageNumber") | GlobalSection + exclamationMark + Symbol("TotalPages") | GlobalSection + exclamationMark + Symbol("ExecutionTime") | GlobalSection + exclamationMark + Symbol("ReportFolder") | GlobalSection + exclamationMark + Symbol("ReportName"); parameterSectionStmt.Rule = ParameterSection + exclamationMark + identifier; fieldsSectionStmt.Rule = FieldsSection + exclamationMark + identifier; #endregion Expr.Rule = Symbol("null") | boolean | nil | stringLiteral | numberLiteral | QualifiedName | FunctionExpression | LCb + Expr + RCb | LFb + QualifiedName + RFb | Conditional | BinExpr //| Expr + BinOp + Expr //| LUnOp + Expr | parameterSectionStmt | globalSectionStmt | userSectionStmt | fieldsSectionStmt; ExprList.Rule = MakePlusRule(ExprList, comma, Expr); BinOp.Rule = Symbol("+") | "-" | "*" | "%" | "^" | "&" | "|" | "/" | "&&" | "||" | "==" | "!=" | greater | less | ">=" | "<=" | "is" | "<>" | "=" //| "+=" | "-=" | "." | and | or; LUnOp.Rule = Symbol("-") | "!"; FunctionExpression.Rule = QualifiedName + LCb + ExprList.Q() + RCb; QualifiedName.Rule = identifier | QualifiedName + dot + identifier | parameterSectionStmt + "!" + identifier | "#" + identifier; Condition.Rule = LCb + Expr + RCb; Conditional.Rule = "if" + Condition + "then" + Expr | "if" + Condition + "then" + Expr + "else" + Expr | "if" + Condition + "then" + Expr + "otherwise" + Expr; BinExpr.Rule = Expr + BinOp + Expr | LUnOp + Expr; ProgramLine.Rule = Expr + NewLine; Program.Rule = MakeStarRule(Program, ProgramLine); this.Root = Program; // Set grammar root #region 5. Operators precedence RegisterOperators(1, "is", "=", "==", "!=", "<>", ">", "<", ">=", "<="); RegisterOperators(2, "+", "-"); RegisterOperators(3, "*", "/", "%"); RegisterOperators(4, Associativity.Right, "^"); RegisterOperators(5, "|", "||", "or"); RegisterOperators(6, "&", "&&", "and"); RegisterOperators(7, "!"); #endregion RegisterPunctuation("(", ")", "[", "]", "{", "}", ",", ";"); MarkTransient(Expr, BinOp); //automatically add NewLine before EOF so that our BNF rules work correctly when there's no final line break in source this.SetLanguageFlags(LanguageFlags.NewLineBeforeEOF | LanguageFlags.SupportsInterpreter | LanguageFlags.AutoDetectTransient | LanguageFlags.CreateAst); }
public CeciliaGrammar() { #region Lexical rules // keywords var BoolKeyword = new KeyTerm("bool", "bool"); var CharKeyword = new KeyTerm("char", "char"); var StringKeyword = new KeyTerm("string", "string"); var ObjectKeyword = new KeyTerm("object", "object"); var ByteKeyword = new KeyTerm("byte", "byte"); var ShortKeyword = new KeyTerm("short", "short"); var IntKeyword = new KeyTerm("int", "int"); var LongKeyword = new KeyTerm("long", "long"); var UbyteKeyword = new KeyTerm("ubyte", "ubyte"); var UShortKeyword = new KeyTerm("ushort", "short"); var UIntKeyword = new KeyTerm("uint", "int"); var ULongKeyword = new KeyTerm("ulong", "long"); var HalfKeyword = new KeyTerm("half", "half"); var FloatKeyword = new KeyTerm("float", "float"); var DoubleKeyword = new KeyTerm("double", "double"); var DecimalKeyword = new KeyTerm("decimal", "decimal"); var NamespaceKeyword = new KeyTerm("namespace", "namespace"); var PublicKeyword = new KeyTerm("public", "public"); var PrivateKeyword = new KeyTerm("private", "private"); var InternalKeyword = new KeyTerm("internal", "internal"); var UsingKeyword = new KeyTerm("using", "using"); var VarKeyword = new KeyTerm("var", "var"); var ConstKeyword = new KeyTerm("const", "const"); var SwitchKeyword = new KeyTerm("switch", "switch"); var LoopKeyword = new KeyTerm("loop", "loop"); var MacroKeyword = new KeyTerm("macro", "macro"); var TrueKeyword = new KeyTerm("true", "true"); var FalseKeyword = new KeyTerm("false", "false"); var DefaultKeyword = new KeyTerm("default", "default"); var ReturnKeyword = new KeyTerm("return", "return"); //symbols var LParen = ToTerm("("); var RParen = ToTerm(")"); var LBracket = ToTerm("["); var RBracket = ToTerm("]"); var LBrace = ToTerm("{"); var RBrace = ToTerm("}"); var Exclamation = ToTerm("!"); var Dollar = ToTerm("$"); var Percent = ToTerm("%"); var Caret = ToTerm("^"); var Ampersand = ToTerm("&"); var Asterisk = ToTerm("*"); var Minus = ToTerm("-"); var Plus = ToTerm("+"); var Equals = ToTerm("="); var Bar = ToTerm("|"); var Backslash = ToTerm("\\"); var Colon = ToTerm(":"); var SemiColon = ToTerm(";"); var DoubleQuote = ToTerm("\""); var SingleQuote = ToTerm("\'"); var LessThan = ToTerm("<"); var GreaterThan = ToTerm(">"); var Comma = ToTerm(","); var Dot = ToTerm("."); var Question = ToTerm("?"); var Hash = ToTerm("#"); var Slash = ToTerm("/"); var BarBar = ToTerm("||"); var AmpAmp = ToTerm("&&"); var MinusMinus = ToTerm("--"); var PlusPlus = ToTerm("++"); var QuestionQuestion = ToTerm("??"); var EqualsEquals = ToTerm("=="); var ExclamationEquals = ToTerm("!="); var Arrow = ToTerm("=>"); var LessThanEqual = ToTerm("<="); var GreaterThanEqual = ToTerm(">="); var LessThanLessThan = ToTerm("<<"); var GreaterThanGreaterThan = ToTerm(">>"); var PlusEqual = ToTerm("+="); var MinusEqual = ToTerm("-="); var AsteriskEqual = ToTerm("*="); var SlashEqual = ToTerm("/="); var BarEqual = ToTerm("|="); var CaretEqual = ToTerm("^="); var LessThanLessThanEqual = ToTerm("<<="); var GreaterThanGreaterThanEqual = ToTerm(">>="); var SemicolonOpt = new NonTerminal("semicolonOpt"); SemicolonOpt.Rule = SemiColon.Q(); var Identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var NumberLiteral = TerminalFactory.CreateCSharpNumber("NumberLiteral"); var StringLiteral = TerminalFactory.CreateCSharpString("string_literal"); var SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\r", "\n"); NonGrammarTerminals.Add(SingleLineComment); #endregion #region non terminals // program and namespace var Program = new NonTerminal("program"); var UsingDirectives = new NonTerminal("using_directives"); var UsingDirective = new NonTerminal("using_directive"); var QualifiedIdentifier = new NonTerminal("qualified_identifier"); var NamespaceMemberDeclarations = new NonTerminal("namespace_member_declarations"); var NamespaceMemberDeclaration = new NonTerminal("namespace_member_declaration"); var NamespaceDeclaration = new NonTerminal("namespace_declaration"); var NamespaceDeclarations = new NonTerminal("namespace_declarations"); // member declaration var TypeDeclaration = new NonTerminal("type_declaration"); var AllMemberModifiers = new NonTerminal("all_member_modifiers"); var AllMemberModifier = new NonTerminal("all_member_modifier"); var MemberDeclaration = new NonTerminal("member_declaration"); var ConstantDeclaration = new NonTerminal("constant_declaration"); var VariableDeclaration = new NonTerminal("variable_declaration"); var MacroDeclaration = new NonTerminal("macro_declaration"); var VariableDeclarators = new NonTerminal("variable_declarators"); var VariableDeclarator = new NonTerminal("variable_declarator"); var TypeAnnotation = new NonTerminal("type_annotation"); var TypeAnnotationOpt = new NonTerminal("type_annotationOpt"); // types var Type = new NonTerminal("type"); var EmbeddedType = new NonTerminal("embedded_type"); var NumberType = new NonTerminal("number_type"); var IntegralNumberType = new NonTerminal("integral_number_type"); var FloatingNumberType = new NonTerminal("floating_number_type"); var OtherBaseType = new NonTerminal("other_base_type"); var SpecialSupportType = new NonTerminal("special_support_type"); var UserDefinitionType = new NonTerminal("user_definition_type"); // expression var Expression = new NonTerminal("expression"); var ConditionalExpression = new NonTerminal("conditional_expression"); var ConditionalExpressionBody = new NonTerminal("conditional_expression_body"); var BinOpExpression = new NonTerminal("bin_op_expression"); var BinOp = new NonTerminal("bin_op"); var AssignmentExpression = new NonTerminal("assignment_expression"); var UnaryExpression = new NonTerminal("unary_expression"); var UnaryOperator = new NonTerminal("unary_operator"); var PrimaryExpression = new NonTerminal("primary_expression"); var AssignmentOperator = new NonTerminal("assignment_operator"); // loop expression var LoopExpression = new NonTerminal("loop_expression"); var LoopCondition = new NonTerminal("loop_condition"); // return expression var ReturnExpression = new NonTerminal("return_expression"); // switch expression var SwitchExpression = new NonTerminal("switch_expression"); var SwitchSection = new NonTerminal("switch_section"); var SwitchLabel = new NonTerminal("switch_label"); // function expression var FunctionExpression = new NonTerminal("function_expression"); var FunctionSignature = new NonTerminal("function_signature"); var FunctionParameterList = new NonTerminal("function_parameter_list"); var FunctionParameter = new NonTerminal("function_parameter"); var FunctionBody = new NonTerminal("function_body"); var Block = new NonTerminal("block"); var ExpressonList = new NonTerminal("expression_list"); var ExpressionListOpt = new NonTerminal("expression_listOpt"); // member access var IndexBracket = new NonTerminal("index_bracket"); var IndexBracketOpt = new NonTerminal("index_bracketOpt"); IndexBracketOpt.Rule = MakeStarRule(IndexBracketOpt, IndexBracket); var MemberAccess = new NonTerminal("member_access"); var MemberAccessSegmentsOpt = new NonTerminal("member_access_segmentsOpt"); var MemberAccessSegment = new NonTerminal("member_access_segment"); // literal var Literal = new NonTerminal("literal"); var BooleanLiteral = new NonTerminal("boolean_literal"); #endregion #region operators punctuation delimiter RegisterOperators(1, BarBar); RegisterOperators(2, AmpAmp); RegisterOperators(3, Bar); RegisterOperators(4, Caret); RegisterOperators(5, Ampersand); RegisterOperators(6, EqualsEquals, ExclamationEquals); RegisterOperators(7, GreaterThan, LessThan, GreaterThanEqual, LessThanEqual); RegisterOperators(8, GreaterThanGreaterThan, LessThanLessThan); RegisterOperators(9, Plus, Minus); RegisterOperators(10, Asterisk, Slash, Percent); RegisterOperators(-1, QuestionQuestion); RegisterOperators(-2, Question); RegisterOperators(-3, Equals, PlusEqual, MinusEqual, AsteriskEqual, SlashEqual, BarEqual, CaretEqual, GreaterThanGreaterThanEqual, LessThanLessThanEqual); MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":"); MarkTransient(NamespaceMemberDeclaration, MemberDeclaration, Literal, BinOp, PrimaryExpression); AddTermsReportGroup("assignment", Equals, PlusEqual, MinusEqual, AsteriskEqual, SlashEqual, SlashEqual, BarEqual, CaretEqual, GreaterThanGreaterThanEqual, LessThanLessThanEqual); AddTermsReportGroup("unary operator", Plus, Minus, Exclamation); AddToNoReportGroup(Comma, SemiColon); AddToNoReportGroup(VarKeyword, ConstKeyword, PlusPlus, MinusMinus, LBrace, RBrace); #endregion #region Syntax rules // program and namespace Program.Rule = UsingDirectives + NamespaceDeclarations; UsingDirectives.Rule = MakeStarRule(UsingDirectives, null, UsingDirective); UsingDirective.Rule = UsingKeyword + QualifiedIdentifier + SemicolonOpt; QualifiedIdentifier.Rule = MakeStarRule(QualifiedIdentifier, Dot, Identifier); NamespaceDeclaration.Rule = NamespaceKeyword + QualifiedIdentifier + Block + SemicolonOpt; NamespaceDeclarations.Rule = MakeStarRule(NamespaceDeclarations, null, NamespaceDeclaration); NamespaceMemberDeclarations.Rule = MakeStarRule(NamespaceMemberDeclarations, NamespaceMemberDeclaration); NamespaceMemberDeclaration.Rule = NamespaceDeclaration | TypeDeclaration; Block.Rule = LBrace + UsingDirectives + NamespaceMemberDeclarations + RBrace; // member declaration TypeDeclaration.Rule = AllMemberModifiers + MemberDeclaration; AllMemberModifiers.Rule = MakeStarRule(AllMemberModifiers, AllMemberModifier); AllMemberModifier.Rule = PublicKeyword | PrivateKeyword | InternalKeyword; MemberDeclaration.Rule = ConstantDeclaration | VariableDeclaration | MacroDeclaration; ConstantDeclaration.Rule = ConstKeyword + VariableDeclarators; VariableDeclaration.Rule = VarKeyword + VariableDeclarators; MacroDeclaration.Rule = MacroKeyword + VariableDeclarators; VariableDeclarators.Rule = MakePlusRule(VariableDeclarators, Comma, VariableDeclarator); VariableDeclarator.Rule = Identifier + TypeAnnotationOpt + Equals + Expression + SemicolonOpt; TypeAnnotation.Rule = Colon + Type; TypeAnnotationOpt.Rule = TypeAnnotation.Q(); // types Type.Rule = EmbeddedType | UserDefinitionType; EmbeddedType.Rule = NumberType | OtherBaseType | SpecialSupportType; NumberType.Rule = IntegralNumberType | FloatingNumberType | DecimalKeyword; IntegralNumberType.Rule = ByteKeyword | UbyteKeyword | ShortKeyword | UShortKeyword | IntKeyword | UIntKeyword | LongKeyword | ULongKeyword; FloatingNumberType.Rule = HalfKeyword | FloatKeyword | DoubleKeyword; OtherBaseType.Rule = BoolKeyword | CharKeyword; SpecialSupportType.Rule = StringKeyword | ObjectKeyword; UserDefinitionType.Rule = QualifiedIdentifier; #region expressions Expression.Rule = FunctionExpression | BinOpExpression | PrimaryExpression /*| AssignmentExpression | SwitchExpression | LoopExpression | ReturnExpression*/ | ConditionalExpression; ConditionalExpression.Rule = Expression + ConditionalExpressionBody; ConditionalExpressionBody.Rule = PreferShiftHere() + Question + Expression + Colon + Expression; // bin op expression BinOpExpression.Rule = Expression + BinOp + Expression; BinOp.Rule = BarBar | AmpAmp | Bar | Caret | Ampersand | EqualsEquals | ExclamationEquals | GreaterThan | LessThan | GreaterThanEqual | LessThanEqual | GreaterThanGreaterThan | Plus | Minus | Asterisk | Slash | Percent | Equals | PlusEqual | MinusEqual | AsteriskEqual | SlashEqual | BarEqual | CaretEqual | GreaterThanGreaterThanEqual | LessThanLessThanEqual | QuestionQuestion; // primary expresson PrimaryExpression.Rule = Literal | UnaryExpression | MemberAccess; // literal Literal.Rule = NumberLiteral | StringLiteral | TrueKeyword | FalseKeyword; UnaryExpression.Rule = UnaryOperator + PrimaryExpression; UnaryOperator.Rule = Plus | Minus | Exclamation | Asterisk; MemberAccess.Rule = Identifier + MemberAccessSegmentsOpt; MemberAccessSegmentsOpt.Rule = MakeStarRule(MemberAccessSegmentsOpt, MemberAccessSegment); MemberAccessSegment.Rule = Dot + Identifier; // function expression FunctionExpression.Rule = FunctionSignature + Arrow + FunctionBody; FunctionSignature.Rule = LParen + FunctionParameterList + RParen | Identifier; FunctionParameterList.Rule = MakeStarRule(FunctionParameterList, Comma, FunctionParameter); FunctionParameter.Rule = Identifier + TypeAnnotationOpt; FunctionBody.Rule = Expression | Block; ExpressionListOpt.Rule = ExpressonList.Q(); ExpressonList.Rule = MakePlusRule(ExpressonList, Expression); #endregion #endregion Root = Program; }