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;
}
