public void Define() { // the valid modifiers for an enum: public or internal var validModifiers = new NonTerminal("enum_valid_modifiers"); validModifiers.Rule = grammar.Keywords.Public | grammar.Keywords.Internal; grammar.MarkTransient(validModifiers); // Enums can have no or multiple modifiers var modifier = new NonTerminal("enum_modifiers"); modifier.Rule = grammar.MakeStarRule(modifier, validModifiers); // A constant that simply a name, and that will have a value automatically assigned. var identifierConstant = new NonTerminal("identifier_constant"); identifierConstant.Rule = grammar.Identifier + grammar.Eos; // A constant that is assigned a value by the programmer var assignmentConstant = new NonTerminal("assignment_constant"); assignmentConstant.Rule = grammar.Identifier + grammar.ToTerm("=") + grammar.Literals.NumberLiteral + grammar.Eos; // List of valid members of an enum: the previous two constant rules. var enumValidMembers = new NonTerminal("enum_valid_members"); enumValidMembers.Rule = identifierConstant | assignmentConstant; // The list of members in the enum. var enumMemberList = new NonTerminal("enum_member_list"); enumMemberList.Rule = grammar.MakeStarRule(enumMemberList, enumValidMembers); // The enum body is an indent, the list of members, and a dedent. var enumBody = new NonTerminal("enum_body"); enumBody.Rule = grammar.Indent + enumMemberList + grammar.Dedent; grammar.MarkTransient(enumBody); // The enum body is optional var enumListOpt = new NonTerminal("enum_list_opt"); enumListOpt.Rule = grammar.Empty | enumBody; /* enum foo: * bar * bar2 = 24 */ EnumDeclaration.Rule = modifier + grammar.Keywords.Enum + grammar.Identifier + grammar.ToTerm(":") + grammar.Eos + enumListOpt; }
public void Define() { var validParameters = new NonTerminal("valid_parameters"); var simpleParameter = new NonTerminal("simple_parameter"); var outParameter = new NonTerminal("out_parameter"); var arrayParameter = new NonTerminal("array_parameter"); var genericParameter = new NonTerminal("generic_parameter"); var methodStatementsList = new NonTerminal("method_statements_list"); var methodBody = new NonTerminal("method_body"); var genericTypeListEos = new NonTerminal("generic_type_list_eos"); // Comma separated list of zero or more valid method parameters ParameterList.Rule = grammar.MakeStarRule(ParameterList, grammar.ToTerm(","), validParameters); // Valid parameters are simple ones: "int i", arrays "int [] i", directioned "ref int i" or generic "List{int} i" validParameters.Rule = simpleParameter | outParameter | arrayParameter | genericParameter; simpleParameter.Rule = grammar.Identifier + grammar.Identifier; outParameter.Rule = (grammar.Keywords.Out | grammar.Keywords.Ref) + grammar.Identifier + grammar.Identifier; arrayParameter.Rule = grammar.Identifier + grammar.ToTerm("[") + grammar.ToTerm("]") + grammar.Identifier; genericParameter.Rule = grammar.GenericIdentifier + grammar.Identifier; var validModifiers = new NonTerminal("valid_method_modifiers"); validModifiers.Rule = grammar.Keywords.Public | grammar.Keywords.Internal | grammar.Keywords.Abstract | grammar.Keywords.Shared | grammar.Keywords.Protected | grammar.Keywords.Private | grammar.Keywords.Virtual | grammar.Keywords.Final | grammar.Keywords.Override; grammar.MarkTransient(validModifiers); // Modifiers are zero or more from the list of valid ones. Modifier.Rule = grammar.MakeStarRule(Modifier, validModifiers); // "member header" is a Modifier followed by two identifiers. MemberHeader.Rule = Modifier + grammar.TwoIdentifiers; // Method body is a list of statements between an indent and a dedent. methodBody.Rule = grammar.Indent + methodStatementsList + grammar.Dedent; OptionalMethodBody.Rule = grammar.Empty | methodBody; // The list of statements in a method is a list of zero or more expressions. methodStatementsList.Rule = grammar.MakeStarRule(methodStatementsList, grammar.expression); MethodDeclaration.Rule = MemberHeader + grammar.Classes.GenericTypeListOpt + grammar.OpenParenthese + ParameterList + grammar.CloseParenthese + grammar.ToTerm(":") + grammar.Eos + OptionalMethodBody; }
public void Define() { // import System, System.IO Import.Rule = grammar.Keywords.Import + grammar.Lists.StarIdentifierList + grammar.Eos; // The namespace body is optional. var namespaceBodyOpt = new NonTerminal("namespace_body_opt"); namespaceBodyOpt.Rule = (NamespaceBody | grammar.Empty); grammar.MarkTransient(NamespaceBody); // namespace foo: NamespaceDeclaration.Rule = grammar.Keywords.NamespaceKeyword + grammar.Identifier + grammar.ToTerm(":") + grammar.Eos + namespaceBodyOpt; // Valid namespace members are: namespaces, imports, enums, delegates, interfaces, classes NamespaceValidMembers.Rule = NamespaceDeclaration | grammar.Classes.ClassDeclaration | Import | grammar.Enums.EnumDeclaration | grammar.Delegates.DelegateDeclaration | grammar.Interfaces.InterfaceDeclaration; grammar.MarkTransient(NamespaceValidMembers); // The list of members in the namespace. NamespaceMembersList.Rule = grammar.MakeStarRule(NamespaceMembersList, NamespaceValidMembers); grammar.MarkTransient(NamespaceMembersList); // The body of the namespace is an indent, a member list, and a dedent. NamespaceBody.Rule = grammar.Indent + NamespaceMembersList + grammar.Dedent; }
// Define the rules (declaration and definition must be separate). public void Define() { // List of base types var baseTypeList = new NonTerminal("base_type_list"); // List of members in the class body var membersList = new NonTerminal("class_members_list"); // The members that may go into a member list. var validMembers = new NonTerminal("class_valid_members"); // The optional body of the class var memberBodyOpt = new NonTerminal("member_body_opt"); // The modifiers that may make up a class. var validClassModifiers = new NonTerminal("valid_class_modifiers"); // The rule describing which modifiers can be applied to a class variable. var classVariableValidModifers = new NonTerminal("classVariableValidModifiers"); classVariableValidModifers.Rule = grammar.Keywords.Public | grammar.Keywords.Private | grammar.Keywords.Protected | grammar.Keywords.Internal | grammar.Keywords.Final | grammar.Keywords.Shared; // A list rule is needed as there can be more than one modifier. ClassVariableModifierList.Rule = grammar.MakeStarRule(ClassVariableModifierList, classVariableValidModifers); // The rule to declare a class varible: public int foo var classVariable = new NonTerminal("class_variable"); classVariable.Rule = grammar.MethodDeclarations.MemberHeader + grammar.Eos; // The rule describing which modifiers can be used for a class declaration validClassModifiers.Rule = grammar.Keywords.Public | grammar.Keywords.Internal | grammar.Keywords.Final | grammar.Keywords.Partial | grammar.Keywords.Abstract; grammar.MarkTransient(validClassModifiers); // A list rule since there can be more than on modifier. Modifier.Rule = grammar.MakeStarRule(Modifier, validClassModifiers); // Could be a class, struct, or module var classStructOrModule = new NonTerminal("class_or_module"); classStructOrModule.Rule = grammar.Keywords.Class | grammar.Keywords.Module | grammar.Keywords.Struct; grammar.MarkTransient(classStructOrModule); // (basetype1, basetype2) baseTypeList.Rule = grammar.OpenParenthese + grammar.Lists.PlusIdentifierList + grammar.CloseParenthese; // Base type list is optional: it may be empty BaseTypeListOpt.Rule = grammar.Empty | baseTypeList; // {T,L} GenericTypeList.Rule = grammar.ToTerm("{") + grammar.Lists.PlusIdentifierList + grammar.ToTerm("}"); // Generic type list is optional. GenericTypeListOpt.Rule = grammar.Empty | GenericTypeList; // Class body is a list of members between an indent and a dedent var memberBody = new NonTerminal("member_body"); memberBody.Rule = (grammar.Indent + membersList + grammar.Dedent); grammar.MarkTransient(memberBody); // member list is optional: it may be empty. var optionalMembersList = new NonTerminal("optional_members_list"); optionalMembersList.Rule = grammar.Empty | membersList; // Body of the class is optional memberBodyOpt.Rule = grammar.Empty | memberBody; /* class foo{T,K}(basetype1,basetype2}: * memberlist */ ClassDeclaration.Rule = Modifier + classStructOrModule + grammar.Identifier + GenericTypeListOpt + BaseTypeListOpt + grammar.ToTerm(":") + grammar.Eos + memberBodyOpt; // Valid class members are methods, constructors, variables, properties, and events. validMembers.Rule = grammar.MethodDeclarations.MethodDeclaration | classVariable | grammar.Constructors.ConstructorDeclaration | grammar.Properties.PropertyDeclaration | grammar.Delegates.EventMember; membersList.Rule = grammar.MakeStarRule(membersList, validMembers); }
public void Define() { StarIdentifierList.Rule = grammar.MakeStarRule(StarIdentifierList, grammar.ToTerm(","), grammar.Identifier); PlusIdentifierList.Rule = grammar.MakePlusRule(PlusIdentifierList, grammar.ToTerm(","), grammar.Identifier); grammar.MarkTransient(StarIdentifierList); }
public void Define() { // The rule describing all valid binary operators. ValidBinaryOperators.Rule = Add | Modulo | Divide | LessOrEqual | Less | Greater | GreaterOrEqual | Equal | NotEqual | grammar.Keywords.And | grammar.Keywords.Or | BitwiseShiftRight | BitwiseShiftLeft | BitwiseOr | BitwiseAnd | BitwiseXor | Subtract | Multiply | As; grammar.MarkTransient(ValidBinaryOperators); // Set operators precedence and associativity, in increasing order of precedence. int precedence = 1; grammar.RegisterOperators(precedence += 1, Associativity.Right, "=", "+=", "-=", "/=", "*=", "|=", "&=", "^="); grammar.RegisterOperators(precedence += 1, Associativity.Left, "||"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "&&"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "|"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "^"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "&"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "==", "!="); grammar.RegisterOperators(precedence += 1, Associativity.Left, "<", ">", ">=", "<="); grammar.RegisterOperators(precedence += 1, Associativity.Left, "<<", ">>"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "+", "-"); grammar.RegisterOperators(precedence += 1, Associativity.Left, "*", "/", "%"); grammar.RegisterOperators(precedence += 1, Associativity.Right, "!", "-"); grammar.RegisterOperators(precedence += 1, As); // Casting // Set comma and closing brace as operators so that lists can continue on the next line. grammar.RegisterOperators(0, grammar.ToTerm("}")); grammar.RegisterOperators(0, grammar.ToTerm(",")); // An operator expression: two expressions with the operator between BinaryOperator.Rule = grammar.expression + ValidBinaryOperators + grammar.expression; // The list of valid assignment operators: +=, -=, *=, /=, |*, &=, ^= var validAssigments = new NonTerminal("valid_assigments"); validAssigments.Rule = EqualsAssignment | AddAssignment | SubtractAssignment | MultiplyAssignment | DivideAssignment | OrAssignment | AndAssignment | XorAssignment; grammar.MarkTransient(validAssigments); // Assignment expression is an expression that can be assigned to, the operator, and the assigned expression. Assignment.Rule = grammar.Assignable + validAssigments + grammar.expression + (grammar.Empty | grammar.Eos); // Valid unary operators. ValidUnaryOperators.Rule = Not | Negate; // Unary operator + expression UnaryOperator.Rule = ValidUnaryOperators + grammar.expression + (grammar.Empty | grammar.Eos); grammar.MarkReservedWords("As"); }