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 ServerGrammar() : base() { var serverNamevalue = new FreeTextLiteral("serverNameValue", FreeTextOptions.None, " ", ";"); var semicolon = ToTerm(";"); var httpCoreServerName = new NonTerminal("httpCoreServerName"); var httpCoreServerNameItems = new NonTerminal("httpCoreServerNameItems"); httpCoreServerName.Rule = "server_name" + httpCoreServerNameItems + semicolon; httpCoreServerNameItems.Rule = MakePlusRule(httpCoreServerNameItems, serverNamevalue); this.Root = httpCoreServerName; }
public T4Grammar() : base(false) { _beginSegment = ToTerm("<#", "beginSegment"); _beginSegment.SkipsWhitespaceAfter = false; _endSegment = ToTerm("#>", "endSegment"); _endSegment.SkipsWhitespaceAfter = false; var directive = InitDirective(BeginSegment, EndSegment); var embeddedCs = InitEmbeddedCs(BeginSegment, EndSegment); var embeddedClassMember = InitEmbeddedClassMember(BeginSegment, EndSegment); var embeddedExpr = InitEmbeddedExpr(BeginSegment, EndSegment); var staticText = new FreeTextLiteral("staticText", FreeTextOptions.AllowEof, BeginSegment.Text); var segment = new NonTerminal("segment") { Rule = staticText | embeddedCs | embeddedExpr | embeddedClassMember | directive }; var content = new NonTerminal("content"); content.Rule = MakeStarRule(content, segment); var root = new NonTerminal("root") {Rule = content}; Root = root; }
public void TestFreeTextLiteral_Escapes() { Parser parser; Token token; //Escapes test var term = new FreeTextLiteral("FreeText", ",", ")"); term.Escapes.Add(@"\\", @"\"); term.Escapes.Add(@"\,", @","); term.Escapes.Add(@"\)", @")"); parser = this.CreateParser(term); token = GetFirst(parser.Parse(@"abc\\de\,\)fg,")); Assert.True(token != null, "Failed to produce a token on valid string."); Assert.True(term == token.Terminal, "Failed to scan a string - invalid Terminal in the returned token."); Assert.True(token.Value.ToString() == @"abc\de,)fg", "Failed to scan a string"); term = new FreeTextLiteral("FreeText", FreeTextOptions.AllowEof, ";"); parser = this.CreateParser(term); token = GetFirst(parser.Parse(@"abcdefg")); Assert.True(token != null, "Failed to produce a token for free text ending at EOF."); Assert.True(term == token.Terminal, "Failed to scan a free text ending at EOF - invalid Terminal in the returned token."); Assert.True(token.Value.ToString() == @"abcdefg", "Failed to scan a free text ending at EOF"); //The following test method and a fix are contributed by ashmind codeplex user //VAR //MESSAGE:STRING80; //(*_ORError Message*) //END_VAR term = new FreeTextLiteral("varContent", "END_VAR"); term.Firsts.Add("VAR"); parser = this.CreateParser(term); token = GetFirst(parser.Parse("VAR\r\nMESSAGE:STRING80;\r\n(*_ORError Message*)\r\nEND_VAR")); Assert.True(token != null, "Failed to produce a token on valid string."); Assert.True(term == token.Terminal, "Failed to scan a string - invalid Terminal in the returned token."); Assert.True(token.ValueString == "\r\nMESSAGE:STRING80;\r\n(*_ORError Message*)\r\n", "Failed to scan a string"); term = new FreeTextLiteral("freeText", FreeTextOptions.AllowEof); parser = this.CreateParser(term); token = GetFirst(parser.Parse(" ")); Assert.True(token != null, "Failed to produce a token on valid string."); Assert.True(term == token.Terminal, "Failed to scan a string - invalid Terminal in the returned token."); Assert.True(token.ValueString == " ", "Failed to scan a string"); }
public void TestFreeTextLiteral() { var term = new FreeTextLiteral("FreeText", ",", ")"); term.Escapes.Add(@"\\", @"\"); term.Escapes.Add(@"\,", @","); term.Escapes.Add(@"\)", @")"); SetTerminal(term); TryMatch(@"abc\\de\,\)fg,"); Assert.IsNotNull(_token, "Failed to produce a token on valid string."); Assert.AreEqual(term, _token.Terminal, "Failed to scan a string - invalid Terminal in the returned token."); Assert.AreEqual(_token.Value.ToString(), @"abc\de,)fg", "Failed to scan a string"); term = new FreeTextLiteral("FreeText", FreeTextOptions.AllowEof, ";"); SetTerminal(term); TryMatch(@"abcdefg"); Assert.IsNotNull(_token, "Failed to produce a token for free text ending at EOF."); Assert.AreEqual(term, _token.Terminal, "Failed to scan a free text ending at EOF - invalid Terminal in the returned token."); Assert.AreEqual(_token.Value.ToString(), @"abcdefg", "Failed to scan a free text ending at EOF"); }
public STLGrammar() : base(false) { #region Letters and Digits /* letter A | B | .. | Z | a | b | .. |z digit 0 | 1 | .. | 9 bit digit 0|1| .. |7 binary digit 0 | 1 | _ hex digit digit | A | .. | F | a | .. | f | _ character letter | ASCII 128 | .. | ASCII 255 | _ first identifier character character | space other identifier character character | digit | space Local Variables (Local ToTerms) [ # ] identifier */ var semi = ToTerm(";", "semi"); var semi_opt = new NonTerminal("semi?", Empty | semi); var dot = ToTerm(".", "dot"); var comma = ToTerm(",", "comma"); var comma_opt = new NonTerminal("comma_opt", Empty | comma); var equal = ToTerm("=", "equal"); var digits = new NumberLiteral("decimal", NumberOptions.IntOnly | NumberOptions.DisableQuickParse); var binarys = new NumberLiteral("binary", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Binary | NumberOptions.AllowUnderscore); var octals = new NumberLiteral("octal", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Octal); var hexs = new NumberLiteral("hex", NumberOptions.IntOnly | NumberOptions.DisableQuickParse | NumberOptions.Hex | NumberOptions.AllowUnderscore); var identifier = TerminalFactory.CreateCSharpIdentifier("identifier"); var global_variable = new NonTerminal("global_variable", typeof(Variable)); var local_variable = new NonTerminal("local_variable", typeof(Variable)); KeyTerm colon = ToTerm(":", "colon"); binarys.AddPrefix("2#", NumberOptions.Binary); hexs.AddPrefix("16#", NumberOptions.Hex); global_variable.SetFlag(TermFlags.IsConstant); local_variable.SetFlag(TermFlags.IsConstant); global_variable.Rule = identifier; local_variable.Rule = "#" + identifier; #endregion #region Program Comments /* comment characters printable character CR comment // { comment characters } CR */ var comment = new CommentTerminal("comment", "//", "\r", "\n"); var comment_opt = new NonTerminal("comment?"); var line_comment = new NonTerminal("line_comment"); var multi_line_comment = new NonTerminal("multi_line_comment"); var empty_line = new NonTerminal("empty_line"); var empty_lines = new NonTerminal("empty_line+"); var empty_lines_opt = new NonTerminal("empty_line*"); multi_line_comment.SetFlag(TermFlags.IsList); empty_lines.SetFlag(TermFlags.IsList); empty_lines_opt.SetFlag(TermFlags.IsListContainer); comment_opt.Rule = comment | Empty; line_comment.Rule = comment + NewLine; multi_line_comment.Rule = multi_line_comment + line_comment | line_comment; empty_line.Rule = NewLine | line_comment; empty_lines.Rule = empty_lines + empty_line | empty_line; empty_lines_opt.Rule = empty_lines | Empty; #endregion #region Instruction mnemonic terminal // Bit logic var bit_logic_mnemonic = new NonTerminal("bit_logic_mnemonic"); var clock_mnemonic = new NonTerminal("clock_mnemonic"); var communication_mnemonic = new NonTerminal("communication_mnemonic"); var compare_mnemonic = new NonTerminal("compare_mnemonic"); var convert_mnemonic = new NonTerminal("convert_mnemonic"); var counter_mnemonic = new NonTerminal("counter_mnemonic"); var floatpoint_math_mnemonic = new NonTerminal("floatpoint_math_mnemonic"); var integer_math_mnemonic = new NonTerminal("integer_math_mnemonic"); var logical_mnemonic = new NonTerminal("logical_mnemonic"); var move_mnemonic = new NonTerminal("move_mnemonic"); var program_control_mnemonic = new NonTerminal("program_control_mnemonic"); var shift_rotate_mnemonic = new NonTerminal("shift_rotate_mnemonic"); var string_mnemonic = new NonTerminal("string_mnemonic"); var table_mnemonic = new NonTerminal("table_mnemonic"); var timer_mnemonic = new NonTerminal("timer_mnemonic"); var subroutine_mnemonic = new NonTerminal("subroutine_mnemonic"); bit_logic_mnemonic.Rule = ToTerm("LD") | "A" | "O" | "LDN" | "AN" | "ON" | "LDI" | "AI" | "OI" | "LDNI" | "ANI" | "ONI" | "NOT" | "EU" | "ED" | "ALD" | "OLD" | "LPS" | "LDS" | "LRD" | "LPP" | "=" | "=I" | "S" | "SI" | "R" | "RI" | "AENO" | "NOP"; clock_mnemonic.Rule = ToTerm("TODR") | "TODW" | "TODRX" | "TODWX"; communication_mnemonic.Rule = ToTerm("XMT") | "RCV" | "NETR" | "NETW" | "GPA" | "SPA"; compare_mnemonic.Rule = ToTerm("LDB=") | "AB=" | "OB=" | "LDB<>" | "AB<>" | "OB<>" | "LDB>=" | "AB>=" | "OB>=" | "LDB<=" | "AB<=" | "OB<=" | "LDB>" | "AB>" | "OB>" | "LDB<" | "AB<" | "OB<" | "LDW=" | "AW=" | "OW=" | "LDW<>" | "AW<>" | "OW<>" | "LDW>=" | "AW>=" | "OW>=" | "LDW<=" | "AW<=" | "OW<=" | "LDW>" | "AW>" | "OW>" | "LDW<" | "AW<" | "OW<" | "LDD=" | "AD=" | "OD=" | "LDD<>" | "AD<>" | "OD<>" | "LDD>=" | "AD>=" | "OD>=" | "LDD<=" | "AD<=" | "OD<=" | "LDD>" | "AD>" | "OD>" | "LDD<" | "AD<" | "OD<" | "LDR=" | "AR=" | "OR=" | "LDR<>" | "AR<>" | "OR<>" | "LDR>=" | "AR>=" | "OR>=" | "LDR<=" | "AR<=" | "OR<=" | "LDR>" | "AR>" | "OR>" | "LDR<" | "AR<" | "OR<" | "LDS=" | "AS=" | "OS=" | "LDS<>" | "AS<>" | "OS<>"; convert_mnemonic.Rule = ToTerm("BTI") | "ITB" | "ITD" | "ITS" | "DTI" | "DTR" | "DTS" | "ROUND" | "TRUNC" | "RTS" | "BCDI" | "IBCD" | "ITA" | "DTA" | "RTA" | "ATH" | "HTA" | "STI" | "STD" | "STR" | "DECO" | "Encoder" | "SEG"; counter_mnemonic.Rule = ToTerm("CTU") | "CTD" | "CTUD" | "HDEF" | "HSC" | "PLS"; floatpoint_math_mnemonic.Rule = ToTerm("+R") | "-R" | "*R" | "/R" | "SQRT" | "SIN" | "COS" | "TAN" | "LN" | "EXP" | "PID"; integer_math_mnemonic.Rule = ToTerm("+I") | "-I" | "*I" | "/I" | "+D" | "-D" | "*D" | "/D" | "MUL" | "DIV" | "INCB" | "INCW" | "INCD" | "DECB" | "DECW" | "DECD"; logical_mnemonic.Rule = ToTerm("INVB") | "INVW" | "INVD" | "ANDB" | "ANDW" | "ANDD" | "ORB" | "ORW" | "ORD" | "XORB" | "XORW" | "XORD"; move_mnemonic.Rule = ToTerm("MOVB") | "MOVW" | "MOVD" | "MOVR" | "BMB" | "BMW" | "BMD" | "SWAP" | "BIR" | "BIW"; program_control_mnemonic.Rule = ToTerm("FOR") | "NEXT" | "JMP" | "LBL" | "LSCR" | "SCRT" | "SCRE" | "CSCRE" | "END" | "STOP" | "WDR" | "DLED"; shift_rotate_mnemonic.Rule = ToTerm("SLB") | "SLW" | "SLD" | "SRB" | "SRW" | "SRD" | "RLB" | "RLW" | "RLD" | "RRB" | "RRW" | "RRD" | "SHRB"; string_mnemonic.Rule = ToTerm("SLEN") | "SCPY" | "SSCPY" | "SCAT" | "SFND" | "CFND"; table_mnemonic.Rule = ToTerm("FILL") | "ATT" | "FND=" | "FND<>" | "FND<" | "FND>" | "LIFO" | "FIFO"; timer_mnemonic.Rule = ToTerm("TON") | "TONR" | "TOF" | "BITIM" | "CITIM"; subroutine_mnemonic.Rule = ToTerm("CALL") | "ENI" | "ENS"; #endregion #region Constants /* Boolean constant TRUE | FALSE | ON | OFF Note: Case insensitive constant descriptor B# | BYTE# | W# | WORD# | DW# | DWORD# Note: Case insensitive unsigned integer [constant descriptor]digit {digit} number digit {digit} signed number [ + | - ] number signed integer [constant descriptor]signed number binary integer [constant descriptor]2# binary digit { binary digit } hex integer [constant descriptor]16# hex digit { hex digit } exponent ( E | e ) signed number real constant signed number . {exponent} real constant number {exponent} real constant signed number . number {exponent} printable character ASCII 32 | .. | ASCII 255 excluding DEL and ? two character hex hex digit hex digit character representation printable character | $$ | $ | $L | $l | $N | $n | $P | $p | $R | $r | $T | $t | $?| $" $two character hex Note: The leading $ sign is a control character (Also known as an escape code) Escape Code Interpretation $$ Single dollar sign $? Single quotation mark character $" Double quotation mark character $L or $l A line feed character $N or $n A new line character $P or $p Form feed, new page $R or $r Carriage return character $T or $t Tab character ASCII character constant [constant descriptor]'character representation' ASCII string constant "character representation" constant Boolean constant | binary digit | unsigned integer | signed integer | binary integer | hex integer | real constant | ASCII constant */ var real = new NumberLiteral("Real", NumberOptions.AllowSign); var bool_constant = new NonTerminal("bool_constant", typeof(BoolConstrant)); var constant_descriptor = new NonTerminal("constant_descriptor", typeof(Descriptor)); var unsigned_integer = new NonTerminal("unsigned_integer", typeof(NumberConstrant)); var signed_number = new NumberLiteral("decimal", NumberOptions.IntOnly|NumberOptions.AllowSign); var signed_integer = new NonTerminal("signed_integer", typeof(NumberConstrant)); var binary_integer = new NonTerminal("binary_integer", typeof(NumberConstrant)); var hex_integer = new NonTerminal("hex_integer", typeof(NumberConstrant)); var real_constant = new NonTerminal("real_constant", typeof(NumberConstrant)); var character_representation = new StringLiteral("character_representation", "'"); var ascii_constant = new NonTerminal("ascii_constant"); var string_constant = new StringLiteral("string_constant", "\""); var constant = new NonTerminal("Constant"); bool_constant.Rule = ToTerm("TRUE") | "FALSE" | "ON" | "OFF"; constant_descriptor.Rule = (ToTerm("B") | "BYTE" | "W" | "WORD" | "D" | "DWORD") + "#" | Empty; unsigned_integer.Rule = constant_descriptor + digits; signed_integer.Rule = constant_descriptor + signed_number; binary_integer.Rule = constant_descriptor + binarys; hex_integer.Rule = constant_descriptor + hexs; real_constant.Rule = real; ascii_constant.Rule = constant_descriptor + character_representation; constant.Rule = bool_constant | unsigned_integer | signed_integer | binary_integer | hex_integer | real_constant | ascii_constant | string_constant; #endregion #region Addressing /*Addressing discrete input I | E Note: Case insensitive discrete output Q | A Note: Case insensitive analog input AI | AE Note: Case insensitive analog output AQ | AA Note: Case insensitive db memory DB Note: Case insensitive variable memory V Note: Case insensitive flag memory M Note: Case insensitive system memory SM Note: Case insensitive Stage memory S Note: Case insensitive accumulator AC Note: Case insensitive Timer T Note: Case insensitive counter C | Z Note: Case insensitive high speed counter HC | HZ Note: Case insensitive data block DB Note: Case insensitive local memory L Note: Case insensitive bit point unsigned number . 0 | 1 | ?| 7 size prefix B | W | D Note: Case insensitive Direct prefix discrete input | discrete output | variable memory | flag memory | system memory | stage memory peripheral prefix analog input | analog output timer counter prefix timer | counter bit address direct prefix [X] bit point byte word dword address direct prefix size prefix unsigned number peripheral address peripheral prefix [W] unsigned number timer counter address timer counter prefix ((X unsigned number) | unsigned number) high speed counter address high speed counter unsigned number accumulator address accumulator [size prefix] unsigned number db number DB unsigned number db address [db number .] data block ([X] bit point) | (size prefix unsigned number) Direct address bit address | byte word dword address | peripheral address |timer counter address | high speed counter address | accumulator address |db address indirect address * ((accumulator [ D| d ]) | (variable memory D | d ) | (local memory D | d) | ([db number .] data block D | d)) unsigned number address of & (variable memory | discrete input | discrete output | timer | counter | flag memory | system memory ([db number.] data block) size prefix unsigned number */ var address_term = new AddressTerm("address_term"); var address = new NonTerminal("address", typeof(Address)); address.Rule = address_term; #endregion #region Local Variable Declaration /* ob declaration [var declaration] int declaration [var declaration] sbr declaration [io var declaration] ob declarations io var declaration [var input declaration] [var in out declaration] [var output declaration] var input declaration VAR_INPUT CR decl_list END_VAR CR var output declaration VAR_OUTPUT CR decl_list END_VAR CR var in out declaration VAR_IN_OUT CR decl_list END_VAR CR var declaration VAR CR decl_list END_VAR CR decl list {identifier : complex type }; {comment} Type Base type | user type | string type complex type Base type | array type | struct type | user type | string type init value constant | integer ( init value ) | init value , init value base type BOOL | BYTE | WORD | DWORD | CHAR | INT | DINT | REAL | */ var base_type = new NonTerminal("base_type"); var init_value = new NonTerminal("init_value"); var complex_type = new NonTerminal("complex_type"); var type = new NonTerminal("type"); var decl = new NonTerminal("decl", typeof(Declaration)); var decl_line = new NonTerminal("decl_line"); var decl_list = new NonTerminal("decl+"); var decl_list_opt = new NonTerminal("decl*"); var var_input_decl = new NonTerminal("var_input_decl", typeof(VarDecl)); var var_output_decl = new NonTerminal("var_output_decl", typeof(VarDecl)); var var_in_out_decl = new NonTerminal("var_in_out_decl", typeof(VarDecl)); var var_decl = new NonTerminal("var_decl", typeof(VarDecl)); var var_input_decl_opt = new NonTerminal("var_input_decl?"); var var_output_decl_opt = new NonTerminal("var_output_decl?"); var var_in_out_decl_opt = new NonTerminal("var_in_out_decl?"); var var_decl_opt = new NonTerminal("var_decl?"); var var_decl_suffix = new NonTerminal("var_decl_suffix"); var io_var_decl = new NonTerminal("io_var_decl"); decl_list.SetFlag(TermFlags.IsList); decl_list_opt.SetFlag(TermFlags.IsListContainer); MarkTransient(decl_line, complex_type, base_type, var_input_decl_opt, var_output_decl_opt, var_in_out_decl_opt); base_type.Rule = ToTerm("BOOL") | "BYTE" | "WORD" | "DWORD" | "CHAR" | "INT" | "DINT" | "REAL"; init_value.Rule = init_value + comma + constant | constant | ToTerm("integer") + "(" + constant + ")"; complex_type.Rule = base_type; type.Rule = base_type; decl.Rule = identifier + ":" + complex_type + ";" + comment_opt + NewLine; decl_line.Rule = decl | empty_line; decl_list.Rule = decl_list + decl_line | decl_line; decl_list_opt.Rule = decl_list | Empty; var_decl_suffix.Rule = NewLine + decl_list_opt + "END_VAR" + NewLine; var_input_decl.Rule = "VAR_INPUT" + var_decl_suffix; var_output_decl.Rule = "VAR_OUTPUT" + var_decl_suffix; var_in_out_decl.Rule = "VAR_IN_OUT" + var_decl_suffix; var_decl.Rule = "VAR" + var_decl_suffix; var_input_decl_opt.Rule = var_input_decl | Empty; var_output_decl_opt.Rule = var_output_decl | Empty; var_in_out_decl_opt.Rule = var_in_out_decl | Empty; var_decl_opt.Rule = var_decl | Empty; io_var_decl.Rule = var_input_decl_opt + var_output_decl_opt + var_in_out_decl_opt; #endregion #region Program Structure /*Note: Keywords are case insensitive unless otherwise noted. Block title { white space } (TITLE = comment characters CR | comment) Block comment {comment} network title { white space } (TITLE = comment characters CR | comment) network comment {comment} line comment {comment} code comment {comment} network number { space | unsigned number } operand { white space } global variable | local variable | constant | direct address | indirect address | address of instruction mnemonic (letter | digit | _ ) { letter | digit | _ } instruction instruction mnemonic [(white space) { white space } operand {(,| white space) { white space } operand}] ; code comment statement list {instruction | line comment} network NETWORK network number (CR | [network title] [network comment]) statement list ob number OB unsigned number organization block ORGANIZATION_BLOCK (ob number) (CR | [block title] [block comment])ob declarations BEGIN [network] END_ORGANIZATION_BLOCK CR sbr number SBR unsigned number subroutine block SUBROUTINE_BLOCK (sbr number) (CR [block title] [block comment])sbr declarations BEGIN [network] END_SUBROUTINE_BLOCK CR int number INT unsigned_number interrupt block INTERRUPT_BLOCK (int number) (CR [block title] [block comment]) int declarations BEGIN [network] END_INTERRUPT_BLOCK CR */ var title_content = new FreeTextLiteral("Title", "\r", "\n"); var title = new NonTerminal("title"); var title_opt = new NonTerminal("title?"); var network_number = new NonTerminal("network_number"); var mnemonic = new NonTerminal("mnemonic"); var operand = new NonTerminal("operand"); var operand_list = new NonTerminal("operand+"); var operand_list_opt = new NonTerminal("operand*"); var instruction = new NonTerminal("instruction", typeof(Instruction)); var statement = new NonTerminal("statement"); var statement_list = new NonTerminal("statement_list"); var statement_list_opt = new NonTerminal("statement*"); var network = new NonTerminal("network", typeof(Network)); var network_list = new NonTerminal("network+"); var network_list_opt = new NonTerminal("network*", typeof(NodeList)); var ob_number = new NonTerminal("ob_number"); var block_1 = new NonTerminal("block_1"); var block_2 = new NonTerminal("block_2"); var organization_block = new NonTerminal("organization_block", typeof(POU)); var sbr_number = new NonTerminal("sbr_number"); var subroutine_block = new NonTerminal("subroutine_block", typeof(POU)); var int_number = new NonTerminal("int_number"); var interrupt_block = new NonTerminal("interrupt_block", typeof(POU)); var subroutine_block_list = new NonTerminal("subroutine_block+"); var interrupt_block_list = new NonTerminal("interrupt_block+"); var subroutine_block_list_opt = new NonTerminal("subroutine_block*", typeof(NodeList)); var interrupt_block_list_opt = new NonTerminal("interrupt_block*", typeof(NodeList)); var program = new NonTerminal("program", typeof(Block)); operand_list.SetFlag(TermFlags.IsList); statement_list.SetFlag(TermFlags.IsList); network_list.SetFlag(TermFlags.IsList); subroutine_block_list.SetFlag(TermFlags.IsList); interrupt_block_list.SetFlag(TermFlags.IsList); operand_list_opt.SetFlag(TermFlags.IsListContainer); statement_list_opt.SetFlag(TermFlags.IsListContainer); network_list_opt.SetFlag(TermFlags.IsListContainer); subroutine_block_list_opt.SetFlag(TermFlags.IsListContainer); interrupt_block_list_opt.SetFlag(TermFlags.IsListContainer); MarkTransient(constant, mnemonic, operand, statement); mnemonic.Rule = bit_logic_mnemonic | clock_mnemonic | communication_mnemonic | compare_mnemonic | convert_mnemonic | counter_mnemonic | floatpoint_math_mnemonic | integer_math_mnemonic | logical_mnemonic | move_mnemonic | program_control_mnemonic | shift_rotate_mnemonic | string_mnemonic | table_mnemonic | timer_mnemonic | subroutine_mnemonic; title.Rule = ToTerm("TITLE") + "=" + title_content + NewLine; title_opt.Rule = title | Empty; operand.Rule = global_variable | local_variable | constant | address; operand_list.Rule = operand_list + comma + operand | operand; operand_list_opt.Rule = operand_list | Empty; instruction.Rule = mnemonic + operand_list_opt + semi_opt + comment_opt + NewLine; statement.Rule = instruction | line_comment | NewLine; statement_list.Rule = statement_list + statement | statement; statement_list_opt.Rule = statement_list | Empty; network_number.Rule = digits | Empty; network.Rule = "NETWORK" + network_number + comment_opt + NewLine + title_opt + statement_list_opt; network_list.Rule = network_list + network | network; network_list_opt.Rule = network_list | Empty; block_1.Rule = identifier + ":" + identifier + NewLine + title_opt + empty_lines_opt; block_2.Rule = "BEGIN" + NewLine + network_list_opt; organization_block.Rule = "ORGANIZATION_BLOCK" + block_1 + var_decl_opt + block_2 + "END_ORGANIZATION_BLOCK" + NewLine; subroutine_block.Rule = "SUBROUTINE_BLOCK" + block_1 + io_var_decl + var_decl_opt + block_2 + "END_SUBROUTINE_BLOCK" + NewLine; interrupt_block.Rule = "INTERRUPT_BLOCK" + block_1 + var_decl_opt + block_2 + "END_INTERRUPT_BLOCK" + NewLine; subroutine_block_list.Rule = subroutine_block_list + subroutine_block | subroutine_block; interrupt_block_list.Rule = interrupt_block_list + interrupt_block | interrupt_block; subroutine_block_list_opt.Rule = subroutine_block_list | Empty; interrupt_block_list_opt.Rule = interrupt_block_list | Empty; program.Rule = organization_block + subroutine_block_list_opt + interrupt_block_list_opt; #endregion //Set grammar root this.Root = program; this.WhitespaceChars = " \t\v"; MarkPunctuation("(", ")", ":", ";", ".", ","); MarkPunctuation(semi_opt, comma_opt, comment, comment_opt, line_comment, empty_line, empty_lines, empty_lines_opt); this.LanguageFlags = LanguageFlags.NewLineBeforeEOF | LanguageFlags.CreateAst; }
private NonTerminal InitEmbeddedExpr(KeyTerm beginSegment, KeyTerm endSegment) { _embeddedExpr = new NonTerminal("embeddedExpr"); var embeddedExprText = new FreeTextLiteral("embeddedCsText", endSegment.Text); var embeddedExprPrefix = ToTerm("="); _embeddedExpr.Rule = beginSegment + embeddedExprPrefix + embeddedExprText + endSegment; return EmbeddedExpr; }
private NonTerminal InitEmbeddedCs(KeyTerm beginSegment, KeyTerm endSegment) { var regexNonDirective = new RegexBasedTerminal("NonDirectivePrefix", "(?![+=@])") { ErrorAlias = "<#@ can only be declared before any text or embedded code", SkipsWhitespaceAfter = false }; _embeddedCs = new NonTerminal("embeddedCs"); var embeddedCsText = new FreeTextLiteral("embeddedCsText", endSegment.Text); var stringLit = new StringLiteral("embeddedCsText"); stringLit.AddStartEnd(beginSegment.Text, endSegment.Text, StringOptions.AllowsLineBreak); _embeddedCs.Rule = beginSegment + regexNonDirective + embeddedCsText + endSegment; return EmbeddedCs; }
private NonTerminal InitEmbeddedClassMember(KeyTerm beginSegment, KeyTerm endSegment) { _embeddedClassMemberText = new FreeTextLiteral("embeddedClassMemberText", endSegment.Text); _embeddedClassMemberPrefix = ToTerm("+"); _embeddedClassMember = new NonTerminal("embeddedClassMember") { Rule = beginSegment + EmbeddedClassMemberPrefix + EmbeddedClassMemberText + endSegment }; return EmbeddedClassMember; }
private NonTerminal InitDirective(KeyTerm beginSegment, KeyTerm endSegment) { _directiveName = new IdentifierTerminal("directiveName"); _expandedIncludeText = new FreeTextLiteral("expandedIncludeText"); _attributeConnector = ToTerm("="); _attributeName = new IdentifierTerminal("attributeName") { SkipsWhitespaceAfter = false }; _attributeValue = new StringLiteral("attributeValue", "\""); _attribute = new NonTerminal("attribute") { Rule = _attributeName + _attributeConnector + _attributeValue }; _attributeList = new NonTerminal("attributeList"); _attributeList.Rule = MakePlusRule(_attributeList, _attribute); var directivePrefix = ToTerm("@"); _directive = new NonTerminal("directive") { Rule = beginSegment + directivePrefix + DirectiveName + AttributeList + endSegment }; return Directive; }