internal UOSLBase(LanguageOption options = LanguageOption.Native) { if (CanCache) { grammars[options] = this; } Options = options; this.DefaultNodeType = typeof(ScopedNode); #region Declare Terminals Here NonGrammarTerminals.Add(blockComment); NonGrammarTerminals.Add(lineComment); Identifier.AstNodeType = typeof(UoFieldExpressionNode); _L = ToTerm("L"); MarkReservedWords("L"); #endregion #region Functions TypedFunction.Rule = Function_void | Function_int | Function_string | Function_ustring | Function_loc | Function_obj | Function_list; Function_void.Rule = _void + _functionname_void; Function_int.Rule = _int + _functionname_int; Function_string.Rule = _string + _functionname_str; Function_ustring.Rule = _ustring + _functionname_ustr; Function_loc.Rule = _loc + _functionname_loc; Function_obj.Rule = _obj + _functionname_obj; Function_list.Rule = _list + _functionname_list; #endregion #region Externals _any.SetFlag(TermFlags.IsKeyword); if (!Keywords.ContainsKey(_any.Text)) { Keywords[_any.Text] = _any; } ExternalParam.Rule = (_int | _string | _ustring | _loc | _obj | _list | _any | _void) + (ToTerm("&").Q()) + (Identifier.Q()); ExternalParams.Rule = MakeStarRule(ExternalParams, _comma, ExternalParam); Function_any.Rule = _any + _functionname_void; // only valid for Core Commands ExternalDeclaration.Rule = ToTerm("external") + (Function_any | TypedFunction) + _openparen_punc + ExternalParams + _closeparen_punc + _semicolon; #endregion BracePair(_openbracket, _closebracket); BracePair(_openparen_op, _closeparen_op); BracePair(_openparen_punc, _closeparen_punc); BracePair(_openbrace, _closebrace); BracePair(_openchevron, _closechevron); this.Delimiters = "{}[](),:;+-*/%&|^!~<>="; this.MarkPunctuation(_semicolon, _comma, _openparen_punc, _closeparen_punc, _openbrace, _closebrace, _openbracket, _closebracket, _colon); RegisterOperators(-1, _assignment); RegisterOperators(1, _logicalnegation, _increment, _decrement); RegisterOperators(0, _plus, _minus, _multiply, _divide, _remainder, _isequal, _isnotequal, _lowerthen, _greaterthen, _lowerthenorequal, _greaterthenorequal, _logicaland, _logicalor, _bitwiseexclusiveor); this.LanguageFlags = LanguageFlags.CreateAst; }
public RubyGrammar() { #region Terminals //String Literals with single and double-quote start/end symbols StringLiteral STRING = new StringLiteral("STRING", TermOptions.SpecialIgnoreCase); STRING.AddStartEnd("\"", ScanFlags.None); STRING.AddStartEnd("'", ScanFlags.None); Terminal HereDoc = new Terminal("HereDoc"); //-- implement me! Terminal RegExLiteral = new Terminal("RegExLiteral"); //-- implement me! IdentifierTerminal IDENTIFIER = new IdentifierTerminal("identifier", "_!?", "_$@"); // name extraChars extraFirstChars IDENTIFIER.DisplayName = "variable"; //we need to isolate reserved words to avoid ambiguities in grammar IDENTIFIER.AddKeywords("do", "end", "def", "class", "if", "case", "return", "yield", "while", "until"); //and some others... Terminal Number = new NumberLiteral("Number"); Terminal Comment = new CommentTerminal("Comment", "#", "\n"); NonGrammarTerminals.Add(Comment); //add comment explicitly to this list as it is not reachable from Root //some conveniency variables Terminal Pipe = Symbol("|"); Terminal dot = Symbol("."); Terminal comma = Symbol(","); #endregion #region NonTerminals //NT variables names match element names in original grammar NonTerminal PROGRAM = new NonTerminal("PROGRAM"); NonTerminal COMPSTMT = new NonTerminal("COMPSTMT"); NonTerminal STMT = new NonTerminal("STMT"); NonTerminal BLOCK = new NonTerminal("BLOCK"); NonTerminal EXPR = new NonTerminal("EXPR"); //NonTerminal CALL = new NonTerminal("CALL"); NonTerminal COMMAND = new NonTerminal("COMMAND"); NonTerminal FUNCTION = new NonTerminal("FUNCTION"); NonTerminal ARG = EXPR;// new NonTerminal("ARG"); NonTerminal PRIMARY = new NonTerminal("PRIMARY", "operand"); NonTerminal WHEN_ARGS = new NonTerminal("WHEN_ARGS"); NonTerminal THEN = new NonTerminal("THEN"); NonTerminal BLOCK_BEGIN = new NonTerminal("BLOCK_BEGIN"); NonTerminal BLOCK_END = new NonTerminal("BLOCK_END"); NonTerminal BLOCK_VAR = new NonTerminal("BLOCK_VAR"); // NonTerminal MLHS_ITEM = new NonTerminal("MLHS_ITEM"); NonTerminal LHS = new NonTerminal("LHS"); NonTerminal MRHS = new NonTerminal("MRHS"); // NonTerminal MLHS = MRHS; // new NonTerminal("MLHS"); NonTerminal CALL_ARGS = new NonTerminal("CALL_ARGS"); NonTerminal CALL_ARGS_P = new NonTerminal("CALL_ARGS_P"); NonTerminal AMP_ARG = new NonTerminal("AMP_ARG"); NonTerminal STAR_ARG = new NonTerminal("STAR_ARG"); NonTerminal ARGS = new NonTerminal("ARGS"); NonTerminal ARGDECL = new NonTerminal("ARGDECL"); NonTerminal ARGLIST = new NonTerminal("ARGLIST"); // NonTerminal SINGLETON = new NonTerminal("SINGLETON"); NonTerminal ASSOCS = new NonTerminal("ASSOCS"); NonTerminal ASSOC = new NonTerminal("ASSOC"); // NonTerminal VARIABLE = new NonTerminal("VARIABLE"); --merged into IDENTIFIER NonTerminal LITERAL = new NonTerminal("LITERAL", "value"); NonTerminal TERM = new NonTerminal("TERM"); NonTerminal DO = new NonTerminal("DO"); // NonTerminal VARNAME = new NonTerminal("VARNAME"); // note 1 NonTerminal GLOBAL = new NonTerminal("GLOBAL"); NonTerminal RETURN_STMT = new NonTerminal("RETURN_STMT"); NonTerminal YIELD_STMT = new NonTerminal("YIELD_STMT"); NonTerminal DEFINEDQ_STMT = new NonTerminal("DEFINEDQ_STMT"); NonTerminal FUNCTION_STMT = new NonTerminal("FUNCTION_STMT"); NonTerminal IF_STMT = new NonTerminal("IF_STMT"); NonTerminal UNLESS_STMT = new NonTerminal("UNLESS_STMT"); NonTerminal WHILE_STMT = new NonTerminal("WHILE_STMT"); NonTerminal UNTIL_STMT = new NonTerminal("UNTIL_STMT"); NonTerminal CASE_STMT = new NonTerminal("CASE_STMT"); NonTerminal FOR_STMT = new NonTerminal("FOR_STMT"); NonTerminal BLOCK_STMT = new NonTerminal("BLOCK_STMT"); NonTerminal CLASS_DEF = new NonTerminal("CLASS_DEF"); NonTerminal BASE_REF = new NonTerminal("BASE_REF"); NonTerminal MODULE = new NonTerminal("MODULE_STMT"); NonTerminal DEFFUNC_STMT = new NonTerminal("DEFFUNC_STMT"); NonTerminal DEFSING_STMT = new NonTerminal("DEFSING_STMT"); NonTerminal SINGLETON = new NonTerminal("SINGLETON"); NonTerminal END = new NonTerminal("end"); NonTerminal SYMBOL = new NonTerminal("SYMBOL"); //Not in original grammar NonTerminal FNAME = new NonTerminal("FNAME"); BLOCK_BEGIN.Rule = Symbol("do") | "{"; BLOCK_END.Rule = Symbol("end") | "}"; NonTerminal OPERATION = new NonTerminal("OPERATION"); // Terminal VARNAME = IDENTIFIER; NonTerminal AUG_ASGN = new NonTerminal("AUG_ASGN"); NonTerminal BINOP = new NonTerminal("BINOP", "operator"); NonTerminal UNOP = new NonTerminal("UNOP"); NonTerminal DELIM = new NonTerminal("DELIM"); #endregion #region Rules //Set grammar root this.Root = PROGRAM; //PROGRAM : COMPSTMT PROGRAM.Rule = COMPSTMT; // +Grammar.Eof; //COMPSTMT : STMT (TERM EXPR)* [TERM] COMPSTMT.Rule = NewLine.Q() + STMT.Plus(TERM) + TERM.Q(); /* STMT : CALL do [`|' [BLOCK_VAR] `|'] COMPSTMT end | undef FNAME | alias FNAME FNAME | STMT if EXPR | STMT while EXPR | STMT unless EXPR | STMT until EXPR | `BEGIN' `{' COMPSTMT `}' | `"end"' `{' COMPSTMT `}' | LHS `=' COMMAND [do [`|' [BLOCK_VAR] `|'] COMPSTMT end] | EXPR */ STMT.Rule = FUNCTION | COMMAND + BLOCK.Q() | "undef" + FNAME | "alias" + FNAME + FNAME | STMT + (Symbol("if")|"while"|"unless"|"until") + EXPR | Symbol("BEGIN") + "{" + COMPSTMT + "}" // | Symbol("end") + BLOCK_BEGIN + COMPSTMT + BLOCK_END // don't quite get it // | LHS + "=" + COMMAND + BLOCK.Q() | LHS + "=" + EXPR //changed this | LHS + AUG_ASGN + EXPR | EXPR; BLOCK.Rule = "do" + WithQ(Pipe + BLOCK_VAR.Q() + Pipe) + COMPSTMT + "end"; /* EXPR : MLHS `=' MRHS | return CALL_ARGS | yield CALL_ARGS | EXPR and EXPR | EXPR or EXPR | not EXPR | COMMAND | `!' COMMAND | ARG */ //this one is completely changed, for better or worse... EXPR.Rule = // MRHS + "=" + EXPR | //changed to EXPR // LHS + "=" + EXPR //changed this // | LHS + AUG_ASGN + EXPR EXPR + BINOP + EXPR | UNOP + EXPR //| "(" + EXPR + ")" | EXPR + "?" + EXPR + ":" + EXPR //added this to cover "?" operator | "defined?" + ARG | PRIMARY ; ARG = EXPR; // CALL : FUNCTION | COMMAND // CALL.Expression = FUNCTION | COMMAND; //expression embedded directly into STMT /* COMMAND : OPERATION CALL_ARGS | PRIMARY `.' OPERATION CALL_ARGS | PRIMARY `::' OPERATION CALL_ARGS | super CALL_ARGS */ COMMAND.Rule = OPERATION + CALL_ARGS | PRIMARY + DELIM + OPERATION + CALL_ARGS | "super" + CALL_ARGS; OPERATION.Rule = IDENTIFIER; DELIM.Rule = dot | "::"; /* FUNCTION : OPERATION [`(' [CALL_ARGS] `)'] | PRIMARY `.' OPERATION `(' [CALL_ARGS] `)' | PRIMARY `::' OPERATION `(' [CALL_ARGS] `)' | PRIMARY `.' OPERATION | PRIMARY `::' OPERATION | super `(' [CALL_ARGS] `)' | super */ FUNCTION.Rule = OPERATION + CALL_ARGS_P | PRIMARY + DELIM + OPERATION + CALL_ARGS_P.Q() | "super" + CALL_ARGS_P; CALL_ARGS_P.Rule = "(" + CALL_ARGS.Q() + ")"; /* ARG : LHS `=' ARG | LHS OP_ASGN ARG | ARG `..' ARG | ARG `...' ARG | ARG `+' ARG | ARG `-' ARG | ARG `*' ARG | ARG `/' ARG | ARG `%' ARG | ARG `**' ARG | `+' ARG | `-' ARG | ARG `|' ARG | ARG `^' ARG | ARG `&' ARG | ARG `<=>' ARG | ARG `>' ARG | ARG `>=' ARG | ARG `<' ARG | ARG `<=' ARG | ARG `==' ARG | ARG `===' ARG | ARG `!=' ARG | ARG `=~' ARG | ARG `!~' ARG | `!' ARG | `~' ARG | ARG `<<' ARG | ARG `>>' ARG | ARG `&&' ARG | ARG `||' ARG | defined? ARG | PRIMARY */ /* ARG.Expression = LHS + "=" + EXPR //changed this | LHS + AUG_ASGN + EXPR | ARG + BINOP + ARG //moved to EXPR | UNOP + ARG | "defined?" + ARG | PRIMARY ; */ AUG_ASGN.Rule = Symbol("+=") | "-=" | "*=" | "/=" | "%=" | "**=" | "&=" | "|=" | "^=" | "<<=" | ">>=" | "&&=" | "||="; BINOP.Rule = Symbol("..") | "..." | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "<=>" | ">" | ">=" | "<" | "<=" | "==" | "===" | "!=" | "=~" | "!~" | "<<" | ">>" | "&&" | "||" | "and" | "or"; //added these two here UNOP.Rule = Symbol("+") | "-" | "!" | "~"; /*PRIMARY: */ /* `(' COMPSTMT `)' | LITERAL | VARIABLE | PRIMARY `::' IDENTIFIER | `::' IDENTIFIER | PRIMARY `[' [ARGS] `]' | `[' [ARGS [`,']] `]' | `{' [(ARGS|ASSOCS) [`,']] `}' | return [`(' [CALL_ARGS] `)'] | yield [`(' [CALL_ARGS] `)'] | defined? `(' ARG `)' | FUNCTION | FUNCTION `{' [`|' [BLOCK_VAR] `|'] COMPSTMT `}' | if EXPR THEN COMPSTMT (elsif EXPR THEN COMPSTMT)* [else COMPSTMT] end | unless EXPR THEN COMPSTMT [else COMPSTMT] end | while EXPR DO COMPSTMT end | until EXPR DO COMPSTMT end | case COMPSTMT (when WHEN_ARGS THEN COMPSTMT)+ [else COMPSTMT] end | for BLOCK_VAR in EXPR DO COMPSTMT end | begin COMPSTMT [rescue [ARGS] DO COMPSTMT]+ [else COMPSTMT] [ensure COMPSTMT] end | class IDENTIFIER [`<' IDENTIFIER] COMPSTMT end"= | module IDENTIFIER COMPSTMT end | def FNAME ARGDECL COMPSTMT end | def SINGLETON (`.'|`::') FNAME ARGDECL COMPSTMT end */ PRIMARY.Rule = // "(" + COMPSTMT + ")" | //-- removed this to fix ambiguity LITERAL | LHS //note 1. | "[" + WithQ(ARGS + comma.Q()) + "]" | "{" + WithQ( (ARGS|ASSOC) + comma.Q() ) + "}" | RETURN_STMT | YIELD_STMT | DEFINEDQ_STMT | FUNCTION_STMT | IF_STMT | UNLESS_STMT | WHILE_STMT | UNTIL_STMT | CASE_STMT | FOR_STMT | BLOCK_STMT | CLASS_DEF | MODULE | DEFFUNC_STMT | DEFSING_STMT; // LHS.Expression = VARIABLE | PRIMARY + "[" + ARGS.Q() + "]" | PRIMARY + "." + IDENTIFIER; RETURN_STMT.Rule = "return" + EXPR;// CALL_ARGS_P.Q(); //changed this YIELD_STMT.Rule = "yield" + CALL_ARGS_P.Q(); DEFINEDQ_STMT.Rule = Symbol("defined?") + "(" + ARG + ")"; FUNCTION_STMT.Rule = FUNCTION + WithQ("{" + WithQ("|" + BLOCK_VAR.Q() + "|") + COMPSTMT + "}"); IF_STMT.Rule = "if" + EXPR + THEN + COMPSTMT + WithStar("elsif" + EXPR + THEN + COMPSTMT) + WithQ("else" + COMPSTMT) + END; UNLESS_STMT.Rule = "unless" + EXPR + THEN + COMPSTMT + "else" + COMPSTMT + END; WHILE_STMT.Rule = "while" + EXPR + DO + COMPSTMT + END; UNTIL_STMT.Rule = "until" + EXPR + DO + COMPSTMT + END; CASE_STMT.Rule = "case" + COMPSTMT + WithPlus("when" + WHEN_ARGS + THEN + COMPSTMT) + WithQ("else" + COMPSTMT) + END; FOR_STMT.Rule = "for" + BLOCK_VAR + "in" + EXPR + DO + COMPSTMT + END; BLOCK_STMT.Rule = "begin" + COMPSTMT + WithPlus("rescue" + ARGS.Q() + DO + COMPSTMT) + WithQ("else" + COMPSTMT) + WithQ("ensure" + COMPSTMT) + END; CLASS_DEF.Rule = "class" + IDENTIFIER + BASE_REF.Q() + COMPSTMT + END; BASE_REF.Rule = "<" + IDENTIFIER; MODULE.Rule = "module" + IDENTIFIER + COMPSTMT + END; DEFFUNC_STMT.Rule = "def" + FNAME + ARGDECL.Q() + COMPSTMT + END; DEFSING_STMT.Rule = "def" + SINGLETON + (dot|"::") + FNAME + ARGDECL.Q() + COMPSTMT + END; END.Rule = "end"; // TERM.Q() + "end"; // SINGLETON : VARIABLE | `(' EXPR `)' SINGLETON.Rule = IDENTIFIER | "(" + EXPR + ")"; // WHEN_ARGS : ARGS [`,' `*' ARG] | `*' ARG WHEN_ARGS.Rule = ARGS + WithQ(comma + "*" + ARG) | "*" + ARG; // THEN : TERM | then | TERM then THEN.Rule = TERM | "then" | TERM + "then"; // DO : TERM | do | TERM do DO.Rule = TERM | "do" | TERM + "do"; // BLOCK_VAR : LHS | MLHS // BLOCK_VAR.Expression = LHS | MLHS; // -- ambiguous, changing to the following: BLOCK_VAR.Rule = IDENTIFIER | "(" + IDENTIFIER.Plus(comma) + ")"; // MLHS : MLHS_ITEM `,' [MLHS_ITEM (`,' MLHS_ITEM)*] [`*' [LHS]] | `*' LHS // MLHS.Expression = MLHS_ITEM.Plus(",") + WithQ("*" + LHS.Q()) | "*" + LHS; --ambiguous //MLHS.Expression = PRIMARY.Plus(",") + WithQ("*" + LHS.Q()) | "*" + LHS; // MLHS_ITEM : LHS | '(' MLHS ')' //MLHS_ITEM.Expression = LHS | "(" + MLHS + ")"; //--ambiguous!!! using PRIMARY //MLHS_ITEM = PRIMARY; /* LHS : VARIABLE | PRIMARY `[' [ARGS] `]' | PRIMARY `.' IDENTIFIER */ // LHS.Expression = IDENTIFIER | PRIMARY + "[" + ARGS.Q() + "]" | PRIMARY + dot + IDENTIFIER; LHS.Rule = OPERATION | PRIMARY + "[" + ARGS.Q() + "]" | "(" + EXPR + ")"; // MRHS : ARGS [`,' `*' ARG] | `*' ARG MRHS.Rule = ARGS + WithQ(comma + "*" + ARG) | "*" + ARG; /* CALL_ARGS : ARGS | ARGS [`,' ASSOCS] [`,' `*' ARG] [`,' `&' ARG] | ASSOCS [`,' `*' ARG] [`,' `&' ARG] | `*' ARG [`,' `&' ARG] | `&' ARG | COMMAND */ CALL_ARGS.Rule = // ARGS | //removed this - it is covered by next expression ARGS + WithQ(comma + ASSOCS) + STAR_ARG.Q() + AMP_ARG.Q() | ASSOCS + STAR_ARG.Q() + AMP_ARG.Q() | "*" + ARG + AMP_ARG.Q() | "&" + ARG | COMMAND; AMP_ARG.Rule = comma + "&" + ARG; STAR_ARG.Rule = comma + "*" + ARG; // ARGS : ARG (`,' ARG)* ARGS.Rule = ARG.Plus(comma); // ARGDECL : `(' ARGLIST `)' | ARGLIST TERM ARGDECL.Rule = "(" + ARGLIST + ")" | ARGLIST + TERM; /* ARGLIST : IDENTIFIER(`,'IDENTIFIER)*[`,'`*'[IDENTIFIER]][`,'`&'IDENTIFIER] | `*'IDENTIFIER[`,'`&'IDENTIFIER] | [`&'IDENTIFIER] */ ARGLIST.Rule = IDENTIFIER.Plus(comma) + WithQ(comma + "*" + IDENTIFIER.Q()) + WithQ(comma + "&" + IDENTIFIER) | "*" + IDENTIFIER + WithQ(comma + "&" + IDENTIFIER) | "&" + IDENTIFIER; // ASSOCS : ASSOC (`,' ASSOC)* ASSOCS.Rule = ASSOC.Plus(comma); //ASSOC : ARG `=>' ARG ASSOC.Rule = ARG + "=>" + ARG; // VARIABLE : VARNAME | nil | self -- variable is merged into IDENTIFIER //VARIABLE.Expression = IDENTIFIER | "nil" | "self"; // LITERAL : numeric | SYMBOL | STRING | STRING2 | HERE_DOC | REGEXP LITERAL.Rule = Number | SYMBOL | STRING | HereDoc | RegExLiteral; SYMBOL.Rule = Symbol(":") + IDENTIFIER; // (FNAME | VARNAME); //note 1. /* FNAME : IDENTIFIER | `..' | `|' | `^' | `&' | `<=>' | `==' | `===' | `=~' | `>' | `>=' | `<' | `<=' | `+' | `-' | `*' | `/' | `%' | `**' | `<<' | `>>' | `~' | `+@' | `-@' | `[]' | `[]=' */ FNAME.Rule = IDENTIFIER | ".." | "|" | "^" | "&" | "<=>" | "==" | "===" | "=~" | ">" | ">=" | "<" | "<=" | "+" | "-" | "*" | "/" | "%" | "**" | "<<" | ">>" | "~" | "+@" | "-@" | "[]" | "[]="; // TERM : `;' | `\n' TERM.Rule = NewLine | ";"; //NewLine is produced by token filter #endregion //error handling EXPR.ErrorRule = SyntaxError; DEFFUNC_STMT.ErrorRule = "def" + SyntaxError + COMPSTMT + END; #region misc: Operators, TokenFilters, etc //Register operators - not sure if precedence is assigned correctly RegisterOperators(100, Associativity.Right, "**"); RegisterOperators( 90, "<<", ">>"); RegisterOperators( 80, "*", "/", "%"); RegisterOperators( 70, "+", "-"); RegisterOperators( 60, "&", "&&", "and"); RegisterOperators( 50, "|", "||", "or", "^"); RegisterOperators( 40, ">", ">=", "<", "<=", "?"); RegisterOperators( 30, "<=>" , "==" , "===" , "!=" , "=~" , "!~"); RegisterOperators( 20, "..", "..."); RegisterPunctuation("(", ")", "," ); CodeOutlineFilter filter = new CodeOutlineFilter(false); TokenFilters.Add(filter); #endregion }
public BDVHDLGrammar() : base(false) { KeyTerm sComma = ToTerm(","); KeyTerm sPeriod = ToTerm("."); KeyTerm sColon = ToTerm(":"); KeyTerm sSemicolon = ToTerm(";"); KeyTerm sLParen = ToTerm("("); KeyTerm sRParen = ToTerm(")"); KeyTerm sAssign = ToTerm("<="); KeyTerm sSeqAssign = ToTerm(":="); KeyTerm sRArrow = ToTerm("=>"); KeyTerm sAbs = ToTerm("abs"); KeyTerm sAccess = ToTerm("access"); KeyTerm sAfter = ToTerm("after"); KeyTerm sAlias = ToTerm("alias"); KeyTerm sAll = ToTerm("all"); KeyTerm sAnd = ToTerm("and"); KeyTerm sArchitecture = ToTerm("architecture"); KeyTerm sArray = ToTerm("array"); KeyTerm sAssert = ToTerm("assert"); KeyTerm sAttribute = ToTerm("attribute"); KeyTerm sBegin = ToTerm("begin"); KeyTerm sBlock = ToTerm("block"); KeyTerm sBody = ToTerm("body"); KeyTerm sBuffer = ToTerm("buffer"); KeyTerm sBus = ToTerm("bus"); KeyTerm sCase = ToTerm("case"); KeyTerm sComponent = ToTerm("component"); KeyTerm sConfiguration = ToTerm("configuration"); KeyTerm sConstant = ToTerm("constant"); KeyTerm sDisconnect = ToTerm("disconnect"); KeyTerm sDownto = ToTerm("downto"); KeyTerm sElse = ToTerm("else"); KeyTerm sElsif = ToTerm("elsif"); KeyTerm sEnd = ToTerm("end"); KeyTerm sEntity = ToTerm("entity"); KeyTerm sExit = ToTerm("exit"); KeyTerm sFile = ToTerm("file"); KeyTerm sFor = ToTerm("for"); KeyTerm sFunction = ToTerm("function"); KeyTerm sGenerate = ToTerm("generate"); KeyTerm sGeneric = ToTerm("generic"); KeyTerm sGroup = ToTerm("group"); KeyTerm sGuarded = ToTerm("guarded"); KeyTerm sIf = ToTerm("if"); KeyTerm sImpure = ToTerm("impure"); KeyTerm sIn = ToTerm("in"); KeyTerm sInitial = ToTerm("inertial"); KeyTerm sInout = ToTerm("inout"); KeyTerm sIs = ToTerm("is"); KeyTerm sLabel = ToTerm("label"); KeyTerm sLibrary = ToTerm("library"); KeyTerm sLinkage = ToTerm("linkage"); KeyTerm sLiteral = ToTerm("literal"); KeyTerm sLoop = ToTerm("loop"); KeyTerm sMap = ToTerm("map"); KeyTerm sMod = ToTerm("mod"); KeyTerm sNand = ToTerm("nand"); KeyTerm sNew = ToTerm("new"); KeyTerm sNext = ToTerm("next"); KeyTerm sNor = ToTerm("nor"); KeyTerm sNot = ToTerm("not"); KeyTerm sNull = ToTerm("null"); KeyTerm sOf = ToTerm("of"); KeyTerm sOn = ToTerm("on"); KeyTerm sOpen = ToTerm("open"); KeyTerm sOr = ToTerm("or"); KeyTerm sOther = ToTerm("others"); KeyTerm sOut = ToTerm("out"); KeyTerm sPackage = ToTerm("package"); KeyTerm sPort = ToTerm("port"); KeyTerm sPostponed = ToTerm("postponed"); KeyTerm sProcedure = ToTerm("procedure"); KeyTerm sProcess = ToTerm("process"); KeyTerm sPure = ToTerm("pure"); KeyTerm sRange = ToTerm("range"); KeyTerm sRecord = ToTerm("record"); KeyTerm sRegister = ToTerm("register"); KeyTerm sReject = ToTerm("reject"); KeyTerm sReturn = ToTerm("return"); KeyTerm sRol = ToTerm("rol"); KeyTerm sRor = ToTerm("ror"); KeyTerm sSelect = ToTerm("select"); KeyTerm sSeverity = ToTerm("severity"); KeyTerm sSignal = ToTerm("signal"); KeyTerm sShared = ToTerm("shared"); KeyTerm sSla = ToTerm("sla"); KeyTerm sSli = ToTerm("sli"); KeyTerm sSra = ToTerm("sra"); KeyTerm sSrl = ToTerm("srl"); KeyTerm sSubtype = ToTerm("subtype"); KeyTerm sThen = ToTerm("then"); KeyTerm sTo = ToTerm("to"); KeyTerm sTransport = ToTerm("transport"); KeyTerm sType = ToTerm("type"); KeyTerm sUnaffected = ToTerm("unaffected"); KeyTerm sUnits = ToTerm("units"); KeyTerm sUntil = ToTerm("until"); KeyTerm sUse = ToTerm("use"); KeyTerm sVariable = ToTerm("variable"); KeyTerm sWait = ToTerm("wait"); KeyTerm sWhen = ToTerm("when"); KeyTerm sWhile = ToTerm("while"); KeyTerm sWidth = ToTerm("with"); KeyTerm sXnor = ToTerm("xnor"); KeyTerm sXor = ToTerm("xor"); var comment = new CommentTerminal("comment", "--", "\n", "\r\n"); NonGrammarTerminals.Add(comment); NumberLiteral sNumber = new NumberLiteral("number"); sNumber.Priority = 1; // identifierよりも先も評価 IdentifierTerminal sIdentifier = new IdentifierTerminal("identifier", "\\_", "\\_0123456789"); StringLiteral sString = new StringLiteral("string", "\""); NonTerminal designFile = new NonTerminal("design_file"); NonTerminal designUnit = new NonTerminal("design_unit"); NonTerminal contextClause = new NonTerminal("context_clause"); NonTerminal contextItem = new NonTerminal("context_item"); NonTerminal libraryClause = new NonTerminal("library_clause"); NonTerminal libraryNames = new NonTerminal("library_names"); NonTerminal libraryName = new NonTerminal("library_name"); NonTerminal useClause = new NonTerminal("use_clause"); NonTerminal useNames = new NonTerminal("use_names"); NonTerminal useName = new NonTerminal("use_name"); NonTerminal identifierSeries = new NonTerminal("identifier_series"); NonTerminal libraryUnit = new NonTerminal("library_unit"); NonTerminal entityDeclaration = new NonTerminal("entity_declaration"); NonTerminal entityHeader = new NonTerminal("entity_header"); NonTerminal genericClause = new NonTerminal("generic_clause"); NonTerminal portClause = new NonTerminal("port_clause"); NonTerminal interfaceList = new NonTerminal("interface_list"); NonTerminal declaration = new NonTerminal("declaration"); NonTerminal attributeDeclaration = new NonTerminal("attribute_declaration"); NonTerminal attributeSpecification = new NonTerminal("attribute_specification"); NonTerminal objectDeclaration = new NonTerminal("object_declaration"); NonTerminal objectType = new NonTerminal("object_type"); NonTerminal identifierList = new NonTerminal("identifier_list"); NonTerminal objectMode = new NonTerminal("object_mode"); NonTerminal subtypeIndication = new NonTerminal("subtype_indication"); NonTerminal rangeConstraint = new NonTerminal("range_constraint"); NonTerminal direction = new NonTerminal("direction"); NonTerminal architectureBody = new NonTerminal("architecture_body"); NonTerminal architectureDeclarativePart = new NonTerminal("architecture_declarative_part"); NonTerminal blockDeclarativeItem = new NonTerminal("block_declarative_item"); NonTerminal componentDeclaration = new NonTerminal("component_declaration"); NonTerminal architectureStatementPart = new NonTerminal("architecture_statement_part"); NonTerminal concurrentStatement = new NonTerminal("concurrent_statement"); NonTerminal concurrentSignalAssignmentStatement = new NonTerminal("concurrent_signal_assignment_statement"); NonTerminal name = new NonTerminal("name"); NonTerminal simpleName = new NonTerminal("simple_name"); NonTerminal indexedName = new NonTerminal("indexed_name"); NonTerminal sliceName = new NonTerminal("slice_name"); NonTerminal componentInstatiationStatement = new NonTerminal("component_instantiation_statement"); NonTerminal genericMapAspect = new NonTerminal("generic_map_aspect"); NonTerminal portMapAspect = new NonTerminal("port_map_aspect"); NonTerminal portAssociationList = new NonTerminal("port_association_list"); NonTerminal portAssociationElement = new NonTerminal("port_association_element"); NonTerminal genericAssociationList = new NonTerminal("generic_association_list"); NonTerminal genericAssociationElement = new NonTerminal("generic_association_element"); NonTerminal expression = new NonTerminal("expression"); NonTerminal andExpression = new NonTerminal("and_expression"); NonTerminal orExpression = new NonTerminal("or_expression"); NonTerminal xorExpression = new NonTerminal("xor_expression"); NonTerminal nandExpression = new NonTerminal("nand_expression"); NonTerminal norExpression = new NonTerminal("nor_expression"); NonTerminal xnorExpression = new NonTerminal("xnor_expression"); NonTerminal factor = new NonTerminal("factor"); NonTerminal primary = new NonTerminal("primary"); designFile.Rule = MakePlusRule(designFile, designUnit); designUnit.Rule = contextClause + libraryUnit; contextClause.Rule = MakeStarRule(contextClause, contextItem); contextItem.Rule = libraryClause | useClause; libraryClause.Rule = sLibrary + libraryNames + sSemicolon; libraryNames.Rule = MakePlusRule(libraryNames, sComma, libraryName); libraryName.Rule = sIdentifier; useClause.Rule = sUse + useNames + sSemicolon; useNames.Rule = MakePlusRule(useNames, sComma, useName); useName.Rule = identifierSeries + (sPeriod + sAll).Q(); identifierSeries.Rule = MakePlusRule(identifierSeries, sPeriod, sIdentifier); libraryUnit.Rule = entityDeclaration + architectureBody; entityDeclaration.Rule = sEntity + sIdentifier + sIs + entityHeader + sEnd + sEntity.Q() + sIdentifier.Q() + sSemicolon; entityHeader.Rule = genericClause.Q() + portClause.Q(); genericClause.Rule = sGeneric + sLParen + interfaceList + sRParen + sSemicolon; portClause.Rule = sPort + sLParen + interfaceList + sRParen + sSemicolon; interfaceList.Rule = MakePlusRule(interfaceList, sSemicolon, declaration); declaration.Rule = objectDeclaration | attributeDeclaration | attributeSpecification; attributeDeclaration.Rule = sAttribute + sIdentifier + sColon + subtypeIndication; attributeSpecification.Rule = sAttribute + sIdentifier + sOf + sIdentifier + sIs + expression; objectDeclaration.Rule = objectType.Q() + identifierList + sColon + objectMode.Q() + subtypeIndication + (sSeqAssign + expression).Q(); objectType.Rule = sAttribute | sConstant | sSignal | sVariable | sFile; identifierList.Rule = MakePlusRule(identifierList, sComma, sIdentifier); objectMode.Rule = sIn | sOut | sInout | sBuffer | sLinkage; subtypeIndication.Rule = sIdentifier + (sLParen + rangeConstraint + sRParen).Q(); rangeConstraint.Rule = sNumber + direction + sNumber; direction.Rule = sTo | sDownto; architectureBody.Rule = sArchitecture + sIdentifier + sOf + sIdentifier + sIs + architectureDeclarativePart + sBegin + architectureStatementPart + sEnd + sArchitecture.Q() + sIdentifier.Q() + sSemicolon; architectureDeclarativePart.Rule = MakeStarRule(architectureDeclarativePart, blockDeclarativeItem); blockDeclarativeItem.Rule = componentDeclaration | objectDeclaration + sSemicolon | attributeDeclaration + sSemicolon | attributeSpecification + sSemicolon; componentDeclaration.Rule = sComponent + sIdentifier + sIs.Q() + genericClause.Q() + portClause.Q() + sEnd + sComponent + sIdentifier.Q() + sSemicolon; architectureStatementPart.Rule = MakeStarRule(architectureStatementPart, concurrentStatement); concurrentStatement.Rule = concurrentSignalAssignmentStatement | componentInstatiationStatement; concurrentSignalAssignmentStatement.Rule = name + sAssign + expression + sSemicolon; name.Rule = simpleName | indexedName | sliceName; simpleName.Rule = sIdentifier; indexedName.Rule = sIdentifier + sLParen + sNumber + sRParen; sliceName.Rule = sIdentifier + sLParen + rangeConstraint + sRParen; componentInstatiationStatement.Rule = sIdentifier + sColon + sComponent.Q() + sIdentifier + genericMapAspect.Q() + portMapAspect.Q() + sSemicolon; genericMapAspect.Rule = sGeneric + sMap + sLParen + genericAssociationList + sRParen; portMapAspect.Rule = sPort + sMap + sLParen + portAssociationList + sRParen; genericAssociationList.Rule = MakePlusRule(genericAssociationList, sComma, genericAssociationElement); genericAssociationElement.Rule = name + sRArrow + expression; portAssociationList.Rule = MakePlusRule(portAssociationList, sComma, portAssociationElement); portAssociationElement.Rule = name + sRArrow + name; expression.Rule = andExpression | orExpression | xorExpression; andExpression.Rule = MakePlusRule(andExpression, sAnd, factor); orExpression.Rule = MakePlusRule(orExpression, sOr, factor); xorExpression.Rule = MakePlusRule(xorExpression, sXor, factor); factor.Rule = primary | sNot + primary; primary.Rule = name | sNumber | sString | sLParen + expression + sRParen; Root = designFile; }