public SpeechExpression() { FreeTextLiteral text = new FreeTextLiteral(TextLiteralName, FreeTextOptions.AllowEof, AliasSymbol, VarSymbol, OpenBracketSymbol, ArgSeparatorSymbol, CloseBracketSymbol); IdentifierTerminal name = TerminalFactory.CreateCSharpIdentifier(NameLiteralName); NonTerminal root = new NonTerminal(RootExpressionName); NonTerminal expression = new NonTerminal(ExpressionLiteralName); NonTerminal argumentList = new NonTerminal(ArgumentListLiteralName); NonTerminal alias = new NonTerminal(AliasLiteralName); NonTerminal variable = new NonTerminal(VariableLiteralName); argumentList.Rule = MakePlusRule(argumentList, ToTerm(ArgSeparatorSymbol), root); alias.Rule = AliasSymbol + name + OpenBracketSymbol + argumentList + CloseBracketSymbol | AliasSymbol + name; variable.Rule = VarSymbol + name; expression.Rule = text | variable | alias; root.Rule = MakeStarRule(root, expression); Root = root; text.Escapes.Add("\\" + AliasSymbol, AliasSymbol); text.Escapes.Add("\\" + VarSymbol, VarSymbol); text.Escapes.Add("\\" + OpenBracketSymbol, OpenBracketSymbol); text.Escapes.Add("\\" + CloseBracketSymbol, CloseBracketSymbol); text.Escapes.Add("\\" + ArgSeparatorSymbol, ArgSeparatorSymbol); MarkTransient(root, expression); RegisterBracePair(OpenBracketSymbol, CloseBracketSymbol); }
public ListRules(PieGrammar grammar) { this.grammar = grammar; StarIdentifierList = new NonTerminal("star_identifer_list"); PlusIdentifierList = new NonTerminal("plus_identfier_list"); }
public FabricGrammar(): base(false) // case non-sensitive { // Terminal Definitions RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+"); // Non-Terminal Definitions NonTerminal program = new NonTerminal("program"), createStatement = new NonTerminal("createStatement"), startStatement = new NonTerminal("startStatement"), moveStatements = new NonTerminal("moveStatements"), moveStatement = new NonTerminal("moveStatement"), direction = new NonTerminal("direction"); // Relation Definitions program.Rule = createStatement + startStatement + moveStatements; createStatement.Rule = ToTerm("Create") + "a" + number + "by" + number + "grid"; startStatement.Rule = ToTerm("Start") + "at" + "location" + number + "," + number; moveStatements.Rule = MakePlusRule(moveStatements, moveStatement); moveStatement.Rule = ToTerm("Move") + direction + number; direction.Rule = ToTerm("up") | "down" | "right" | "left"; // Set the Root this.Root = program; // Set the Markup Register MarkPunctuation("Create", "a", "grid", "by", "Start", "at", "location", ",", "Move"); }
public ExceptionRules(PieGrammar grammar) { this.grammar = grammar; ExceptionHandlingBlock = new NonTerminal("exception_handling_block"); ThrowStatement = new NonTerminal("throw_statement"); }
public ExpressionGrammar() { var Number = new NumberLiteral("Number"); var Var = new IdentifierTerminal("Var"); var conditional_expression = new NonTerminal("conditional_expression"); //conditional_expression.Rule = expression + PreferShiftHere() + qmark + expression + colon + expression; //NonTerminal DataType = new NonTerminal("DataType"); NonTerminal DecSt = new NonTerminal("DecSt"); DecSt.Rule = "int" + Var + "=" + Number + ";" | "int" + Var + ";"; NonTerminal PrintSt = new NonTerminal("PrintSt"); PrintSt.Rule = "cout <<" + Var; //NonTerminal IF = new NonTerminal("IF"); //IF.Rule = "if( + ; NonTerminal stmt = new NonTerminal("stmt"); stmt.Rule = PrintSt | DecSt; NonTerminal stmt1 = new NonTerminal("stmt"); stmt1.Rule = "begin{" + stmt + "}end;"; this.Root = DecSt; }
protected override NonTerminal MakeRoot() { var root = new NonTerminal("root"); Productions(root); return root; }
public E2Grammar() { LineTerminators = "\r\n"; var program = new NonTerminal("Program"); var directiveList = new NonTerminal("DirectiveList"); var directive = new NonTerminal("Directive"); var directiveName = new IdentifierTerminal("DirectiveName"); var directiveBody = new NonTerminal("DirectiveBody"); var statementList = new NonTerminal("StatementList"); var statement = new NonTerminal("Statement"); var assignment = new NonTerminal("Assignment"); var expression = new NonTerminal("Expression"); var parenExpression = new NonTerminal("ParenExpression"); var methodCall = new NonTerminal("MethodCall"); var argumentList = new NonTerminal("ArgumentList"); var argumentTail = new NonTerminal("ArgumentTail"); var @operator = new NonTerminal("Operator"); var operation = new NonTerminal("Operation"); var identifier = new IdentifierTerminal("Identifier"); var @string = new StringLiteral("String", "\""); var number = new NumberLiteral("Number"); var ifStatement = new NonTerminal("IfStatement"); var whileStatement = new NonTerminal("WhileStatement"); var comment = new CommentTerminal("comment", "#", new[] {"\n"}); var dcom = new CommentTerminal("commentCheat", "@", new[] {"\n"}); Root = program; NonGrammarTerminals.Add(comment); NonGrammarTerminals.Add(dcom); RegisterBracePair("{", "}"); program.Rule = /* directiveList + */statementList; //directiveList.Rule = MakePlusRule(directiveList, null, directive); //directiveBody.Rule = new CommentTerminal() //directive.Rule = ToTerm("@") + directiveName + directiveBody; statementList.Rule = MakePlusRule(statementList, null, statement); statement.Rule = methodCall | assignment; expression.Rule = operation | @string | number | methodCall | identifier; parenExpression.Rule = ToTerm("(") + expression + ")"; methodCall.Rule = expression + ":" + identifier + "(" + argumentList + ")"; argumentList.Rule = MakeStarRule(argumentList, ToTerm(","), expression); operation.Rule = expression + @operator + expression; @operator.Rule = ToTerm("+") | "-" | "*" | "/" | "&" | "|"; assignment.Rule = identifier + "=" + expression; ifStatement.Rule = ToTerm("if") + parenExpression + "{" + statementList + "}"; whileStatement.Rule = ToTerm("while") + parenExpression + "{" + statementList + "}"; }
public WhileLoopRules(PieGrammar grammar) { this.grammar = grammar; SimpleWhileLoop = new NonTerminal("simple_while_loop"); BodiedWhileLoop = new NonTerminal("bodied_while_loop"); }
/// <summary> /// Initializes a new instance of the <see cref="Parser"/> class. /// </summary> /// <param name="language">The language.</param> /// <param name="scanner">The scanner.</param> /// <param name="root">The root.</param> /// <exception cref="Exception"> /// </exception> public Parser(LanguageData language, Scanner scanner, NonTerminal root) { Language = language; Context = new ParsingContext(this); Scanner = scanner ?? language.CreateScanner(); if (Scanner != null) { Scanner.Initialize(this); } else { Language.Errors.Add(GrammarErrorLevel.Error, null, "Scanner is not initialized for this grammar"); } CoreParser = new CoreParser(this); Root = root; if (Root == null) { Root = Language.Grammar.Root; InitialState = Language.ParserData.InitialState; } else { if (Root != Language.Grammar.Root && !Language.Grammar.SnippetRoots.Contains(Root)) { throw new Exception(string.Format(Resources.ErrRootNotRegistered, root.Name)); } InitialState = Language.ParserData.InitialStates[Root]; } }
public ProjectsGrammar() { // Todo // Fix Note to work actually right, just take the rest of the text // Define Terminals var taskName = new TaskTerminal("TaskName"); var projectName = new ProjectTerminal("ProjectName"); var noteText = new NoteTerminal("NoteText"); // Define Non-Terminals var notes = new NonTerminal("Notes", typeof(StatementListNode)); var project = new NonTerminal("Project", typeof (StatementListNode)); var task = new NonTerminal("Task", typeof (StatementListNode)); var tasks = new NonTerminal("Tasks", typeof (StatementListNode)); var program = new NonTerminal("ProgramLine", typeof(StatementListNode)); // Define Rules notes.Rule = MakeStarRule(notes, noteText); task.Rule = taskName + notes; tasks.Rule = MakeStarRule(tasks, task); project.Rule = projectName +notes + tasks; program.Rule = MakeStarRule(program, project); Root = program; LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.CanRunSample; }
public override void ForCircleDefinition(NonTerminal circleDef, NonTerminal coordSet) { AstBuilder(circleDef, (context, node) => { throw new InvalidOperationException("SqlGeometryParser cannot handle circle-like structures if the output style is set to GeometryCollection"); }); }
public XamlMarkupExtensionGrammar() { // Non Terminals var markupExtension = new NonTerminal(MarkupExtensionTerm); var arguments = new NonTerminal("Arguments"); var namedArgs = new NonTerminal("NamedArgs"); var namedArg = new NonTerminal(NamedArgumentTerm); var positionalArgs = new NonTerminal("PositionalArgs"); var argument = new NonTerminal("Argument"); // Terminals var typeName = new TypeNameTerminal(TypeNameTerm); var memberName = new MemberNameTerminal(MemberNameTerm); var @string = new StringTerminal(StringTerm); var startExtension = this.ToTransientTerm("{"); var endExtension = this.ToTransientTerm("}"); var namedArgumentSeparator = this.ToTransientTerm("="); var argumentSeparator = this.ToTransientTerm(","); // Setup rules markupExtension.Rule = (startExtension + typeName + endExtension) | (startExtension + typeName + arguments + endExtension); arguments.Rule = namedArgs | positionalArgs | (positionalArgs + argumentSeparator + namedArgs); namedArgs.Rule = namedArg | (namedArg + argumentSeparator + namedArgs); namedArg.Rule = (memberName + namedArgumentSeparator + argument); positionalArgs.Rule = namedArgs | argument | (argument + argumentSeparator + positionalArgs); argument.Rule = markupExtension | @string; this.Root = markupExtension; this.MarkTransient(arguments, argument); }
public JsonGrammar() { //Terminals var jstring = new StringLiteral("string", "\""); var jnumber = new NumberLiteral("number"); var comma = ToTerm(","); //Nonterminals var jobject = new NonTerminal("Object"); var jobjectBr = new NonTerminal("ObjectBr"); var jarray = new NonTerminal("Array"); var jarrayBr = new NonTerminal("ArrayBr"); var jvalue = new NonTerminal("Value"); var jprop = new NonTerminal("Property"); //Rules jvalue.Rule = jstring | jnumber | jobjectBr | jarrayBr | "true" | "false" | "null"; jobjectBr.Rule = "{" + jobject + "}"; jobject.Rule = MakeStarRule(jobject, comma, jprop); jprop.Rule = jstring + ":" + jvalue; jarrayBr.Rule = "[" + jarray + "]"; jarray.Rule = MakeStarRule(jarray, comma, jvalue); //Set grammar root this.Root = jvalue; MarkPunctuation("{", "}", "[", "]", ":", ","); this.MarkTransient(jvalue, jarrayBr, jobjectBr); }//constructor
public void Define() { /* case <expression>: * <expression> */ var caseBlock = new NonTerminal("case_block"); caseBlock.Rule = grammar.Keywords.Case + grammar.expression + grammar.ToTerm(":") + grammar.Eos + grammar.MethodDeclarations.OptionalMethodBody; // List of case block expressions. var caseBlockList = new NonTerminal("case_block_list"); caseBlockList.Rule = grammar.MakeStarRule(caseBlockList, caseBlock); // The list of case block expressions is optional. var caseBlockListOpt = new NonTerminal("case_block_list_opt"); caseBlockListOpt.Rule = (grammar.Indent + caseBlockList +grammar.Dedent) | grammar.Empty; /* switch <expression>: * case <expression>: * <expression> */ SwitchBlock.Rule = grammar.Keywords.Switch + grammar.expression + grammar.ToTerm(":") + grammar.Eos + caseBlockListOpt; }
//#AS:2012/12/08: grammar is case-insensitive public CameraControlGrammar() : base(caseSensitive: false) { var program = new NonTerminal("program"); var cameraSize = new NonTerminal("cameraSize"); var cameraPosition = new NonTerminal("cameraPosition"); var commandList = new NonTerminal("commandList"); var command = new NonTerminal("command"); var direction = new NonTerminal("direction"); var number = new NumberLiteral("number"); this.Root = program; //Grammar production rules in bnf form // <Program> ::= <CameraSize> <CameraPosition> <CommandList> program.Rule = cameraSize + cameraPosition + commandList; // <CameraSize> ::= "set" "camera" "size" ":" <number> "by" <number> "pixels" "." cameraSize.Rule = ToTerm("set") + "camera" + "size" + ":" + number + "by" + number + "pixels" + "."; // <CameraPosition> ::= "set" "camera" "position" ":" <number> "," <number> "." cameraPosition.Rule = ToTerm("set") + "camera" + "position" + ":" + number + "," + number + "."; // <CommandList> ::= <Command>+ commandList.Rule = MakePlusRule(commandList, null, command); // <Command> ::= "move" <number> "pixels" <Direction> "." command.Rule = ToTerm("move") + number + "pixels" + direction + "."; // <Direction> ::= "up" | "down" | "left" | "right" direction.Rule = ToTerm("up") | "down" | "left" | "right"; //#AS:2012/12/08: these symbols are defined as puntuation, so they will not be included in the ast this.MarkPunctuation("set", ("camera"), "size", ":", "by", "pixels", ".", "position", ",", "move"); }
public TestGrammar() { var root = new NonTerminal("root"); root.Rule = Empty; this.Root = root; this.Delimiters = ",;(){}"; //important for quick-parse tests }
public static BnfExpression MakeStarRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember, TermListOptions options) { bool allowTrailingDelimiter = (options & TermListOptions.AllowTrailingDelimiter) != 0; if (delimiter == null) { //it is much simpler case listNonTerminal.SetFlag(TermFlags.IsList); listNonTerminal.Rule = _currentGrammar.Empty | listNonTerminal + listMember; return(listNonTerminal.Rule); } //Note that deceptively simple version of the star-rule // Elem* -> Empty | Elem | Elem* + delim + Elem // does not work when you have delimiters. This simple version allows lists starting with delimiters - // which is wrong. The correct formula is to first define "Elem+"-list, and then define "Elem*" list // as "Elem* -> Empty|Elem+" NonTerminal plusList = new NonTerminal(listMember.Name + "+"); plusList.Rule = MakePlusRule(plusList, delimiter, listMember); plusList.SetFlag(TermFlags.NoAstNode); //to allow it to have AstNodeType not assigned if (allowTrailingDelimiter) { listNonTerminal.Rule = _currentGrammar.Empty | plusList | plusList + delimiter; } else { listNonTerminal.Rule = _currentGrammar.Empty | plusList; } listNonTerminal.SetFlag(TermFlags.IsListContainer); return(listNonTerminal.Rule); }
public GridWorldGrammar() { this.GrammarComments = "A grammar for GridWorld"; //Terminals RegexBasedTerminal number = new RegexBasedTerminal("number", "[0-9]+"); //Non terminals NonTerminal program = new NonTerminal("program"); NonTerminal createStatement = new NonTerminal("createStatement", typeof(StartNode)); NonTerminal startStatement = new NonTerminal("startStatement", typeof(StartNode)); NonTerminal moveStatements = new NonTerminal("moveStatements", typeof(MovesNode)); NonTerminal moveStatement = new NonTerminal("moveStatement", typeof(MoveNode)); NonTerminal direction = new NonTerminal("direction", typeof(DirectionNode)); //BNF rules program.Rule = createStatement + startStatement + moveStatements; createStatement.Rule = ToTerm("Create") + "a" + number + "by" + number + "grid" + "."; startStatement.Rule = ToTerm("Start") + "at" + "location" + number + "," + number + "."; moveStatements.Rule = MakePlusRule(moveStatements, moveStatement); moveStatement.Rule = "Move" + direction + number + "."; direction.Rule = ToTerm("up") | "down" | "right" | "left"; this.Root = program; this.LanguageFlags = LanguageFlags.CreateAst; MarkPunctuation("Create", "a", "grid", "by", "Start", "at","location", ",", ".", "Move"); }
public ForLoopRules(PieGrammar grammar) { this.grammar = grammar; SimpleForLoop = new NonTerminal("simple_for_loop"); BodiedForLoop = new NonTerminal("bodied_for_loop"); }
public GrammarExL514() { NonTerminal A = new NonTerminal("A"); Terminal a = new Terminal("a"); A.Rule = "(" + A + ")" | a; this.Root = A; }//method
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 KISGrammer() { var number = new NumberLiteral("number"); var text = new StringLiteral("string", "\""); number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt }; var identifier = new IdentifierTerminal("identifier"); var comment = new CommentTerminal("comment", "#", "\n", "\r"); base.NonGrammarTerminals.Add(comment); var Code = new NonTerminal("code"); var Statments = new NonTerminal("statments"); var Value = new NonTerminal("value"); var ValueString = TerminalFactory.CreateCSharpString("valuestring"); var SetStmt = new NonTerminal("setstmt"); var CallStmt = new NonTerminal("callstmt"); var FnStmt = new NonTerminal("fnstmt"); var CallPath = new NonTerminal("callpath"); var CallPerams = new NonTerminal("callperams"); var fullstop = new NonTerminal("fullstop"); var comma = new NonTerminal("comma"); var openb = new NonTerminal("openb"); var closeb = new NonTerminal("closeb"); openb.Rule = "{"; closeb.Rule = "}"; fullstop.Rule = "."; comma.Rule = ","; CallPath.Rule = MakePlusRule(CallPath, fullstop, identifier); CallPerams.Rule = MakePlusRule(CallPerams, comma, Value); var Semicolon = ToTerm(";"); //StateMents: SetStmt.Rule = identifier + "=" + Value + Semicolon; CallStmt.Rule = (CallPath | identifier) + "(" + (CallPerams | Empty) + ")" + Semicolon; FnStmt.Rule = "function" + identifier + "(" + (CallPerams | Empty) + ")"; Statments.Rule = SetStmt | CallStmt | FnStmt | openb | closeb | Empty; var Exspr = new NonTerminal("exspr"); var Operator = new NonTerminal("operator"); var ExsprStmt = new NonTerminal("exsprstmt"); Operator.Rule = ToTerm("/") | "*" | "-" | "+"; ExsprStmt.Rule = Value + Operator + Value; Exspr.Rule = MakePlusRule(Exspr, Operator, ExsprStmt); Value.Rule = number | ValueString | identifier | "true" | "false" | Exspr /* | text */; Code.Rule = MakePlusRule(Code, NewLine, Statments); LanguageFlags = LanguageFlags.NewLineBeforeEOF; //code := Statment {statment} this.Root = Code; }
public static BnfExpression MakePlusRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember) { if (delimiter == null) listNonTerminal.Rule = listMember | listNonTerminal + listMember; else listNonTerminal.Rule = listMember | listNonTerminal + delimiter + listMember; listNonTerminal.SetFlag(TermFlags.IsList); return listNonTerminal.Rule; }
public override void ForGeometryCollection(NonTerminal geometryCollection, NonTerminal geometryDef) { AstBuilder(geometryCollection, (context, node) => { var geometries = GetAllAstNodesOf<GeoJSONObject>(node, geometryDef); node.AstNode = new GeometryCollection(geometries.OfType<IGeometryObject>().ToList()); }); }
private NonTerminal Alter() { var alterCommand = new NonTerminal("alter_command"); alterCommand.Rule = AlterTable() | AlterUser(); return alterCommand; }
public override void ForGeometryCollection(NonTerminal geometryCollection, NonTerminal geometryDef) { AstBuilder(geometryCollection, (context, node) => { var geometries = GetAllAstNodesOf<Feature>(node, geometryDef).ToList(); node.AstNode = new FeatureCollection(geometries); }); }
public IntegrationTestGrammar() { var comment = new CommentTerminal("comment", "/*", "*/"); base.NonGrammarTerminals.Add(comment); var str = new StringLiteral("str", "'", StringOptions.AllowsLineBreak); var stmt = new NonTerminal("stmt"); stmt.Rule = str | Empty; this.Root = stmt; }
/// <summary> /// Class constructor and grammar definition /// </summary> public FtpGrammar() : base(false) { // declare keywords var openKeyword = ToTerm("open"); var changeDirKeyword = ToTerm("cd"); var dirKeyword = ToTerm("dir"); var listKeyword = ToTerm("ls"); var closeKeyword = ToTerm("close"); var getKeyword = ToTerm("get"); var byeKeyword = ToTerm("bye"); var backfolderKeyword = ToTerm(".."); var rootfolderKeyword = ToTerm(@"\"); // declare non-terminals var program = new NonTerminal("program"); var commandList = new NonTerminal("commandList"); var command = new NonTerminal("command"); var openCommand = new NonTerminal("open"); var changeDirCommand = new NonTerminal("cd"); var dirCommand = new NonTerminal("dir"); var closeCommand = new NonTerminal("close"); var getCommand = new NonTerminal("get"); var byeCommand = new NonTerminal("byeCommand"); var url = new NonTerminal("url"); var folderName = new NonTerminal("folderName"); var quotedUrl = new StringLiteral("quotedUrl", "\""); var unquotedUrl = new IdentifierTerminal("unquotedUrl"); var quotedIdentifier = new StringLiteral("quotedIdentifier", "\""); var unquotedIdentifier = new IdentifierTerminal("unquotedIdentifier"); var filename = new RegexBasedTerminal("filename", @"[a-zA-Z0-9\.\-_]+"); // note: space not allowed. // grammar rules program.Rule = commandList; commandList.Rule = this.MakePlusRule(commandList, null, command); command.Rule = openCommand | changeDirCommand | dirCommand | closeCommand | getCommand | byeCommand; openCommand.Rule = openKeyword + url + this.NewLine; // string_literal + string_literal + changeDirCommand.Rule = changeDirKeyword + rootfolderKeyword + this.NewLine | changeDirKeyword + backfolderKeyword + this.NewLine | changeDirKeyword + folderName + this.NewLine; dirCommand.Rule = (dirKeyword | listKeyword) + this.NewLine; closeCommand.Rule = closeKeyword + this.NewLine; getCommand.Rule = getKeyword + unquotedIdentifier + this.NewLine; // vai ser preciso usar uma regex para o nome do ficheiro byeCommand.Rule = byeKeyword + this.NewLine; //// string regex = @"^[a-zA-Z0-9\.-_ ]+$" (cuidado com ., .., ...) e os espaços //// inválidos: \/:*?"<>| url.Rule = quotedUrl | unquotedUrl; folderName.Rule = quotedIdentifier | filename; // remove these notes as children in the AST this.MarkPunctuation("open", "dir", "ls", "close", "get", "cd", "bye"); this.Root = program; // LanguageFlags |= LanguageFlags.CreateAst; }
public IfBlockRules(PieGrammar grammar) { this.grammar = grammar; SimpleIfBlock = new NonTerminal("simple_if_block"); BodiedIfBlock = new NonTerminal("bodied_if_block"); SimpleElseBlock = new NonTerminal("simple_else_block"); BodiedElseBlock = new NonTerminal("bodied_else_block"); }
public PowerPCGrammar() : base(false) { var number = new NumberLiteral("number", NumberOptions.Default); var REGCHAR = ToTerm("r"); REGCHAR.AllowAlphaAfterKeyword = true; var register = new NonTerminal("register"); register.Rule = REGCHAR + number; var program = new NonTerminal("program"); var statementList = new NonTerminal("statementList"); var statement = new NonTerminal("statement"); var comma = ","; var li = new NTerminal("li"); var add = new NTerminal("add"); var addi = new NTerminal("addi"); var addc = new NTerminal("addc"); var and = new NTerminal("and"); var andc = new NTerminal("andc"); var andi = new NTerminal("andi"); var andis = new NTerminal("andis"); var cmp = new NTerminal("cmp"); var sub = new NTerminal("sub"); var subi = new NTerminal("subi"); var print = new NTerminal("print"); li.Rule = li.term + register + comma + number; add.Rule = add.term + register + comma + register + comma + register; addi.Rule = addi.term + register + comma + register + comma + number; addc.Rule = addc.term + register + comma + register + comma + register; and.Rule = and.term + register + comma + register + comma + register; andc.Rule = andc.term + register + comma + register + comma + register; andi.Rule = andi.term + register + comma + register + comma + number; andis.Rule = andis.term + register + comma + register + comma + number; cmp.Rule = cmp.term + register + comma + register; sub.Rule = sub.term + register + comma + register + comma + register; subi.Rule = subi.term + register + comma + register + comma + number; print.Rule = print.term | print.term + register | print.term + register + "..." + register; program.Rule = statementList; statementList.Rule = MakeStarRule(statementList, NewLine, statement); this.MarkPunctuation(comma, ";", "..."); foreach (NTerminal n in NTerminal.termList) { if (statement.Rule == null) statement.Rule = n.keyTerm; else statement.Rule = statement.Rule | n.keyTerm; MarkPunctuation(n.term); } this.Root = program; }
protected override NonTerminal MakeRoot() { Semicolon = ToTerm("."); var root = new NonTerminal("root"); Productions(root); return root; }
public override void ForGeometry(NonTerminal geometryDef) { AstBuilder(geometryDef, (context, node) => { node.AstNode = node.ChildNodes.Count == 1 ? node.ChildNodes[0].AstNode : new Feature(new GeometryCollection(node.ChildNodes.Select(ptn => ptn.AstNode).OfType<IGeometryObject>().ToList())); }); }
public NonTerminal Star() { if (_star != null) { return(_star); } _star = new NonTerminal(this.Name + "*"); _star.Rule = Grammar.MakeStarRule(_star, this); return(_star); }
public NonTerminal Plus() { if (_plus != null) { return(_plus); } _plus = new NonTerminal(this.Name + "+"); _plus.Rule = Grammar.MakePlusRule(_plus, this); return(_plus); }
NonTerminal _q, _plus, _star; //cash them public NonTerminal Q() { if (_q != null) { return(_q); } _q = new NonTerminal(this.Name + "?"); _q.Rule = this | Grammar.CurrentGrammar.Empty; return(_q); }
public static BnfExpression MakePlusRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember, TermListOptions options) { bool allowTrailingDelimiter = (options & TermListOptions.AllowTrailingDelimiter) != 0; if (delimiter == null || !allowTrailingDelimiter) return MakePlusRule(listNonTerminal, delimiter, listMember); //create plus list var plusList = new NonTerminal(listMember.Name + "+"); plusList.Rule = MakePlusRule(listNonTerminal, delimiter, listMember); listNonTerminal.Rule = plusList | plusList + delimiter; listNonTerminal.SetFlag(TermFlags.IsListContainer); return listNonTerminal.Rule; }
protected BnfExpression MakeListRule(NonTerminal list, BnfTerm delimiter, BnfTerm listMember, TermListOptions options = TermListOptions.PlusList) { //If it is a star-list (allows empty), then we first build plus-list var isPlusList = !options.IsSet(TermListOptions.AllowEmpty); var allowTrailingDelim = options.IsSet(TermListOptions.AllowTrailingDelimiter) && delimiter != null; //"plusList" is the list for which we will construct expression - it is either extra plus-list or original list. // In the former case (extra plus-list) we will use it later to construct expression for list NonTerminal plusList = isPlusList ? list : new NonTerminal(listMember.Name + "+"); plusList.SetFlag(TermFlags.IsList); plusList.Rule = plusList; // rule => list if (delimiter != null) { plusList.Rule += delimiter; // rule => list + delim } if (options.IsSet(TermListOptions.AddPreferShiftHint)) { plusList.Rule += PreferShiftHere(); // rule => list + delim + PreferShiftHere() } plusList.Rule += listMember; // rule => list + delim + PreferShiftHere() + elem plusList.Rule |= listMember; // rule => list + delim + PreferShiftHere() + elem | elem if (isPlusList) { // if we build plus list - we're almost done; plusList == list // add trailing delimiter if necessary; for star list we'll add it to final expression if (allowTrailingDelim) { plusList.Rule |= list + delimiter; // rule => list + delim + PreferShiftHere() + elem | elem | list + delim } } else { // Setup list.Rule using plus-list we just created list.Rule = Empty | plusList; if (allowTrailingDelim) { list.Rule |= plusList + delimiter | delimiter; } plusList.SetFlag(TermFlags.NoAstNode); list.SetFlag(TermFlags.IsListContainer); //indicates that real list is one level lower } return(list.Rule); }//method
public Parser(LanguageData language, NonTerminal root) { Language = language; Data = Language.ParserData; _grammar = Language.Grammar; Context = new ParsingContext(this); Scanner = new Scanner(this); Root = root; if (Root == null) { Root = Language.Grammar.Root; InitialState = Language.ParserData.InitialState; } else { if (Root != Language.Grammar.Root && !Language.Grammar.SnippetRoots.Contains(Root)) { throw new Exception(string.Format(Resources.ErrRootNotRegistered, root.Name)); } InitialState = Language.ParserData.InitialStates[Root]; } }
protected BnfExpression MakeListRule(NonTerminal list, BnfTerm delimiter, BnfTerm listMember, TermListOptions options = TermListOptions.PlusList) { //If it is a star-list (allows empty), then we first build plus-list var isStarList = options.IsSet(TermListOptions.AllowEmpty); NonTerminal plusList = isStarList ? new NonTerminal(listMember.Name + "+") : list; //"list" is the real list for which we will construct expression - it is either extra plus-list or original listNonTerminal. // In the latter case we will use it later to construct expression for listNonTerminal plusList.Rule = plusList; // rule => list if (delimiter != null) { plusList.Rule += delimiter; // rule => list + delim } if (options.IsSet(TermListOptions.AddPreferShiftHint)) { plusList.Rule += PreferShiftHere(); // rule => list + delim + PreferShiftHere() } plusList.Rule += listMember; // rule => list + delim + PreferShiftHere() + elem plusList.Rule |= listMember; // rule => list + delim + PreferShiftHere() + elem | elem //trailing delimiter if (options.IsSet(TermListOptions.AllowTrailingDelimiter) & delimiter != null) { plusList.Rule |= list + delimiter; // => list + delim + PreferShiftHere() + elem | elem | list + delim } // set Rule value plusList.SetFlag(TermFlags.IsList); //If we do not use exra list - we're done, return list.Rule if (plusList == list) { return(list.Rule); } // Let's setup listNonTerminal.Rule using plus-list we just created //If we are here, TermListOptions.AllowEmpty is set, so we have star-list list.Rule = Empty | plusList; plusList.SetFlag(TermFlags.NoAstNode); list.SetFlag(TermFlags.IsListContainer); //indicates that real list is one level lower return(list.Rule); }//method
public ParseTreeNode(NonTerminal term, SourceSpan span) : this() { Term = term; Span = span; }
public static BnfExpression MakeStarRule(NonTerminal listNonTerminal, BnfTerm listMember) { return(MakeStarRule(listNonTerminal, null, listMember, TermListOptions.None)); }
public override void Modify(NonTerminal node) { Grammar.MarkTransient(node); }
public Production(NonTerminal lvalue) { LValue = lvalue; }
public override void Modify(NonTerminal node) { node.Flags = TermFlags.None; node.AstConfig.NodeCreator = _nodeCreator; }
public static BnfExpression MakePlusRule(NonTerminal listNonTerminal, BnfTerm listMember) { return(MakePlusRule(listNonTerminal, null, listMember)); }
public static BnfExpression MakeStarRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember) { return MakeStarRule(listNonTerminal, delimiter, listMember, TermListOptions.None); }
internal readonly Construction.LR0ItemList LR0Items = new Construction.LR0ItemList(); //LR0 items based on this production public Production(NonTerminal lvalue) { LValue = lvalue; }//constructor
public BnfExpression MakeStarRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember) { return(MakeListRule(listNonTerminal, delimiter, listMember, TermListOptions.StarList)); }
public BnfExpression MakePlusRule(NonTerminal listNonTerminal, BnfTerm delimiter, BnfTerm listMember) { return(MakeListRule(listNonTerminal, delimiter, listMember)); }
public virtual void Modify(NonTerminal nt) { _modify(nt); }