protected static NumberLiteral CreateLuaNumber(string name)
{
NumberLiteral term = new NumberLiteral(name, NumberOptions.AllowStartEndDot);
//default int types are Integer (32bit) -> LongInteger (BigInt); Try Int64 before BigInt: Better performance?
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
term.DefaultFloatType = TypeCode.Double; // it is default
term.AddPrefix("0x", NumberOptions.Hex);
return(term);
}
private NumberLiteral CreateNumberLiteral(string name)
{
var term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
term.DefaultFloatType = TypeCode.Double;
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("l", TypeCode.Int64, TypeCode.UInt64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
return term;
}
private NumberLiteral CreateNumberLiteral(string name)
{
var term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
term.DefaultFloatType = TypeCode.Double;
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("l", TypeCode.Int64, TypeCode.UInt64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
return(term);
}
public static NumberLiteral CreateJavaNumber(string name)
{
var term = new NumberLiteral(name, NumberOptions.AllowStartEndDot)
{
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Double
};
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("l", TypeCode.Int64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
return term;
}
//http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-334.pdf section 9.4.4
public static NumberLiteral CreateCSharpNumber(string name) {
NumberLiteral term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.UInt32, TypeCode.Int64, TypeCode.UInt64 };
term.DefaultFloatType = TypeCode.Double;
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("u", TypeCode.UInt32, TypeCode.UInt64);
term.AddSuffix("l", TypeCode.Int64, TypeCode.UInt64);
term.AddSuffix("ul", TypeCode.UInt64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
term.AddSuffix("m", TypeCode.Decimal);
return term;
}
private void SetUpTerminals()
{
Comment = new CommentTerminal(nameof(Comment), ";", "\n", "\r");
NonGrammarTerminals.Add(Comment);
var ident = new IdentifierTerminal(nameof(Ident), ".$_", ".$_");
ident.Options = IdOptions.IsNotKeyword;
Ident = ident;
var number = new NumberLiteral(nameof(Number), NumberOptions.AllowUnderscore | NumberOptions.IntOnly | NumberOptions.AllowSign);
number.AddPrefix("0x", NumberOptions.Hex);
number.AddPrefix("0b", NumberOptions.Binary);
number.AddPrefix("0", NumberOptions.Octal);
Number = number;
NormalString = new StringLiteral(nameof(NormalString), "\"", StringOptions.NoEscapes);
EscapedString = new StringLiteral(nameof(EscapedString), "`", StringOptions.AllowsAllEscapes);
CharLiteral = new StringLiteral(nameof(CharLiteral), "'", StringOptions.IsChar | StringOptions.AllowsAllEscapes);
Separator = ToTerm(SeparatorToken, nameof(Separator));
}
//http://www.microsoft.com/downloads/details.aspx?FamilyId=6D50D709-EAA4-44D7-8AF3-E14280403E6E&displaylang=en section 2
public static NumberLiteral CreateVbNumber(string name) {
NumberLiteral term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64 };
//term.DefaultFloatType = TypeCode.Double; it is default
term.AddPrefix("&H", NumberOptions.Hex);
term.AddPrefix("&O", NumberOptions.Octal);
term.AddSuffix("S", TypeCode.Int16);
term.AddSuffix("I", TypeCode.Int32);
term.AddSuffix("%", TypeCode.Int32);
term.AddSuffix("L", TypeCode.Int64);
term.AddSuffix("&", TypeCode.Int64);
term.AddSuffix("D", TypeCode.Decimal);
term.AddSuffix("@", TypeCode.Decimal);
term.AddSuffix("F", TypeCode.Single);
term.AddSuffix("!", TypeCode.Single);
term.AddSuffix("R", TypeCode.Double);
term.AddSuffix("#", TypeCode.Double);
term.AddSuffix("US", TypeCode.UInt16);
term.AddSuffix("UI", TypeCode.UInt32);
term.AddSuffix("UL", TypeCode.UInt64);
return term;
}
public static NumberLiteral CreateJavaNumber(string name)
{
var term = new NumberLiteral(name, NumberOptions.AllowStartEndDot)
{
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Double
};
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("l", TypeCode.Int64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
return(term);
}
static NumberLiteral CreateNumberLiteral(string name)
{
NumberLiteral term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.UInt32, TypeCode.Int64, TypeCode.UInt64 };
term.DefaultFloatType = TypeCode.Double;
term.AddPrefix("0x", NumberOptions.Hex);
term.AddSuffix("u", TypeCode.UInt32, TypeCode.UInt64);
term.AddSuffix("l", TypeCode.Int64, TypeCode.UInt64);
term.AddSuffix("ul", TypeCode.UInt64);
term.AddSuffix("f", TypeCode.Single);
term.AddSuffix("d", TypeCode.Double);
term.AddSuffix("m", TypeCode.Decimal);
term.Options |= NumberOptions.AllowSign;
return(term);
}
static NumberLiteral createNumberLiteral()
{
var Num = new NumberLiteral("Number");
Num.AddPrefix("-", NumberOptions.AllowSign);
Num.AddPrefix("0x", NumberOptions.Hex);
Num.AddPrefix("0d", NumberOptions.Default);
Num.AddPrefix("0o", NumberOptions.Octal);
Num.AddPrefix("0", NumberOptions.Octal);
Num.AddPrefix("0b", NumberOptions.Binary);
return(Num);
}
public LiteralRules(PieGrammar grammar)
{
this.grammar = grammar;
NumberLiteral = new NumberLiteral("number_literal", NumberOptions.AllowStartEndDot)
{
// Define types to assign if the parser can't determine.
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Double
};
// The pre and post fixes for different number types and formats.
NumberLiteral.AddPrefix("0x", NumberOptions.Hex);
NumberLiteral.AddSuffix("b", TypeCode.Byte);
NumberLiteral.AddSuffix("B", TypeCode.Byte);
NumberLiteral.AddSuffix("s", TypeCode.Int16);
NumberLiteral.AddSuffix("S", TypeCode.Int16);
NumberLiteral.AddSuffix("u", TypeCode.UInt32);
NumberLiteral.AddSuffix("U", TypeCode.UInt32);
NumberLiteral.AddSuffix("us", TypeCode.UInt16);
NumberLiteral.AddSuffix("US", TypeCode.UInt16);
NumberLiteral.AddSuffix("l", TypeCode.Int64);
NumberLiteral.AddSuffix("L", TypeCode.Int64);
NumberLiteral.AddSuffix("ul", TypeCode.UInt64);
NumberLiteral.AddSuffix("UL", TypeCode.UInt64);
NumberLiteral.AddSuffix("F", TypeCode.Single);
NumberLiteral.AddSuffix("f", TypeCode.Single);
NumberLiteral.AddSuffix("d", TypeCode.Double);
NumberLiteral.AddSuffix("D", TypeCode.Double);
NumberLiteral.AddSuffix("m", TypeCode.Decimal);
NumberLiteral.AddSuffix("M", TypeCode.Decimal);
StringLiteral = new StringLiteral("string_literal", "\"", StringOptions.AllowsAllEscapes);
CharLiteral = new StringLiteral("char_literal", "'", StringOptions.IsChar);
BoolLiteral = new NonTerminal("bool_literal");
BoolLiteral.Rule = grammar.Keywords.True | grammar.Keywords.False;
Null = grammar.ToTerm("null", "null_literal");
}
public LiteralRules(PieGrammar grammar)
{
this.grammar = grammar;
NumberLiteral = new NumberLiteral("number_literal", NumberOptions.AllowStartEndDot)
{
// Define types to assign if the parser can't determine.
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Double
};
// The pre and post fixes for different number types and formats.
NumberLiteral.AddPrefix("0x", NumberOptions.Hex);
NumberLiteral.AddSuffix("b", TypeCode.Byte);
NumberLiteral.AddSuffix("B", TypeCode.Byte);
NumberLiteral.AddSuffix("s", TypeCode.Int16);
NumberLiteral.AddSuffix("S", TypeCode.Int16);
NumberLiteral.AddSuffix("u", TypeCode.UInt32);
NumberLiteral.AddSuffix("U", TypeCode.UInt32);
NumberLiteral.AddSuffix("us", TypeCode.UInt16);
NumberLiteral.AddSuffix("US", TypeCode.UInt16);
NumberLiteral.AddSuffix("l", TypeCode.Int64);
NumberLiteral.AddSuffix("L", TypeCode.Int64);
NumberLiteral.AddSuffix("ul", TypeCode.UInt64);
NumberLiteral.AddSuffix("UL", TypeCode.UInt64);
NumberLiteral.AddSuffix("F", TypeCode.Single);
NumberLiteral.AddSuffix("f", TypeCode.Single);
NumberLiteral.AddSuffix("d", TypeCode.Double);
NumberLiteral.AddSuffix("D", TypeCode.Double);
NumberLiteral.AddSuffix("m", TypeCode.Decimal);
NumberLiteral.AddSuffix("M", TypeCode.Decimal);
StringLiteral = new StringLiteral("string_literal", "\"", StringOptions.AllowsAllEscapes);
CharLiteral = new StringLiteral("char_literal", "'", StringOptions.IsChar);
BoolLiteral = new NonTerminal("bool_literal");
BoolLiteral.Rule = grammar.Keywords.True | grammar.Keywords.False;
Null = grammar.ToTerm("null", "null_literal");
}
public RefalGrammar() : base(true) // case sensitive
{
GrammarComments = "Refal-5 language interpreter based on Irony toolkit.";
// Terminals
var Number = new NumberLiteral("Number");
Number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
Number.AddPrefix("0x", NumberOptions.Hex);
Number.AddSuffix("u", TypeCode.UInt32);
Number.AddSuffix("l", TypeCode.Int64);
Number.AddSuffix("ul", TypeCode.UInt64);
Number.Options |= NumberOptions.IntOnly;
var CharLiteral = new StringLiteral("Char", "'", StringOptions.AllowsAllEscapes);
var StringLiteral = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var Identifier = new IdentifierTerminal("Identifier", "_-", "");
var LineComment = new CommentTerminal("LineComment", "*", "\n", "\r");
LineComment.ValidateToken += LineComment_ValidateToken;
var BlockComment = new CommentTerminal("BlockComment", "/*", "*/");
NonGrammarTerminals.Add(LineComment);
NonGrammarTerminals.Add(BlockComment);
// Non-terminals
var Program = new NonTerminal("Program", typeof(Program));
var Definition = new NonTerminal("Definition");
var Function = new NonTerminal("Function", typeof(DefinedFunction));
var External = new NonTerminal("External", typeof(AuxiliaryNode));
var IdentifierList = new NonTerminal("Identifier+", typeof(AuxiliaryNode));
var Block = new NonTerminal("Block", typeof(Block));
var Sentence = new NonTerminal("Sentence", typeof(Sentence));
var RSentence = new NonTerminal("RSentence", typeof(AuxiliaryNode));
var SentenceList = new NonTerminal("Sentence+", typeof(AuxiliaryNode));
var Pattern = new NonTerminal("Pattern", typeof(Pattern));
var PatternItem = new NonTerminal("PatternItem");
var PatternInParentheses = new NonTerminal("(Pattern)", typeof(ExpressionInBraces));
var Expression = new NonTerminal("Expression", typeof(Expression));
var ExpressionItem = new NonTerminal("ExpressionItem");
var ExpressionInParentheses = new NonTerminal("(Expression)", typeof(ExpressionInBraces));
var Var = new NonTerminal("Variable", Variable.CreateVariableNode);
var VarPrefix = new NonTerminal("VariablePrefix");
var VarIndex = new NonTerminal("VariableIndex");
var Symbol = new NonTerminal("Symbol", LiteralValueNodeHelper.InitNode);
var Call = new NonTerminal("Call", typeof(FunctionCall));
var FunctionName = new NonTerminal("FunctionName", typeof(AuxiliaryNode));
var WhereOrWithClause = new NonTerminal("WhereOrWithClause", typeof(Conditions));
var CommaOrAmpersand = new NonTerminal("CommaOrAmpersand");
var RWhereOrWithClause = new NonTerminal("RWhereOrWithClause", typeof(AuxiliaryNode));
var RExpressionOrWhereOrWithClause = new NonTerminal("RExpressionOrWhereOrWithClause");
var SemicolonOpt = new NonTerminal("[;]", Empty | ";");
var EntryOpt = new NonTerminal("[ENTRY]", Empty | "$ENTRY");
var Extern = new NonTerminal("Extern", ToTerm("$EXTRN") | "$EXTERN" | "$EXTERNAL");
// Rules
Root = Program;
Program.Rule = MakePlusRule(Program, Definition);
Definition.Rule = Function | External;
External.Rule = Extern + IdentifierList + ";";
IdentifierList.Rule = MakePlusRule(IdentifierList, ToTerm(","), Identifier);
Function.Rule = EntryOpt + Identifier + Block + SemicolonOpt;
Block.Rule = "{" + SentenceList + SemicolonOpt + "}";
SentenceList.Rule = MakePlusRule(SentenceList, ToTerm(";"), Sentence);
Sentence.Rule = Pattern + RSentence;
RSentence.Rule = "=" + Expression | WhereOrWithClause;
Pattern.Rule = MakeStarRule(Pattern, PatternItem);
PatternItem.Rule = Var | Symbol | PatternInParentheses;
PatternInParentheses.Rule = "(" + Pattern + ")";
Expression.Rule = MakeStarRule(Expression, ExpressionItem);
ExpressionItem.Rule = Call | Var | Symbol | ExpressionInParentheses;
ExpressionInParentheses.Rule = "(" + Expression + ")";
Var.Rule = VarPrefix + "." + VarIndex;
VarPrefix.Rule = ToTerm("e") | "s" | "t";
VarIndex.Rule = Number | Identifier;
Symbol.Rule = StringLiteral | CharLiteral | Number | "True" | "False" | Identifier;
Call.Rule = "<" + FunctionName + Expression + ">";
FunctionName.Rule = Identifier | "+" | "-" | "*" | "/";
WhereOrWithClause.Rule = CommaOrAmpersand + Expression + ":" + RWhereOrWithClause;
CommaOrAmpersand.Rule = ToTerm(",") | "&";
RWhereOrWithClause.Rule = Block // with-clause
| Pattern + RExpressionOrWhereOrWithClause; // where-clause
RExpressionOrWhereOrWithClause.Rule = ToTerm("=") + Expression | WhereOrWithClause;
// Punctuation, braces, transient terms, options
MarkPunctuation("(", ")");
MarkPunctuation("{", "}");
MarkPunctuation("<", ">");
MarkPunctuation("=", ",", "&", ";");
RegisterBracePair("(", ")");
RegisterBracePair("<", ">");
RegisterBracePair("{", "}");
MarkTransient(Definition, PatternItem, ExpressionItem, SemicolonOpt, EntryOpt, Extern, CommaOrAmpersand, VarPrefix, VarIndex, RExpressionOrWhereOrWithClause);
LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.SupportsBigInt | LanguageFlags.TailRecursive;
}
public EbisterGrammar() : base(true)
{
// 0. Comments
var commentSingleLine = new CommentTerminal("commentSingleLine", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
var commentMultiLine = new CommentTerminal("commentMultiLine", "/*", "*/");
NonGrammarTerminals.Add(commentSingleLine);
NonGrammarTerminals.Add(commentMultiLine);
// 1. Literals and Operators
var literalNumber = new NumberLiteral("number",
NumberOptions.AllowSign |
NumberOptions.AllowStartEndDot |
NumberOptions.AllowUnderscore
);
literalNumber.AddPrefix("0x", NumberOptions.Hex);
literalNumber.AddPrefix("0b", NumberOptions.Binary);
var literalString = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes);
literalString.AddPrefix("@", StringOptions.NoEscapes | StringOptions.AllowsLineBreak | StringOptions.AllowsDoubledQuote);
var identifier = new IdentifierTerminal("identifier");
var operatorPlus = ToTerm("+");
var operatorMinus = ToTerm("-");
var operatorAsterisk = ToTerm("*");
var operatorSlash = ToTerm("/");
var operatorPercent = ToTerm("%");
var operatorParenLeft = ToTerm("(");
var operatorParenRight = ToTerm(")");
var operatorSemicolon = ToTerm(";");
// 2. Non-Terminals
// 2.1 Statements
var program = new NonTerminal("program", typeof(IronyProgramNode));
var statement = new NonTerminal("statement", typeof(IronyGroupedNode));
var statementBlock = new NonTerminal("statementBlock", typeof(IronyBlockStatementNode));
var statementExpression = new NonTerminal("statementBlock", typeof(IronyExpressionStatementNode));
var statementKeyword = new NonTerminal("statementKeyword", typeof(IronyKeywordStatementNode));
var statementRepeat = new NonTerminal("statementRepeat", typeof(IronyRepeatStatementNode));
// 2.2 Expressions
var exprAddSub = new NonTerminal("exprAddSub", typeof(IronyExpressionNode));
var exprMulDiv = new NonTerminal("exprMulDiv", typeof(IronyExpressionNode));
var expr = new NonTerminal("expr", typeof(IronyExpressionNode));
var exprs = new NonTerminal("exprs", typeof(IronyExpressionsNode));
var exprParen = new NonTerminal("exprParen", typeof(IronyParenExpressionNode));
var exprUnary = new NonTerminal("exprUnary", typeof(IronyUnaryExpressionNode));
var exprCall = new NonTerminal("call", typeof(IronyCallExpressionNode));
var operatorUnary = new NonTerminal("operatorUnary", typeof(IronyUnaryOperatorNode));
// 3. BNF Definition
program.Rule = MakeStarRule(program, statement);
exprs.Rule = MakeStarRule(exprs, ToTerm(","), exprAddSub);
statementExpression.Rule = exprAddSub + operatorSemicolon;
statementBlock.Rule = ToTerm("{") + program + ToTerm("}");
statementKeyword.Rule = "break" + operatorSemicolon
| "continue" + operatorSemicolon
| "return" + operatorSemicolon;
statementRepeat.Rule = "repeat" + statement;
statement.Rule = statementExpression
| statementBlock
| statementKeyword
| statementRepeat;
exprAddSub.Rule = exprMulDiv
| exprAddSub + operatorPlus + exprAddSub
| exprAddSub + operatorMinus + exprAddSub;
exprMulDiv.Rule = expr
| exprMulDiv + operatorAsterisk + exprMulDiv
| exprMulDiv + operatorSlash + exprMulDiv
| exprMulDiv + operatorPercent + exprMulDiv;
exprCall.Rule =
expr + operatorParenLeft + exprs + operatorParenRight;
expr.Rule = exprParen
| exprUnary
| exprCall
| literalNumber
| literalString
| "true"
| "false"
| "null"
| identifier;
exprParen.Rule = operatorParenLeft + exprAddSub + operatorParenRight;
exprUnary.Rule = operatorUnary + expr;
operatorUnary.Rule = operatorPlus | operatorMinus;
Root = program;
LanguageFlags = LanguageFlags.CreateAst;
}
public Grammar()
{
this.LanguageFlags |= Irony.Parsing.LanguageFlags.CreateAst;
var comment = new CommentTerminal("comment", "//", "\n", "\r\n");
NonGrammarTerminals.Add(comment);
var integerLiteral = new NumberLiteral("integer", NumberOptions.IntOnly);
integerLiteral.AddPrefix("0x", NumberOptions.Hex);
var identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
identifier.AstNodeType = typeof(VariableNameNode);
var inlineASM = new NonTerminal("inline", typeof(InlineASMNode));
var numberLiteral = new NonTerminal("Number", typeof(NumberLiteralNode));
var expression = new NonTerminal("Expression");
var parenExpression = new NonTerminal("Paren Expression");
var binaryOperation = new NonTerminal("Binary Operation", typeof(BinaryOperationNode));
var @operator = ToTerm("+") | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "==" | "!=";
var variableDeclaration = new NonTerminal("Variable Declaration", typeof(VariableDeclarationNode));
var dereference = new NonTerminal("Dereference", typeof(DereferenceNode));
var statement = new NonTerminal("Statement");
var statementList = new NonTerminal("Statement List", typeof(BlockNode));
var assignment = new NonTerminal("Assignment", typeof(AssignmentNode));
var ifStatement = new NonTerminal("If", typeof(IfStatementNode));
var block = new NonTerminal("Block");
var ifElseStatement = new NonTerminal("IfElse", typeof(IfStatementNode));
var parameterList = new NonTerminal("Parameter List");
var functionDeclaration = new NonTerminal("Function Declaration", typeof(FunctionDeclarationNode));
var parameterDeclaration = new NonTerminal("Parameter Declaration");
var parameterListDeclaration = new NonTerminal("Parameter Declaration List");
var returnStatement = new NonTerminal("Return", typeof(ReturnStatementNode));
//var indexOperation = new NonTerminal("Index Operation", typeof(IndexOperationNode));
//var indexAssignment = new NonTerminal("Index Assignment", typeof(IndexAssignmentNode));
//var inlineArgument = new NonTerminal("Inline Argument", typeof(InlineArgumentNode));
//var inlineArgumentList = new NonTerminal("Inline Argument List");
//var inlineInstruction = new NonTerminal("Inline Instruction", typeof(InlineInstructionNode));
//var inlineInstructionList = new NonTerminal("Inline Instruction List");
//var inlineBlock = new NonTerminal("Inline Block", typeof(InlineBlockNode));
var functionCall = new NonTerminal("Function Call", typeof(FunctionCallNode));
numberLiteral.Rule = integerLiteral;
expression.Rule = numberLiteral | binaryOperation | parenExpression | identifier | dereference | functionCall;
assignment.Rule = (identifier | dereference) + "=" + expression;
binaryOperation.Rule = expression + @operator + expression;
parenExpression.Rule = ToTerm("(") + expression + ")";
variableDeclaration.Rule = ToTerm("var") + identifier + "=" + expression;
dereference.Rule = ToTerm("*") + expression;
statement.Rule = inlineASM | (variableDeclaration + ";")
| (assignment + ";") | ifStatement | ifElseStatement | block | functionDeclaration | (functionCall + ";")
| (returnStatement + ";");
block.Rule = ToTerm("{") + statementList + "}";
statementList.Rule = MakeStarRule(statementList, statement);
inlineASM.Rule = ToTerm("asm") + "{" + new FreeTextLiteral("inline asm", "}") + "}";
ifStatement.Rule = ToTerm("if") + "(" + expression + ")" + statement;
ifElseStatement.Rule = ToTerm("if") + "(" + expression + ")" + statement + this.PreferShiftHere() + "else" + statement;
parameterList.Rule = MakeStarRule(parameterList, ToTerm(","), expression);
functionCall.Rule = identifier + "(" + parameterList + ")";
parameterDeclaration.Rule = identifier;
parameterListDeclaration.Rule = MakeStarRule(parameterListDeclaration, ToTerm(","), parameterDeclaration);
functionDeclaration.Rule = ToTerm("function") + identifier + "(" + parameterListDeclaration + ")" + block;
returnStatement.Rule = ToTerm("return") + expression;
this.Root = statementList;
this.RegisterBracePair("[", "]");
this.Delimiters = "{}[](),:;+-*/%&|^!~<>=.";
this.MarkPunctuation(";", ",", "(", ")", "{", "}", "[", "]", ":");
this.MarkTransient(expression, parenExpression, statement, block);//, parameterList);
this.RegisterOperators(1, Associativity.Right, "==", "!=");
this.RegisterOperators(2, Associativity.Right, "=");
this.RegisterOperators(3, Associativity.Left, "+", "-");
this.RegisterOperators(4, Associativity.Left, "*", "/");
this.RegisterOperators(6, Associativity.Left, "[", "]", "<", ">");
}
public BnfGrammar(Mode mode)
{
var alternationChar = (mode == Mode.Strict) ? "/" : "|";
var rulename = new IdentifierTerminal("rulename", "-_", null);
var funcname = new IdentifierTerminal("funcname", ".", null);
var newrulename = new IdentifierTerminal("newrulename", "-_", null);
//var comment1 = new CommentTerminal("comment", "/*", "*/");
var comment = new CommentTerminal("comment", ";", "\n");
var bindig1 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly);
var bindig2 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly);
var hexdig1 = new NumberLiteral("hexdig", NumberOptions.Hex | NumberOptions.IntOnly);
var hexdig2 = new NumberLiteralEx("hexdig", NumberOptions.Hex | NumberOptions.IntOnly);
var decdig1 = new NumberLiteral("decvalue", NumberOptions.IntOnly);
var decdig2 = new NumberLiteral("decvalue", NumberOptions.IntOnly);
var charval = new StringLiteral("charval", "\"", StringOptions.NoEscapes);
var repeat1 = new NumberLiteral("repeat1", NumberOptions.IntOnly | NumberOptions.AllowLetterAfter);
var repeat2 = new NumberLiteral("repeat2", NumberOptions.IntOnly | NumberOptions.AllowLetterAfter);
var minus = ToTerm("-", "minus");
var point = ToTerm(".", "point");
bindig1.AddPrefix("b", NumberOptions.None);
hexdig1.AddPrefix("x", NumberOptions.None);
decdig1.AddPrefix("d", NumberOptions.None);
//base.NonGrammarTerminals.Add(comment1);
base.NonGrammarTerminals.Add(comment);
// NON TERMINALS
var numval = new NonTerminal("numval");
var hexval = new NonTerminal("hexval");
var hexvalp = new NonTerminal("hexvalpoint");
var hexvalps = new NonTerminal("hexvalpointstar");
var binval = new NonTerminal("binval");
var binvalp = new NonTerminal("binvalpoint");
var binvalps = new NonTerminal("binvalpointstar");
var decval = new NonTerminal("decval");
var decvalp = new NonTerminal("decvalpoint");
var decvalps = new NonTerminal("decvalpointstar");
var rule = new NonTerminal("rule");
var rulelist = new NonTerminal("rulelist");
var alternation = new NonTerminal("alternation");
var concatenation = new NonTerminal("concatenation");
var subtraction = new NonTerminal("subtraction");
var repetition = new NonTerminal("repetition");
var repeat = new NonTerminal("repeat");
var element = new NonTerminal("element");
var elements = new NonTerminal("elements");
var group = new NonTerminal("group");
var option = new NonTerminal("option");
var func = new NonTerminal("func");
var funcarg = new NonTerminal("funcarg");
var funcargs = new NonTerminal("funcargs");
// RULES
hexval.Rule = hexdig1 + (hexvalps | (minus + hexdig2) | Empty);
hexvalp.Rule = point + hexdig2;
hexvalps.Rule = MakePlusRule(hexvalps, hexvalp);
binval.Rule = bindig1 + (binvalps | (minus + bindig2) | Empty);
binvalp.Rule = point + bindig2;
binvalps.Rule = MakePlusRule(binvalps, binvalp);
decval.Rule = decdig1 + (decvalps | (minus + decdig2) | Empty);
decvalp.Rule = point + decdig2;
decvalps.Rule = MakePlusRule(decvalps, decvalp);
numval.Rule = ToTerm("%") + (binval | hexval | decval);
BnfExpression rp = ToTerm("*");
if (mode == Mode.HttpCompatible)
rp = rp | "#";
repeat.Rule = ((repeat1) | ((repeat1 | Empty) + rp + (repeat2 | Empty)));
group.Rule = ToTerm("(") + alternation + ")";
option.Rule = ToTerm("[") + alternation + "]";
funcarg.Rule = alternation;
funcargs.Rule = MakePlusRule(funcargs, ToTerm(","), funcarg);
func.Rule = ToTerm("{") + funcname + "," + funcargs + "}";
alternation.Rule = MakePlusRule(alternation, ToTerm(alternationChar), subtraction);
subtraction.Rule = MakePlusRule(subtraction, ToTerm("&!"), concatenation);
concatenation.Rule = MakePlusRule(concatenation, repetition);
repetition.Rule = (Empty | repeat) + element;
element.Rule = rulename | group | option | numval | charval | func;
elements.Rule = alternation;
rule.Rule = NewLineStar + newrulename + (ToTerm("=") | ToTerm("=" + alternationChar)) + elements + NewLinePlus;
rulelist.Rule = MakeStarRule(rulelist, rule);
base.Root = rulelist;
}
// About exponent symbols, extract from R6RS:
// ... representations of number objects may be written with an exponent marker that indicates the desired precision
// of the inexact representation. The letters s, f, d, and l specify the use of short, single, double, and long precision, respectively.
// ...
// In addition, the exponent marker e specifies the default precision for the implementation. The default precision
// has at least as much precision as double, but implementations may wish to allow this default to be set by the user.
public static NumberLiteral CreateSchemeNumber(string name) {
NumberLiteral term = new NumberLiteral(name);
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
term.DefaultFloatType = TypeCode.Double; // it is default
term.AddExponentSymbols("eE", TypeCode.Double); //default precision for platform, double
term.AddExponentSymbols("sSfF", TypeCode.Single);
term.AddExponentSymbols("dDlL", TypeCode.Double);
term.AddPrefix("#b", NumberOptions.Binary);
term.AddPrefix("#o", NumberOptions.Octal);
term.AddPrefix("#x", NumberOptions.Hex);
term.AddPrefix("#d", NumberOptions.None);
term.AddPrefix("#i", NumberOptions.None); // inexact prefix, has no effect
term.AddPrefix("#e", NumberOptions.None); // exact prefix, has no effect
term.AddSuffix("J", NumberLiteral.TypeCodeImaginary);
return term;
}
public NotchianGrammar()
: base(caseSensitive:false)
{
#region parser settings
this.UsesNewLine = true;
#endregion
#region symbols
var directive = new IdentifierTerminal("directive");
directive.AllFirstChars = ".";
var label = new IdentifierTerminal("label", IdOptions.IsNotKeyword);
label.AllFirstChars = ":";
var symbol = new IdentifierTerminal("symbol", IdOptions.IsNotKeyword);
var character_string = new StringLiteral("character_string", "\"");
var literal = new NumberLiteral("literal", NumberOptions.IntOnly);
literal.AddPrefix("0x", NumberOptions.Hex);
literal.AddPrefix("0b", NumberOptions.Binary);
var comment = new CommentTerminal("comment", ";", "\n", "\r", "\r\n");
NonGrammarTerminals.Add(comment);
var program = new NonTerminal("program");
var statement_list = new NonTerminal("statement_list");
var statement_list_cont = new NonTerminal("statement_list_cont");
var statement = new NonTerminal("statement");
var labelled_instruction = new NonTerminal("labelled_instruction");
var label_opt = new NonTerminal("label_opt");
var instruction = new NonTerminal("instruction");
var basic = new NonTerminal("basic_instruction");
var nonbasic = new NonTerminal("nonbasic_instruction");
var data = new NonTerminal("data");
var data_list = new NonTerminal("data_list");
var datum = new NonTerminal("datum");
var basic_opcode = new NonTerminal("basic_opcode");
var nonbasic_opcode = new NonTerminal("nonbasic_opcode");
var value = new NonTerminal("value");
var register = new NonTerminal("register");
var counter = new NonTerminal("register");
var synonym = new NonTerminal("synonym");
var address = new NonTerminal("address");
var pointer = new NonTerminal("pointer");
var target = new NonTerminal("target");
var indirection = new NonTerminal("indirection");
var offset = new NonTerminal("offset");
#endregion symbols
#region parser settings
this.UsesNewLine = true;
this.Root = program;
#endregion
#region grammar rules
//basic structure
program.Rule = statement_list + Eof;
statement_list.Rule = statement + statement_list_cont | Empty;
statement_list_cont.Rule = NewLine + statement_list;
statement.Rule = directive | label | labelled_instruction | Empty;
//lines and labels
labelled_instruction.Rule = label_opt + instruction;
label_opt.Rule = label | Empty;
//instructions
instruction.Rule = basic | nonbasic | data;
basic.Rule = basic_opcode + value + "," + value;
nonbasic.Rule = nonbasic_opcode + value;
//data
data.Rule = ToTerm("DAT") + data_list;
data_list.Rule = MakeListRule(data_list, ToTerm(","), datum, TermListOptions.PlusList);
datum.Rule = literal | character_string;
//opcodes
basic_opcode.Rule = ToTerm("SET") | "ADD" | "SUB" | "MUL" | "DIV" | "MOD" | "SHL" | "SHR" | "AND" | "BOR" | "XOR" | "IFE" | "IFN" | "IFG" | "IFB";
nonbasic_opcode.Rule = ToTerm("JSR");
//values
value.Rule = literal | register | counter | synonym | address;
register.Rule = ToTerm("A") | "B" | "C" | "X" | "Y" | "Z" | "I" | "J";
counter.Rule = ToTerm("SP") | "PC" | "O";
synonym.Rule = ToTerm("POP") | "PEEK" | "PUSH";
address.Rule = pointer | symbol;
pointer.Rule = ToTerm("[") + target + ToTerm("]");
target.Rule = literal | register | indirection;
indirection.Rule = (register + ToTerm("+") + offset) | (offset + ToTerm("+") + register);
offset.Rule = literal | symbol;
this.Root = program;
#endregion
}
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;
}
public static NumberLiteral CreateDasmNumber(string name, Options options)
{
var lit = new NumberLiteral(name,
(options.SignedNumbers ? NumberOptions.AllowSign : 0)
| (options.UnderscoreInNumbers ? NumberOptions.AllowUnderscore : 0)
| NumberOptions.IntOnly | NumberOptions.NoDotAfterInt);
lit.DefaultIntTypes = new TypeCode[] { TypeCode.UInt16, TypeCode.Int16 };
if (options.BinaryLiterals)
lit.AddPrefix("0b", NumberOptions.Binary);
lit.AddPrefix("0x", NumberOptions.Hex);
return lit;
}
public XbnfGrammar(Mode mode)
{
this.mode = mode;
var alternationChar = (mode == Mode.Strict) ? "/" : "|";
var rulename = new IdentifierTerminal("rulename", "-_", null);
var funcname = new IdentifierTerminal("funcname", ".", null);
var newrulename = new IdentifierTerminal("newrulename", "-_", null);
var comment = new CommentTerminal("comment", "/*", "*/");
var bindig1 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly);
var bindig2 = new NumberLiteral("bindig", NumberOptions.Binary | NumberOptions.IntOnly);
var hexdig1 = new NumberLiteral("hexdig", NumberOptions.Hex | NumberOptions.IntOnly);
var hexdig2 = new NumberLiteral("hexdig", NumberOptions.Hex | NumberOptions.IntOnly);
var decdig1 = new NumberLiteral("decvalue", NumberOptions.IntOnly);
var decdig2 = new NumberLiteral("decvalue", NumberOptions.IntOnly);
var charval = new StringLiteral("charval", "\"", StringOptions.NoEscapes);
var repeat1 = new NumberLiteral("repeat1", NumberOptions.IntOnly);
var repeat2 = new NumberLiteral("repeat2", NumberOptions.IntOnly);
var minus = ToTerm("-", "minus");
var point = ToTerm(".", "point");
bindig1.AddPrefix("b", NumberOptions.None);
hexdig1.AddPrefix("x", NumberOptions.None);
decdig1.AddPrefix("d", NumberOptions.None);
base.NonGrammarTerminals.Add(comment);
// NON TERMINALS
var numval = new NonTerminal("numval");
var hexval = new NonTerminal("hexval");
var hexvalp = new NonTerminal("hexvalpoint");
var hexvalps = new NonTerminal("hexvalpointstar");
var binval = new NonTerminal("binval");
var binvalp = new NonTerminal("binvalpoint");
var binvalps = new NonTerminal("binvalpointstar");
var decval = new NonTerminal("decval");
var decvalp = new NonTerminal("decvalpoint");
var decvalps = new NonTerminal("decvalpointstar");
var rule = new NonTerminal("rule");
var rulelist = new NonTerminal("rulelist");
var alternation = new NonTerminal("alternation");
var concatenation = new NonTerminal("concatenation");
var substraction = new NonTerminal("substraction");
var repetition = new NonTerminal("repetition");
var repeat = new NonTerminal("repeat");
var element = new NonTerminal("element");
var elements = new NonTerminal("elements");
var group = new NonTerminal("group");
var option = new NonTerminal("option");
var func = new NonTerminal("func");
var funcarg = new NonTerminal("funcarg");
var funcargs = new NonTerminal("funcargs");
// RULES
hexval.Rule = hexdig1 + (hexvalps | (minus + hexdig2) | Empty);
hexvalp.Rule = point + hexdig2;
hexvalps.Rule = MakePlusRule(hexvalps, hexvalp);
binval.Rule = bindig1 + (binvalps | (minus + bindig2) | Empty);
binvalp.Rule = point + bindig2;
binvalps.Rule = MakePlusRule(binvalps, binvalp);
decval.Rule = decdig1 + (decvalps | (minus + decdig2) | Empty);
decvalp.Rule = point + decdig2;
decvalps.Rule = MakePlusRule(decvalps, decvalp);
numval.Rule = ToTerm("%") + (binval | hexval | decval);
BnfExpression rp = ToTerm("*");
if (mode == Mode.HttpCompatible)
{
rp = rp | "#";
}
repeat.Rule = ((repeat1) | ((repeat1 | Empty) + rp + (repeat2 | Empty)));
group.Rule = ToTerm("(") + alternation + ")";
option.Rule = ToTerm("[") + alternation + "]";
funcarg.Rule = alternation;
funcargs.Rule = MakePlusRule(funcargs, ToTerm(","), funcarg);
func.Rule = ToTerm("{") + funcname + "," + funcargs + "}";
//alternation.Rule = MakePlusRule(alternation, ToTerm(alternationChar), concatenation);
//concatenation.Rule = MakePlusRule(concatenation, repetition);
alternation.Rule = MakePlusRule(alternation, ToTerm(alternationChar), substraction);
substraction.Rule = MakePlusRule(substraction, ToTerm("&!"), concatenation);
//concatenation + ((ToTerm("--") + concatenation) | Empty);
concatenation.Rule = MakePlusRule(concatenation, repetition);
repetition.Rule = (Empty | repeat) + element;
element.Rule = rulename | group | option | numval | charval | func;
elements.Rule = alternation;
rule.Rule = newrulename + (ToTerm("=") | ToTerm("=" + alternationChar)) + elements + ";";
rulelist.Rule = MakeStarRule(rulelist, rule);
base.Root = rulelist;
base.LanguageFlags |= LanguageFlags.CanRunSample;
}
public DemoGrammar() : base(false) // true means case sensitive
{
GrammarComments = @"A Demo Language. Case-insensitive.";
//comment
CommentTerminal eolComment = new CommentTerminal("eolComment", "//", "\n", "\r");
NonGrammarTerminals.Add(eolComment);
//number
NumberLiteral integer_terminal = new NumberLiteral("integer", NumberOptions.IntOnly | NumberOptions.AllowSign, typeof(IntegerAstNode));
integer_terminal.DefaultIntTypes = new TypeCode[] { TypeCode.Int32 };
integer_terminal.AddPrefix("0b", NumberOptions.Binary);
integer_terminal.AddPrefix("0x", NumberOptions.Hex);
//label
IdentifierTerminal label_terminal = new IdentifierTerminal("label_terminal");
//string
StringLiteral string_terminal = new StringLiteral("string", "\"", StringOptions.None, typeof(StringAstNode));
//keywords
KeyTerm FILTERS = ToTerm("filters");
KeyTerm FILTER = ToTerm("filter");
KeyTerm OPEN = ToTerm("[");
KeyTerm CLOSE = ToTerm("]");
//name
NonTerminal name = new NonTerminal("name", typeof(NameAstNode));
name.Rule = label_terminal;
//value
NonTerminal value = new NonTerminal("value");
value.Rule = integer_terminal | string_terminal;
//nvPair
NonTerminal nvPair = new NonTerminal("nvPair", typeof(NvPairAstNode));
nvPair.Rule = name + "=" + value + ";"; //note: you don't have to excplitly declare KeyTerms
//nvPairs
NonTerminal nvPairs = new NonTerminal("nvPairs");
nvPairs.Rule = MakeStarRule(nvPairs, nvPair);
//filter
NonTerminal filter = new NonTerminal("filter", typeof(FilterAstNode));
filter.Rule = FILTER + OPEN + nvPairs + CLOSE;
//filters
NonTerminal filters = new NonTerminal("filters");
filters.Rule = MakeStarRule(filters, filter);
//file
NonTerminal file = new NonTerminal("file", typeof(FileAstNode));
file.Rule = FILTERS + OPEN + filters + CLOSE;
Root = file;
LanguageFlags |= LanguageFlags.CreateAst;
}
public Language()
{
var singleLineComment = new CommentTerminal("Comment", "--", "\r", "\n", "\u2085", "\u2028", "\u2029");
var multilineComment = new LuaLongCommentTerminal("Comment");
var normalString = new LuaStringLiteral("String");
var number = new NumberLiteral("Number", NumberOptions.AllowStartEndDot);
number.AddPrefix("0x", NumberOptions.Hex);
number.AddExponentSymbols("eE", TypeCode.Double);
number.DefaultIntTypes = new TypeCode[] { TypeCode.Double };
number.DefaultFloatType = TypeCode.Double;
var name = new IdentifierTerminal("Name");
var nil = new KeyTerm("nil", "Nil");
var @true = new KeyTerm("true", "True");
var @false = new KeyTerm("false", "False");
var namelist = new NonTerminal("NameList");
var chunk = new NonTerminal("Chunk");
var block = new NonTerminal("Block");
var stat = new NonTerminal("Statement");
var retstat = new NonTerminal("Return");
var label = new NonTerminal("Label");
var funcname = new NonTerminal("FunctionName");
var funcname_normal = new NonTerminal("FunctionName_Normal");
var funcname_self = new NonTerminal("FunctionName_Self");
var variables = new NonTerminal("Variables");
var variable = new NonTerminal("Variable");
var property = new NonTerminal("Property");
var index = new NonTerminal("Index");
var explist = new NonTerminal("ExpressionList");
var expression = new NonTerminal("Expression");
var binop = new NonTerminal("BinaryOperation");
var binoperator = new NonTerminal("BinaryOperator");
var unop = new NonTerminal("UnaryOperation");
var unoperator = new NonTerminal("UnaryOperator");
var functiondef = new NonTerminal("FunctionDefinition");
var tableconstructor = new NonTerminal("TableConstructor");
var functioncall = new NonTerminal("FunctionCall");
var args = new NonTerminal("Arguments");
var funcbody = new NonTerminal("FunctionBody");
var parlist = new NonTerminal("ParameterList");
var field = new NonTerminal("Field");
var fieldsep = new NonTerminal("FieldSeperator");
var fieldlist = new NonTerminal("FieldList");
var global_assignment = new NonTerminal("GlobalAssignment");
var local_assignment = new NonTerminal("LocalAssignment");
var @break = new NonTerminal("Break");
var @goto = new NonTerminal("Goto");
var scope = new NonTerminal("Scope");
var forLoopEnumerable = new NonTerminal("ForLoop_Enumerable");
var forLoopIterable = new NonTerminal("ForLoop_Iterable");
var whileLoop = new NonTerminal("WhileLoop");
var repeatLoop = new NonTerminal("RepeatLoop");
var ifStatement = new NonTerminal("IfStatement");
var elseifStatement = new NonTerminal("ElseIfStatement");
var elseifStatements = new NonTerminal("ElseIfStatements");
var elseStatement = new NonTerminal("ElseStatement");
var globalFunction = new NonTerminal("GlobalFunction");
var localFunction = new NonTerminal("LocalFunction");
var @return = new NonTerminal("ReturnStatement");
var assignmentValues = new NonTerminal("AssignmentValues");
var localAssignmentValues = new NonTerminal("LocalAssignmentValues");
var functioncall_normal = new NonTerminal("FunctionCall_Normal");
var functioncall_instance = new NonTerminal("FunctionCall_Instance");
MarkTransient(expression, stat, localAssignmentValues, binoperator, unoperator, assignmentValues, chunk);
MarkMemberSelect(".", ":", "[");
MarkReservedWords("if", "for", "while", "repeat", "do", "end", "break", "return", "local", "function", "false", "true", "nil");
MarkPunctuation("=", "'", "\"", ".", ":", "::", "[", "]", "(", ")", "return", "if", "for", "then", "else", "elseif", "while", "repeat", "do", "end", "local", "function", "goto");
RegisterBracePair("[", "]");
RegisterBracePair("[[", "]]");
RegisterBracePair("[=[", "]=]");
RegisterBracePair("[==[", "]==]");
RegisterBracePair("[===[", "]===]");
RegisterBracePair("{", "}");
RegisterBracePair("(", ")");
chunk.Rule = block;
block.Rule = MakeStarRule(block, stat);
stat.Rule = ToTerm(";")
| global_assignment
| local_assignment
| functioncall
| label
| @break
| @goto
| scope
| forLoopEnumerable
| forLoopIterable
| whileLoop
| repeatLoop
| ifStatement
| globalFunction
| localFunction
| retstat
| singleLineComment
| multilineComment
;
assignmentValues.Rule = ToTerm("=") + explist;
localAssignmentValues.Rule = ToTerm("=") + explist | Empty;
global_assignment.Rule = variables + assignmentValues;
local_assignment.Rule = ToTerm("local") + variables + localAssignmentValues;
@break.Rule = ToTerm("break");
@goto.Rule = ToTerm("goto") + name;
scope.Rule = ToTerm("do") + block + "end";
forLoopIterable.Rule = ToTerm("for") + name + "=" + expression + "," + expression + ("," + expression).Q() + "do" + block + "end";
forLoopEnumerable.Rule = ToTerm("for") + variables + "in" + explist + "do" + block + "end";
whileLoop.Rule = ToTerm("while") + expression + "do" + block + "end";
repeatLoop.Rule = ToTerm("repeat") + block + "until" + expression;
ifStatement.Rule = ToTerm("if") + expression + "then" + block + elseifStatements + elseStatement + "end";
elseifStatement.Rule = ToTerm("elseif") + expression + "then" + block;
elseifStatements.Rule = MakeStarRule(elseifStatements, elseifStatement);
elseStatement.Rule = "else" + block | Empty;
globalFunction.Rule = ToTerm("function") + funcname + funcbody;
localFunction.Rule = ToTerm("local") + "function" + name + funcbody;
retstat.Rule = ToTerm("return") + explist;
label.Rule = ToTerm("::") + name + "::";
namelist.Rule = MakePlusRule(namelist, ToTerm(","), name);
funcname.Rule = funcname_normal | funcname_self;
funcname_normal.Rule = MakePlusRule(funcname_normal, ToTerm("."), name);
funcname_self.Rule = funcname + ":" + name;
explist.Rule = MakeListRule(explist, ToTerm(","), expression, TermListOptions.StarList);
expression.Rule = PreferShiftHere() + nil
| @true
| @false
| number
| variable
| functioncall
| normalString
| "..."
| functiondef
| tableconstructor
| binop
| unop;
expression.ErrorAlias = "valid expression";
functioncall.Rule = functioncall_normal | functioncall_instance;
//LALR supporting prefixes
variables.Rule = MakeListRule(variables, ToTerm(","), variable, TermListOptions.PlusList);
property.Rule = variable + "." + name | functioncall + "." + name;
index.Rule = variable + "[" + expression + "]" | functioncall + "[" + expression + "]";
variable.Rule = name | property | index | "(" + expression + ")";
functioncall_instance.Rule = variable + ":" + name + args | functioncall + ":" + name + args;
functioncall_normal.Rule = variable + args | functioncall + args;
args.Rule = ToTerm("(") + explist + ")" | tableconstructor | normalString;
functiondef.Rule = ToTerm("function") + funcbody;
funcbody.Rule = ToTerm("(") + parlist + ")" + block + "end";
parlist.Rule = namelist | namelist + "," + "..." | "..." | Empty;
tableconstructor.Rule = ToTerm("{") + fieldlist + "}";
fieldsep.Rule = ToTerm(",") | ";";
//WARNING: Doesn't allow trailing delimiter ( { field1, field2, } )
fieldlist.Rule = MakeListRule(fieldlist, fieldsep, field, TermListOptions.StarList | TermListOptions.AddPreferShiftHint);
field.Rule = (ToTerm("[") + expression + "]" + "=" + expression) | (name + "=" + expression) | expression;
var binMinus = ToTerm("-");
var unMinus = ToTerm("-");
binoperator.Rule = ToTerm("+") | binMinus | "*" | "/" | "^" | "%" | ".." | "<" | "<=" | ">" | ">=" | "==" | "~=" | "and" | "or";
unoperator.Rule = unMinus | "#" | "not";
unoperator.SetFlag(TermFlags.IsOperator);
binoperator.SetFlag(TermFlags.IsOperator);
RegisterOperators(5, Associativity.Left, "^", "%", "..");
RegisterOperators(4, Associativity.Left, "/");
RegisterOperators(2, Associativity.Left, "*");
RegisterOperators(2, Associativity.Right, unMinus);
RegisterOperators(1, Associativity.Left, "+");
RegisterOperators(0, Associativity.Left, binMinus);
RegisterOperators(-1, Associativity.Left, "<", "<=", ">", ">=", "==", "~=", "and", "or");
binop.Rule = expression + binoperator + expression;
unop.Rule = ReduceHere() + unoperator + expression;
this.Root = chunk;
}
// Constructor
public GraphQLGrammar() : base(caseSensitive: true)
{
// special chars
var comma = ToTerm(",", "comma");
NonGrammarTerminals.Add(comma); //comma is ignored in GraphQL, just like comments
var colon = ToTerm(":", "colon");
var excl = ToTerm("!");
var pipe = ToTerm("|");
var pipeOpt = new NonTerminal("pipeOpt", Empty | pipe);
var amp = ToTerm("&");
var ampOpt = new NonTerminal("ampOpt", Empty | amp);
var ellipsis = ToTerm("...");
var extend = ToTerm("extend");
// comments
var lineTerminators = new string[] { "\r", "\n", "\u2085", "\u2028", "\u2029" };
var comment = new CommentTerminal("comment", "#", lineTerminators);
this.NonGrammarTerminals.Add(comment);
//terminals
var number = new NumberLiteral(TermNames.Number, NumberOptions.AllowSign);
number.AddPrefix("0x", NumberOptions.Hex); //allow hex
var tripleQt = "\"\"\"";
var strSimple = new StringLiteral(TermNames.StrSimple, "\"", StringOptions.AllowsUEscapes);
var strBlock = new StringLiteral(TermNames.StrBlock, tripleQt, StringOptions.AllowsLineBreak | StringOptions.AllowsUEscapes);
var str = new NonTerminal("str", strSimple | strBlock);
var qStr = new StringLiteral(TermNames.Qstr, "'"); //used by custom scalars: Datetime, Uuid, etc
var nullVal = ToTerm("null", TermNames.NullValue);
var name = new IdentifierTerminal(TermNames.Name);
var varName = new IdentifierTerminal(TermNames.VarName);
varName.AllFirstChars = "$";
var dirName = new IdentifierTerminal("dirName");
dirName.AllFirstChars = "@";
//non-terminals
SchemaDocRoot = new NonTerminal("schemaDoc");
var def = new NonTerminal("def");
var typeSystemDef = new NonTerminal("typeSystemDef");
var typeSysExt = new NonTerminal("typeSysExt");
var schemaDef = new NonTerminal("schemaDef");
var dirDef = new NonTerminal("dirDef");
var schemaExt = new NonTerminal("schemaExt");
var rootOpDefList = new NonTerminal("rootOpDefList");
var rootOpDef = new NonTerminal("rootOpDef");
var requestOp = new NonTerminal(TermNames.RequestOp);
var fragmDef = new NonTerminal(TermNames.FragmDef);
var typeCond = new NonTerminal(TermNames.TypeCond);
var typeCondOpt = new NonTerminal("typeCondOpt");
var typeDef = new NonTerminal("typeDef");
var scalarTypeDef = new NonTerminal("scalarTypeDef");
var objTypeDef = new NonTerminal("objTypeDef");
var intfTypeDef = new NonTerminal("intfTypeDef");
var unionTypeDef = new NonTerminal("unionTypeDef");
var enumTypeDef = new NonTerminal("enumTypeDef");
var opTypeDef = new NonTerminal("opTypeDef");
var opTypeDefList = new NonTerminal("opTypeDefList");
var inputObjTypeDef = new NonTerminal("inputObjTypeDef");
var descrOpt = new NonTerminal(TermNames.DescrOpt, Empty | str);
var argDefList = new NonTerminal("argDefList");
var inputValueDef = new NonTerminal("inputValueDef");
var listTypeRef = new NonTerminal(TermNames.ListTypeRef);
var dirLoc = new NonTerminal("dirLoc");
var execDirLoc = new NonTerminal("execDirLoc");
var typeDirLoc = new NonTerminal("typeDirLoc");
var implsIntfsOpt = new NonTerminal("implsIntfsOpt");
var fldsDefOpt = new NonTerminal("fldsDefOpt");
var fldDefList = new NonTerminal("fldDefList");
var fldDef = new NonTerminal("fldDef");
var intfList = new NonTerminal("intfList");
var unionMemberTypes = new NonTerminal("unionMemberTypes");
var unionList = new NonTerminal("unionList");
var enumValDefsOpt = new NonTerminal("enumValDefsOpt");
var enumValDefList = new NonTerminal("enumValDefList");
var enumValDef = new NonTerminal("enumValDef");
var inputFldDefsOpt = new NonTerminal("inputFldDefsOpt");
var inputFldDefList = new NonTerminal("inputFldDefList");
var inputFldDef = new NonTerminal("inputFldDef");
var fragmSpread = new NonTerminal(TermNames.FragmSpread);
var inlineFragm = new NonTerminal(TermNames.InlineFragm);
var argDefsOpt = new NonTerminal("argDefsOpt");
var dirLocs = new NonTerminal("dirLocs");
var typeExt = new NonTerminal("typeExt");
var opType = new NonTerminal(TermNames.OpType);
var nameOpt = new NonTerminal("nameopt", name | Empty);
var typeRef = new NonTerminal("typeRef");
var dftValueOpt = new NonTerminal("dftValueOpt");
var constVal = new NonTerminal("constVal");
var val = new NonTerminal("val");
var arg = new NonTerminal("arg");
var argListOpt = new NonTerminal(TermNames.ArgListOpt);
var argsOpt = new NonTerminal("argsOpt");
var constListBr = new NonTerminal("constListBr");
var constList = new NonTerminal(TermNames.ConstList);
var constInpObj = new NonTerminal(TermNames.ConstInpObj);
var constInpObjFldList = new NonTerminal("constInpObjFldList");
var constObjFld = new NonTerminal("constObjFld");
var notNullTypeRef = new NonTerminal(TermNames.NotNullTypeRef);
var nullTypeRef = new NonTerminal("nullTypeRef");
var baseTypeRef = new NonTerminal(TermNames.BaseTypeRef);
var trueVal = ToTerm("true", TermNames.True);
var falseVal = ToTerm("false", TermNames.False);
var boolVal = new NonTerminal("boolVal", trueVal | falseVal);
var varDef = new NonTerminal("varDef");
var varDefList = new NonTerminal(TermNames.VarDefList);
var varDefsOpt = new NonTerminal("varDefsOpt");
var selSet = new NonTerminal(TermNames.SelSet);
var selSetBr = new NonTerminal("selSetBr");
var selSetOpt = new NonTerminal("selSetOpt");
var selItem = new NonTerminal("selItem");
var selFld = new NonTerminal(TermNames.SelField);
var aliasedName = new NonTerminal(TermNames.AliasedName);
var dir = new NonTerminal("dir");
var dirListOpt = new NonTerminal(TermNames.DirListOpt);
var scalarTypeExt = new NonTerminal("scalarTypeExt");
var objTypeExt = new NonTerminal("objTypeExt");
var intfTypeExt = new NonTerminal("intfTypeExt");
var unionTypeExt = new NonTerminal("unionTypeExt");
var enumTypeExt = new NonTerminal("enumTypeExt");
var inputObjTypeExt = new NonTerminal("inputObjTypeExt");
var defaultQuery = new NonTerminal(TermNames.DefaultQuery);
var defs = new NonTerminal("defs");
var reqElem = new NonTerminal("reqElem");
var reqElemList = new NonTerminal(TermNames.RequestElemList);
RequestDocRoot = new NonTerminal(TermNames.RequestDoc);
// RULES =========================================================================================
/*
* According to spec, a request can contain either a single default (anonymous) query, or one or more named operations.
* We could structure the grammar so that it forces this at syntax level, but the problem is unclear error messages
* like 'unexpected symbol' at open brace, and no easy way to improve it.
* So we structure the grammar to allow multiple default queries, and then catch the error at AST phase.
*/
// Request Document
RequestDocRoot.Rule = reqElemList;
reqElemList.Rule = MakePlusRule(reqElemList, reqElem);
reqElem.Rule = requestOp | fragmDef | defaultQuery;
requestOp.Rule = descrOpt + opType + nameOpt + varDefsOpt + dirListOpt + selSetBr;
defaultQuery.Rule = selSetBr;
// Schema doc
SchemaDocRoot.Rule = defs;
defs.Rule = MakePlusRule(defs, def);
def.Rule = requestOp | fragmDef | typeSystemDef | typeSysExt;
typeSystemDef.Rule = schemaDef | typeDef | dirDef;
typeSysExt.Rule = schemaExt | typeExt;
//schemaDef
schemaDef.Rule = descrOpt + "schema" + dirListOpt + "{" + rootOpDefList + "}";
rootOpDefList.Rule = MakePlusRule(rootOpDefList, rootOpDef);
rootOpDef.Rule = descrOpt + opType + colon + name;
// opDef
opType.Rule = ToTerm("query") | "mutation" | "subscription";
//typeDef
typeDef.Rule = scalarTypeDef | objTypeDef | intfTypeDef | unionTypeDef | enumTypeDef | inputObjTypeDef;
scalarTypeDef.Rule = descrOpt + "scalar" + name + dirListOpt;
objTypeDef.Rule = descrOpt + "type" + name + implsIntfsOpt + dirListOpt + fldsDefOpt;
intfTypeDef.Rule = descrOpt + "interface" + name + dirListOpt + fldsDefOpt;
unionTypeDef.Rule = descrOpt + "union" + name + dirListOpt + unionMemberTypes;
enumTypeDef.Rule = descrOpt + "enum" + name + dirListOpt + enumValDefsOpt;
inputObjTypeDef.Rule = descrOpt + "input" + name + dirListOpt + inputFldDefsOpt;
// union members
unionMemberTypes.Rule = Empty | "=" + pipeOpt + unionList;
unionList.Rule = MakePlusRule(unionList, pipe, name);
//fragmDef
fragmDef.Rule = descrOpt + "fragment" + name + typeCond + dirListOpt + selSetBr;
// name should NOT be 'on' - we make it reserved word
//typeCond
typeCond.Rule = "on" + name;
// this is intentional (not typeCond); some specifics of AST Builder; maybe refactor it in the future, looks silly
typeCondOpt.Rule = Empty | "on" + name;
// enum members
enumValDefsOpt.Rule = Empty | "{" + enumValDefList + "}";
enumValDefList.Rule = MakePlusRule(enumValDefList, enumValDef);
enumValDef.Rule = descrOpt + name + dirListOpt;
// implements clause
implsIntfsOpt.Rule = Empty | "implements" + ampOpt + intfList;
intfList.Rule = MakePlusRule(intfList, amp, name);
// inputFldDefs
inputFldDefsOpt.Rule = Empty | "{" + inputFldDefList + "}";
inputFldDefList.Rule = MakePlusRule(inputFldDefList, inputFldDef);
inputFldDef.Rule = descrOpt + name + colon + typeRef + dftValueOpt + dirListOpt;
// fields
fldsDefOpt.Rule = Empty | "{" + fldDefList + "}";
fldDefList.Rule = MakeStarRule(fldDefList, fldDef);
fldDef.Rule = descrOpt + name + argDefsOpt + colon + typeRef + dirListOpt;
selFld.Rule = descrOpt + aliasedName + argsOpt + dirListOpt + selSetOpt;
aliasedName.Rule = name + colon + name | name; //optional alias
//directives
dirDef.Rule = descrOpt + "directive" + dirName + argDefsOpt + "on" + pipeOpt + dirLocs;
argDefsOpt.Rule = Empty | "(" + argDefList + ")";
argDefList.Rule = MakeStarRule(argDefList, inputValueDef);
inputValueDef.Rule = descrOpt + name + colon + typeRef + dftValueOpt + dirListOpt;
dirLocs.Rule = MakeListRule(dirLocs, pipe, dirLoc);
dirLoc.Rule = execDirLoc | typeDirLoc;
execDirLoc.Rule = ToTerm("QUERY") | "MUTATION" | "SUBSCRIPTION" | "FIELD" | "FRAGMENT_DEFINITION" |
"FRAGMENT_SPREAD" | "INLINE_FRAGMENT";
typeDirLoc.Rule = ToTerm("SCHEMA") | "SCALAR" | "OBJECT" | "FIELD_DEFINITION" | "ARGUMENT_DEFINITION" |
"INTERFACE" | "UNION" | "ENUM" | "ENUM_VALUE" | "INPUT_OBJECT" | "INPUT_FIELD_DEFINITION";
dirListOpt.Rule = MakeStarRule(dirListOpt, dir);
dir.Rule = dirName + argsOpt;
// varDefs
varDefsOpt.Rule = Empty | "(" + varDefList + ")";
varDefList.Rule = MakeStarRule(varDefList, varDef);
varDef.Rule = varName + colon + typeRef + dftValueOpt + dirListOpt; //directives for vars added in 2020 draft
dftValueOpt.Rule = Empty | "=" + constVal;
baseTypeRef.Rule = name;
notNullTypeRef.Rule = nullTypeRef + excl;
nullTypeRef.Rule = listTypeRef | baseTypeRef;
typeRef.Rule = baseTypeRef | listTypeRef | notNullTypeRef;
listTypeRef.Rule = "[" + typeRef + "]";
// args
argsOpt.Rule = Empty | "(" + argListOpt + ")";
argListOpt.Rule = MakeStarRule(argListOpt, arg); // might be PLUS according to spec (empty not allowed), but let's be forgiving
arg.Rule = name + colon + val;
// SelectionSet
selSetBr.Rule = "{" + selSet + "}";
selSetOpt.Rule = selSetBr | Empty;
selSet.Rule = MakePlusRule(selSet, selItem);
selItem.Rule = selFld | fragmSpread | inlineFragm;
// fragments
fragmSpread.Rule = ellipsis + name + dirListOpt;
inlineFragm.Rule = ellipsis + typeCondOpt + dirListOpt + selSetBr;
// Value/Literal; 'name' is for enum value
constVal.Rule = number | str | boolVal | nullVal | name | constListBr | constInpObj | qStr;
val.Rule = varName | constVal;
constListBr.Rule = "[" + constList + "]";
constList.Rule = MakeStarRule(constList, val);
constInpObj.Rule = "{" + constInpObjFldList + "}";
constInpObjFldList.Rule = MakePlusRule(constInpObjFldList, constObjFld);
constObjFld.Rule = name + colon + val;
// schemaExt
schemaExt.Rule = extend + "schema" + dirListOpt + "{" + opTypeDefList + "}";
opTypeDefList.Rule = MakePlusRule(opTypeDefList, opTypeDef);
opTypeDef.Rule = opType + colon + name;
// TypeExt
typeExt.Rule = scalarTypeExt | objTypeExt | intfTypeExt | unionTypeExt | enumTypeExt | inputObjTypeExt;
scalarTypeExt.Rule = extend + "scalar" + name + dirListOpt;
objTypeExt.Rule = extend + "type" + name + implsIntfsOpt + dirListOpt + fldsDefOpt;
intfTypeExt.Rule = extend + "interface" + name + dirListOpt + fldsDefOpt;
unionTypeExt.Rule = extend + "union" + name + dirListOpt + unionMemberTypes;
enumTypeExt.Rule = extend + "enum" + name + dirListOpt + enumValDefsOpt;
inputObjTypeExt.Rule = extend + "input" + name + dirListOpt + inputFldDefsOpt;
this.MarkReservedWords("on", "true", "false");
this.RegisterBracePair("(", ")");
this.RegisterBracePair("[", "]");
this.RegisterBracePair("{", "}");
this.MarkPunctuation(":", ",", "{", "}", "(", ")", "[", "]", "=", "!");
this.MarkTransient(varDefsOpt, dftValueOpt, reqElem);
this.MarkTransient(def, typeSystemDef, typeSysExt, typeExt, typeDef, typeRef, fldsDefOpt);
this.MarkTransient(boolVal, str, val, constListBr, nameOpt, descrOpt, nullTypeRef, constVal);
this.MarkTransient(selItem, selSetOpt, selSetBr, argsOpt, dirLoc, dirListOpt);
this.Root = RequestDocRoot;
this.SnippetRoots.Add(SchemaDocRoot); // alt root for schema doc parser
}
public AssemblyGrammar()
{
#region Declare Terminals Here
CommentTerminal blockComment = new CommentTerminal("block-comment", "/*", "*/");
CommentTerminal lineComment = new CommentTerminal("line-comment", "//", "\r", "\n", "\u2085", "\u2028", "\u2029");
//CommentTerminal sharpComment = new CommentTerminal("sharp-comment","#","\r","\n","\u2085","\u2028","\u2029");
NonGrammarTerminals.Add(blockComment);
NonGrammarTerminals.Add(lineComment);
//NonGrammarTerminals.Add(sharpComment);
StringLiteral stringLiteral = new StringLiteral("string-literal", "\"");
StringLiteral charLiteral = new StringLiteral("char-literal", "\'", StringOptions.IsChar);
NumberLiteral number = new NumberLiteral("number", NumberOptions.AllowSign | NumberOptions.IntOnly);
number.AddPrefix("0x", NumberOptions.Hex);
number.AddPrefix("0b", NumberOptions.Binary);
IdentifierTerminal identifier = TerminalFactory.CreateCSharpIdentifier("identifier");
#endregion
#region Declare NonTerminals Here;
NonTerminal fileroot = new NonTerminal("fileroot");
NonTerminal rootdefs = new NonTerminal("root-defines");
NonTerminal rootdef = new NonTerminal("root-define");
NonTerminal usingDesc = new NonTerminal("using-description");
NonTerminal memorySizeDesc = new NonTerminal("memorysize-description");
NonTerminal targetISADesc = new NonTerminal("targetisa-description");
NonTerminal label = new NonTerminal("label");
NonTerminal operandReg = new NonTerminal("operand-register");
NonTerminal operandRef = new NonTerminal("operand-reference");
NonTerminal operandImm = new NonTerminal("operand-immediate");
NonTerminal valueInt = new NonTerminal("value-integer");
NonTerminal valueChar = new NonTerminal("value-character");
NonTerminal valueRefAddr = new NonTerminal("value-referaddress");
NonTerminal labeledStatement = new NonTerminal("labeled-statement");
NonTerminal statement = new NonTerminal("statement");
NonTerminal instr = new NonTerminal("instruction");
NonTerminal instrLabels = new NonTerminal("instruction-labels");
NonTerminal instrNemonic = new NonTerminal("instruction-nemonic");
NonTerminal instrOperands = new NonTerminal("instruction-operands");
NonTerminal instrOperand = new NonTerminal("instruction-operand");
NonTerminal labeledInstrOperand = new NonTerminal("labeled-instruction-operand");
NonTerminal instrJump = new NonTerminal("instruction-jump");
NonTerminal instrJumpNemonic = new NonTerminal("instruction-jump-nemonic");
NonTerminal instrJumpTarget = new NonTerminal("instruction-jump-target");
NonTerminal macrocall = new NonTerminal("macrocall");
NonTerminal macrocallLabels = new NonTerminal("macrocall-labels");
NonTerminal macrocallName = new NonTerminal("macrocall-name");
NonTerminal macrocallOperands = new NonTerminal("macrocall-operands");
NonTerminal macrocallOperand = new NonTerminal("macrocall-operand");
NonTerminal symboldef = new NonTerminal("symboldef");
NonTerminal symboldefName = new NonTerminal("symboldef-name");
NonTerminal symboldefContent = new NonTerminal("symboldef-content");
NonTerminal variabledef = new NonTerminal("variabledef");
NonTerminal variabledefName = new NonTerminal("variabledef-name");
NonTerminal variabledefContents = new NonTerminal("variabledef-contents");
NonTerminal variabledefContent = new NonTerminal("variabledef-content");
NonTerminal variabledefPositionHint = new NonTerminal("variabledef-poshint");
NonTerminal constantdef = new NonTerminal("constantdef");
NonTerminal constantdefName = new NonTerminal("constantdef-name");
NonTerminal constantdefContents = new NonTerminal("constantdef-content");
NonTerminal constantdefContent = new NonTerminal("constantdef-content");
NonTerminal macrodef = new NonTerminal("macrodef");
NonTerminal macrodefArguments = new NonTerminal("macrodef-arguments");
NonTerminal macrodefArgument = new NonTerminal("macrodef-arguments");
NonTerminal macrodefContents = new NonTerminal("macrodef-contents");
NonTerminal macrodefContent = new NonTerminal("macrodef-content");
NonTerminal sectiondef = new NonTerminal("sectiondef");
NonTerminal sectiondefAttributes = new NonTerminal("sectiondef-attributes");
NonTerminal sectiondefAttribute = new NonTerminal("sectiondef-attribute");
NonTerminal sectiondefContents = new NonTerminal("sectiondef-contents");
NonTerminal sectiondefContent = new NonTerminal("sectiondef-content");
NonTerminal blockdef = new NonTerminal("blockdef");
NonTerminal blockdefContents = new NonTerminal("blockdef-contents");
NonTerminal blockdefContent = new NonTerminal("blockdef-content");
NonTerminal debugprint = new NonTerminal("debugprint");
#endregion
#region Place Rules Here
this.Root = fileroot;
fileroot.Rule = rootdefs;
rootdefs.Rule = MakeStarRule(rootdefs, rootdef);
rootdef.Rule = sectiondef
| usingDesc
| memorySizeDesc
| targetISADesc;
usingDesc.Rule = ToTerm("#include") + stringLiteral + ToTerm(";");
memorySizeDesc.Rule = ToTerm("#memorysize") + number + ToTerm(";");
targetISADesc.Rule = ToTerm("#targetisa") + stringLiteral + ToTerm(";");
//Commons
operandImm.Rule = valueInt
| valueChar
| valueRefAddr;
valueInt.Rule = number;
valueChar.Rule = charLiteral;
valueRefAddr.Rule = ToTerm("&") + identifier
| ToTerm("&") + identifier + ToTerm("[") + number + ToTerm("]");
operandRef.Rule = identifier;
operandReg.Rule = ToTerm("$") + number
| ToTerm("$") + identifier;
//Variable
variabledef.Rule = ToTerm(".variable") + variabledefName + ToTerm(";") //With no initial value (these will be grouped into one variable by optimization.)
| ToTerm(".variable") + variabledefName + ToTerm("=") + variabledefContent + ToTerm(";") //With initial value (these will be not grouped.)
| ToTerm(".variable") + variabledefName + ToTerm("[") + number + ToTerm("]") + ToTerm("=") + ToTerm("{") + variabledefContents + ToTerm("}") + ToTerm(";")
| ToTerm(".variable") + variabledefName + variabledefPositionHint + ToTerm(";") //With no initial value (these will be grouped into one variable by optimization.)
| ToTerm(".variable") + variabledefName + variabledefPositionHint + ToTerm("=") + variabledefContent + ToTerm(";") //With initial value (these will be not grouped.)
| ToTerm(".variable") + variabledefName + ToTerm("[") + number + ToTerm("]") + variabledefPositionHint + ToTerm("=") + ToTerm("{") + variabledefContents + ToTerm("}") + ToTerm(";");;
variabledefPositionHint.Rule = ToTerm("(") + ToTerm("@") + number + ToTerm(")");
variabledefName.Rule = identifier;
variabledefContents.Rule = MakeStarRule(variabledefContents, ToTerm(","), variabledefContent);
variabledefContent.Rule = valueInt
| valueChar
| valueRefAddr;
//Constant
constantdef.Rule = ToTerm(".constant") + constantdefName + ToTerm("=") + constantdefContent + ToTerm(";")
| ToTerm(".constant") + constantdefName + ToTerm("[") + number + ToTerm("]") + ToTerm("=") + ToTerm("{") + constantdefContents + ToTerm("}") + ToTerm(";");
constantdefName.Rule = identifier;
constantdefContents.Rule = MakeStarRule(constantdefContents, ToTerm(","), constantdefContent);
constantdefContent.Rule = valueInt
| valueChar
| valueRefAddr;
//Statement instr | callmacro
debugprint.Rule = ToTerm(">>>>") + stringLiteral;
label.Rule = identifier + ToTerm(":");
labeledStatement.Rule = label + labeledStatement
| statement;
statement.Rule = instr
| macrocall;
//Instruction
instr.Rule = instrNemonic + instrOperands + ToTerm(";")
| instrNemonic + instrOperands + ToTerm(";") + debugprint
| instrNemonic + instrOperands + instrJump + ToTerm(";")
| instrNemonic + instrOperands + instrJump + ToTerm(";") + debugprint;
instrNemonic.Rule = identifier;
instrLabels.Rule = MakeStarRule(instrLabels, label);
instrOperands.Rule = MakeStarRule(instrOperands, ToTerm(","), labeledInstrOperand);
labeledInstrOperand.Rule = label + labeledInstrOperand
| instrOperand;
instrOperand.Rule = operandRef
| operandImm
| operandReg;
//Instruction Jump
instrJump.Rule = ToTerm("-<") + instrJumpNemonic + instrJumpTarget;
instrJumpNemonic.Rule = identifier;
instrJumpTarget.Rule = operandRef
| operandImm
| operandReg;
//Macrocall
macrocall.Rule = ToTerm("~") + macrocallName + ToTerm("(") + macrocallOperands + ToTerm(")") + ToTerm(";")
| ToTerm("~") + macrocallName + ToTerm("(") + macrocallOperands + ToTerm(")") + ToTerm(";") + debugprint;
macrocallName.Rule = identifier;
macrocallOperands.Rule = MakeStarRule(macrocallOperands, ToTerm(","), macrocallOperand);
macrocallOperand.Rule = operandRef
| operandImm
| operandReg;
//Macrodefinition
macrodef.Rule = ToTerm("macro") + identifier + ToTerm("(") + macrodefArguments + ToTerm(")") +
ToTerm("{") + macrodefContents + ToTerm("}");
macrodefArguments.Rule = MakeStarRule(macrodefArguments, ToTerm(","), macrodefArgument);
macrodefArgument.Rule = identifier;
macrodefContents.Rule = MakeStarRule(macrodefContents, macrodefContent);
macrodefContent.Rule = blockdef
| labeledStatement
| variabledef
| constantdef
| macrodef;
//Symboldefinition
symboldef.Rule = ToTerm(".symbol") + symboldefName + ToTerm("=") + symboldefContent + ToTerm(";")
| ToTerm(".symbol") + symboldefName + ToTerm(":=") + symboldefContent + ToTerm(";");
symboldefName.Rule = identifier;
symboldefContent.Rule = operandReg
| ToTerm("@") + number
| valueInt
| valueChar
| valueRefAddr;
//Section 属性を設定可能
sectiondef.Rule = ToTerm("section") + identifier + ToTerm("{") + sectiondefAttributes + sectiondefContents + ToTerm("}");
sectiondefAttributes.Rule = MakeStarRule(sectiondefAttributes, sectiondefAttribute);
sectiondefAttribute.Rule = ToTerm(".startup");
sectiondefContents.Rule = MakeStarRule(sectiondefContents, sectiondefContent);
sectiondefContent.Rule = blockdef
| labeledStatement
| variabledef
| constantdef
| symboldef
| macrodef;
//Block ただのスコープ
blockdef.Rule = ToTerm("{") + blockdefContents + ToTerm("}")
| identifier + ToTerm("{") + blockdefContents + ToTerm("}");
blockdefContents.Rule = MakeStarRule(blockdefContents, blockdefContent);
blockdefContent.Rule = blockdef
| labeledStatement
| variabledef
| constantdef
| symboldef
| macrodef;
//セクションで定義された変数や定数・命令は最適化されて好き勝手な場所に配置される．
//デバッグ情報からその変数がどこのセクションで定義され，どこに配置されているかが確認できる
//セクションはその親のセクションを持っている
//ラベルを参照する際にはそのラベルが使用されたセクションから順に上をたどって参照先を検索する
//マクロが展開されるとその中身は新しいブロックの中に展開される
//.startup
//.variable NAME =
//.constant NAME = 0x23a1s,65409
//'srl: rd,rs,rt
//{
//
//}
//
//@ROM
//{
//
//}
#endregion
#region Define Keywords
this.MarkReservedWords("break", "continue", "else", "extern", "for",
"if", "int", "return", "static", "void", "while");
#endregion
}
private void Rebop()
{
GrammarComments = @"This grammar is based on the BNF provided in Appendix E of 'The Official Beboputer Microprocessor Databook' Copyright © 1998, Maxfield & Montrose Interactive Inc.";
//comments
CommentTerminal eolPoundComment = new CommentTerminal("eolComment", "#", "\n", "\r");
NonGrammarTerminals.Add(eolPoundComment);
CommentTerminal eolComment = new CommentTerminal("eolComment", "//", "\n", "\r");
NonGrammarTerminals.Add(eolComment);
CommentTerminal multilineComment = new CommentTerminal("multilineComment", "/*", "*/");
NonGrammarTerminals.Add(multilineComment);
NumberLiteral integer = new NumberLiteral("integer", NumberOptions.IntOnly, typeof(IntegerAstNode));
integer.DefaultIntTypes = new TypeCode[] { TypeCode.Byte, TypeCode.UInt16, TypeCode.UInt32 };
integer.AddPrefix("%", NumberOptions.Binary);
integer.AddPrefix("$", NumberOptions.Hex);
IdentifierTerminal label_terminal = new IdentifierTerminal("label_terminal");
NonTerminal label = new NonTerminal("label", typeof(LabelAstNode));
label.Rule = label_terminal;
NonTerminal integer_ref = new NonTerminal("integer_ref");
integer_ref.Rule = integer | label;
//expressions
//TODO
//mnemonics
NonTerminal mnemonic = new NonTerminal("mnemonic", typeof(MnemonicAstNode));
List <string> instructions = new List <string>();
foreach (var i in Instruction.GetInstructions())
{
if (!instructions.Contains(i.Mnemonic))
{
instructions.Add(i.Mnemonic);
if (mnemonic.Rule == null)
{
mnemonic.Rule = ToTerm(i.Mnemonic);
}
else
{
mnemonic.Rule |= ToTerm(i.Mnemonic);
}
}
}
//operands
NonTerminal imm_operand = new NonTerminal("imm_operand", typeof(ImmOperandAstNode));
imm_operand.Rule = integer_ref;
NonTerminal abs_operand = new NonTerminal("abs_operand", typeof(AbsOperandAstNode));
abs_operand.Rule = "[" + integer_ref + "]";
NonTerminal absx_operand = new NonTerminal("absx_operand", typeof(AbsXOperandAstNode));
absx_operand.Rule = "[" + integer_ref + "," + "X" + "]";
NonTerminal ind_operand = new NonTerminal("ind_operand", typeof(IndOperandAstNode));
ind_operand.Rule = "[" + "[" + integer_ref + "]" + "]";
NonTerminal xind_operand = new NonTerminal("xind_operand", typeof(XIndOperandAstNode));
xind_operand.Rule = "[" + "[" + integer_ref + "," + "X" + "]" + "]";
NonTerminal indx_operand = new NonTerminal("indx_operand", typeof(IndXOperandAstNode));
indx_operand.Rule = "[" + "[" + integer_ref + "]" + "," + "X" + "]";
NonTerminal operand = new NonTerminal("operand");
operand.Rule = imm_operand | abs_operand | absx_operand | ind_operand | xind_operand | indx_operand;
NonTerminal instruction = new NonTerminal("instruction", typeof(InstructionAstNode));
instruction.Rule = ((label + ":") | Empty) + (mnemonic + (operand | Empty));
//directives
NonTerminal origin = new NonTerminal("origin", typeof(OriginAstNode));
origin.Rule = ".org" + integer_ref;
NonTerminal end = new NonTerminal("end", typeof(EndAstNode));
end.Rule = ".end";
NonTerminal declaration = new NonTerminal("declaration", typeof(DeclarationAstNode));
declaration.Rule = ".equ" + integer;
NonTerminal reservation_star = new NonTerminal("reservation_star", typeof(ReservationStarAstNode));
reservation_star.Rule = ((ToTerm(".byte") | ".2byte" | ".4byte")) + "*" + integer_ref;
NonTerminal byte_list_star = new NonTerminal("byte_list_star");
MakeStarRule(byte_list_star, "," + integer);
NonTerminal byte_list = new NonTerminal("byte_list");
byte_list.Rule = integer + byte_list_star;
NonTerminal reservation_init = new NonTerminal("reservation_init", typeof(ReservationInitAstNode));
reservation_init.Rule = (ToTerm(".byte") | ".2byte" | ".4byte") + (byte_list | Empty);
NonTerminal directive = new NonTerminal("directive", typeof(DirectiveAstNode));
directive.Rule = ((label + ":") | Empty) + (origin | end | (reservation_star | reservation_init) | declaration);
//statements
NonTerminal statement = new NonTerminal("statement");
//statement.Rule = NewLineStar + ((label + ":") | Empty) + (instruction| directive) + (NewLinePlus|Eof);
statement.Rule = NewLineStar + (instruction | directive) + (NewLinePlus | Eof);
//file structure
NonTerminal assembly_source_file = new NonTerminal("assembly_source_file", typeof(FileAstNode));
assembly_source_file.Rule = MakeStarRule(assembly_source_file, statement);
Root = assembly_source_file;
LanguageFlags |= LanguageFlags.CreateAst;
}
public LuaGrammar()
: base(true)
{
#region Terminals
var Identifier = new IdentifierTerminal("identifier");
var SingleString = new StringLiteral("string", "'", StringOptions.AllowsAllEscapes);
var DoubleString = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes);
var MultiLineString = new CommentTerminal("string", "[[", "]]");
var Number = new NumberLiteral("number");
Number.DefaultIntTypes = new[] { TypeCode.UInt64, TypeCode.Double };
Number.AddPrefix("0x", NumberOptions.Hex);
var LineComment = new CommentTerminal("Comment", "--", "\n", "\r");
var LongComment = new CommentTerminal("LongComment", "--[[", "]]");
base.NonGrammarTerminals.Add(LineComment);
base.NonGrammarTerminals.Add(LongComment);
#endregion
#region Nonterminals
var Chunk = new NonTerminal("Chunk");
var Prefix = new NonTerminal("Prefix");
var Variable = new NonTerminal("Variable");
var FunctionCall = new NonTerminal("FunctionCall");
var CallArguments = new NonTerminal("FunctionCallArguments");
var OopCall = new NonTerminal("OopCall");
var CallArgumentsFragment = new NonTerminal("");
var Expression = new NonTerminal("Expression");
var FunctionDef = new NonTerminal("FunctionDef");
var DefArguments = new NonTerminal("FunctionDefArguments");
var DefArgumentsFragment = new NonTerminal("");
var Statement = new NonTerminal("Statement");
var ReturnStatement = new NonTerminal("ReturnStat");
var BreakStatement = new NonTerminal("BreakStat");
var Assignment = new NonTerminal("Assignment");
var LocalAssignment = new NonTerminal("LocalAssignment");
var FunctionDecl = new NonTerminal("FunctionDecl");
var DoBlock = new NonTerminal("DoBlock");
var If = new NonTerminal("If");
var Elseif = new NonTerminal("Elseif");
var Else = new NonTerminal("Else");
var While = new NonTerminal("While");
var Repeat = new NonTerminal("Repeat");
var For = new NonTerminal("For");
var PowerOp = new NonTerminal("PowerOp");
var MulOp = new NonTerminal("MulOp");
var AddOp = new NonTerminal("AddOp");
var ConcatOp = new NonTerminal("ConcatOp");
var RelOp = new NonTerminal("RelOp");
var AndOp = new NonTerminal("AndOp");
var OrOp = new NonTerminal("OrOp");
var UnaryExpr = new NonTerminal("UnaryExpr");
var TableConstruct = new NonTerminal("TableConstruct");
var TableConstructFragment = new NonTerminal("TableConstructFragment");
var VarArgs = new NonTerminal("Varargs")
{
Rule = "..."
};
#endregion
#region Fragments
CallArgumentsFragment.Rule = Expression | Expression + "," + CallArgumentsFragment;
CallArguments.Rule = "(" + (CallArgumentsFragment | Empty) + ")";
DefArgumentsFragment.Rule = (Identifier | VarArgs) | Identifier + "," + DefArgumentsFragment;
DefArguments.Rule = "(" + (DefArgumentsFragment | Empty) + ")";
Chunk.Rule = MakeStarRule(Chunk, Statement);
#endregion
#region Expressions
PowerOp.Rule = Expression + ("^" + Expression | Empty);
MulOp.Rule = PowerOp + ((ToTerm("*") | "/" | "%") + PowerOp | Empty);
AddOp.Rule = MulOp + ((ToTerm("+") | "-") + MulOp | Empty);
ConcatOp.Rule = AddOp + (".." + AddOp | Empty);
RelOp.Rule = ConcatOp + ((ToTerm(">") | ">=" | "<" | "<=" | "==" | "~=") + ConcatOp | Empty);
AndOp.Rule = RelOp + ("and" + RelOp | Empty);
OrOp.Rule = AndOp + ("or" + AndOp | Empty);
UnaryExpr.Rule = (ToTerm("not") | "-" | "#") + Expression;
Prefix.Rule =
OopCall
| FunctionCall
| Variable
| "(" + Expression + ")";
Variable.Rule =
Prefix + "." + Identifier
| Prefix + "[" + Expression + "]"
| Identifier;
FunctionCall.Rule = Prefix + CallArguments;
OopCall.Rule = Prefix + ":" + Identifier + CallArguments;
FunctionDef.Rule =
ToTerm("function") + DefArguments
+ Chunk + ToTerm("end");
var tableSep = new NonTerminal("");
tableSep.Rule = ToTerm(";") | ",";
TableConstructFragment.Rule =
(
(
(
(Identifier | "[" + Expression + "]") + "="
)
+ Expression
| Expression
)
+ (";" + TableConstructFragment | "," + TableConstructFragment | Empty)
) | Empty;
TableConstruct.Rule = "{" + TableConstructFragment + "}";
Expression.Rule =
VarArgs
| Prefix
| OrOp
| UnaryExpr
| ToTerm("true")
| "false"
| "nil"
| SingleString
| DoubleString
| MultiLineString
| Number
| FunctionDef
| TableConstruct;
#endregion
#region Statements
FunctionDecl.Rule = "function" + Variable + (":" + Identifier | Empty) + DefArguments + Chunk + "end";
var RetChunk = new NonTerminal("RetChunk");
RetChunk.Rule = Expression + (("," + RetChunk) | Empty);
ReturnStatement.Rule = "return" + (RetChunk | Empty);
var AssignExpChunk = new NonTerminal("AssignExpChunk");
AssignExpChunk.Rule = Expression + (("," + AssignExpChunk) | Empty);
var AssignVarChunk = new NonTerminal("AssignVarChunk");
AssignVarChunk.Rule = Variable + (("," + AssignVarChunk) | Empty);
Assignment.Rule =
AssignVarChunk + "=" + AssignExpChunk;
var LocalAssignNameChunk = new NonTerminal("AssignNameChunk");
var LocalFunction = new NonTerminal("LocalFunction");
LocalAssignNameChunk.Rule = Identifier + (("," + LocalAssignNameChunk) | Empty);
LocalFunction.Rule = "function" + Identifier + DefArguments + Chunk + "end";
LocalAssignment.Rule = "local" + (LocalAssignNameChunk + ("=" + AssignExpChunk | Empty) | LocalFunction);
Elseif.Rule = "elseif" + Expression + "then" + Chunk + (Elseif | Empty);
Else.Rule = "else" + Chunk;
If.Rule = "if" + Expression + "then" + Chunk + (Elseif | Empty) + (Else | Empty) + "end";
While.Rule = "while" + Expression + DoBlock;
DoBlock.Rule = "do" + Chunk + "end";
Repeat.Rule = "repeat" + Chunk + "until" + Expression;
BreakStatement.Rule = "break";
var NumericFor = new NonTerminal("NumericFor");
NumericFor.Rule = Identifier + "=" + Expression + "," + Expression + ("," + Expression | Empty);
var GenericFor = new NonTerminal("GenericFor");
var NameList = new NonTerminal("NameList");
var ExpList = new NonTerminal("ExpList");
NameList.Rule = Identifier + (("," + NameList) | Empty);
ExpList.Rule = Expression + (("," + ExpList) | Empty);
GenericFor.Rule = NameList + "in" + ExpList;
For.Rule = "for" + (GenericFor | NumericFor) + DoBlock;
Statement.Rule =
";"
| ReturnStatement
| BreakStatement
| Assignment
| LocalAssignment
| FunctionCall
| OopCall
| FunctionDecl
| For
| If
| While
| DoBlock
| Repeat;
#endregion
Root = Chunk;
MarkReservedWords(
"true", "false",
"nil", "local",
"function", "while",
"if", "for", "repeat", "until",
"end", "do", "return", "break");
MarkPunctuation(".", ",", ";", "(", ")", "[", "]", "{", "}", "=", ":");
MarkTransient(Statement);
}
public CalcGrammar() : base(true)
{
var comment = new CommentTerminal("comment", "//", "\n", "\r");
var blockComment = new CommentTerminal("blockComment", "/*", "*/");
NonGrammarTerminals.Add(comment);
NonGrammarTerminals.Add(blockComment);
NonTerminal start = new NonTerminal("start", typeof(StatementListNode));
NonTerminal block = new NonTerminal("block");
NonTerminal instructions = new NonTerminal("instructions", typeof(BlockNode));
NonTerminal instruction = new NonTerminal("instruction");
NonTerminal embeddedInstruction = new NonTerminal("embeddedInstruction");
NonTerminal ifClause = new NonTerminal("ifClause", typeof(IfNode));
NonTerminal ifElseClause = new NonTerminal("ifElseClause", typeof(IfNode));
NonTerminal forClause = new NonTerminal("forClause", typeof(ForNode));
NonTerminal forInitClause = new NonTerminal("forInit", typeof(StatementListNode));
NonTerminal forConditionClause = new NonTerminal("forCondition");
NonTerminal forIterClause = new NonTerminal("forIter", typeof(StatementListNode));
NonTerminal foreachClause = new NonTerminal("foreachClause", typeof(ForeachNode));
NonTerminal foreachVarDecl = new NonTerminal("foreachVarDecl");
NonTerminal whileClause = new NonTerminal("whileClause", typeof(WhileNode));
NonTerminal doWhileClause = new NonTerminal("doWhileClause", typeof(DoWhileNode));
NonTerminal returnClause = new NonTerminal("returnClause", typeof(ReturnNode));
NonTerminal emptyReturnClause = new NonTerminal("emptyReturnClause", typeof(ReturnNode));
NonTerminal breakClause = new NonTerminal("breakClause", typeof(BreakNode));
NonTerminal continueClause = new NonTerminal("continueClause", typeof(ContinueNode));
NonTerminal usingClause = new NonTerminal("usingClause", typeof(UsingNode));
NonTerminal usingNamespace = new NonTerminal("namespace", typeof(UsingNamespaceNode));
NonTerminal tryClause = new NonTerminal("tryClause", typeof(TryNode));
NonTerminal catchClause = new NonTerminal("catchClause", typeof(CatchNode));
NonTerminal finallyClause = new NonTerminal("finallyClause");
NonTerminal throwClause = new NonTerminal("throwClause", typeof(ThrowNode));
NonTerminal assignment = new NonTerminal("assignment", typeof(AssignmentNode));
NonTerminal assignmentOp = new NonTerminal("assignmentOp", "assignment operator");
NonTerminal varDeclaration = new NonTerminal("varDeclaration", typeof(VarDeclarationNode));
NonTerminal varDeclarationAndAssign = new NonTerminal("varDeclaration", typeof(VarDeclarationNode));
NonTerminal functionDef = new NonTerminal("functionDef", typeof(FunctionDefNode));
NonTerminal functionBody = new NonTerminal("functionBody", typeof(StatementListNode));
NonTerminal lambdaBody = new NonTerminal("lambdaBody", typeof(StatementListNode));
NonTerminal inlineFunctionDef = new NonTerminal("inlineFunctionDef", typeof(LambdaNode));
NonTerminal externFunctionDef = new NonTerminal("externFunctionDef", typeof(ExternFunctionNode));
NonTerminal paramList = new NonTerminal("paramList", typeof(ParamListNode));
NonTerminal param = new NonTerminal("param", typeof(ParamNode));
NonTerminal lambdaParamList = new NonTerminal("lambdaParamList", typeof(ParamListNode));
NonTerminal singleLambdaParamList = new NonTerminal("lambdaParamList", typeof(ParamListNode));
NonTerminal lambdaParam = new NonTerminal("lambdaParam", typeof(ParamNode));
NonTerminal paramsOrEmpty = new NonTerminal("paramsOrEmpty");
NonTerminal arrayDef = new NonTerminal("arrayDef");
NonTerminal arrayDefList = new NonTerminal("arrayDefList", typeof(ArrayDefNode));
NonTerminal arrayDefListItem = new NonTerminal("arrayDefListItem");
NonTerminal namedArrayItem = new NonTerminal("namedArrayItem", typeof(NamedArrayItemNode));
NonTerminal expr = new NonTerminal("expr");
NonTerminal prefixExpr = new NonTerminal("prefixExpr", typeof(IncDecNode));
NonTerminal postfixExpr = new NonTerminal("postfixExpr", typeof(IncDecNode));
NonTerminal binExpr = new NonTerminal("binExpr", typeof(BinaryOperationNode));
NonTerminal unExpr = new NonTerminal("unExpr", typeof(UnaryExpressionNode));
NonTerminal var = new NonTerminal("var");
NonTerminal objRef = new NonTerminal("objRef");
NonTerminal memberAccess = new NonTerminal("memberAccess", typeof(MemberAccessNode));
NonTerminal ternaryIf = new NonTerminal("ternaryIf", typeof(IfNode));
NonTerminal coalescence = new NonTerminal("coalescence", typeof(CoalescenceNode));
NonTerminal functionCall = new NonTerminal("functionCall", typeof(FunctionCallNode));
NonTerminal varList = new NonTerminal("varList", typeof(ExpressionListNode));
NonTerminal array = new NonTerminal("array");
NonTerminal singleDimArray = new NonTerminal("singleDimArray", typeof(IndexedAccessNode));
NonTerminal rangeArrayDef = new NonTerminal("rangeArrayDef", typeof(RangeArrayDefNode));
NonTerminal rangeInclusiveArrayDef = new NonTerminal("rangeInclusiveArrayDef", typeof(RangeArrayDefNode));
NonTerminal typeInfo = new NonTerminal("typeInfo");
NonTerminal typeInfoOrEmpty = new NonTerminal("typeInfoOrEmpty");
IdentifierTerminal name = new IdentifierTerminal("name", IdOptions.IsNotKeyword);
IdentifierTerminal newName = new IdentifierTerminal("newName", IdOptions.IsNotKeyword);
NumberLiteral number = new NumberLiteral("number", NumberOptions.AllowUnderscore);
StringLiteral _string = new StringLiteral("string", "\"", StringOptions.AllowsAllEscapes);
StringLiteral _char = new StringLiteral("Char", "'", StringOptions.IsChar | StringOptions.AllowsAllEscapes);
NonTerminal boolVal = new NonTerminal("boolVal", typeof(BoolValNode));
NonTerminal nullVal = new NonTerminal("nullVal", typeof(NullValueNode));
NonTerminal thisVal = new NonTerminal("thisVal", typeof(ThisNode));
NonTerminal binOp = new NonTerminal("binOp", "operator");
NonTerminal unaryOp = new NonTerminal("unaryOp", "operator");
NonTerminal incDecOp = new NonTerminal("incDecOp", "operator");
NonTerminal emptyInstruction = new NonTerminal("emptyInstruction", typeof(EmptyNode));
start.Rule = MakeStarRule(start, instruction);
block.Rule = "{" + instructions + "}";
instructions.Rule = MakeStarRule(instructions, instruction);
instruction.Rule = block
| embeddedInstruction + ";"
| ifClause
| ifElseClause
| functionDef
| externFunctionDef + ";"
| returnClause + ";"
| emptyReturnClause
| breakClause
| continueClause
| forClause
| foreachClause
| whileClause
| doWhileClause
| usingClause
| varDeclaration + ";"
| emptyInstruction
| tryClause
| throwClause + ";";
emptyInstruction.Rule = ToTerm(";");
instruction.ErrorRule = SyntaxError + ";";
embeddedInstruction.Rule = functionCall | postfixExpr | prefixExpr | assignment | varDeclarationAndAssign;
ifElseClause.Rule = ToTerm("if") + "(" + expr + ")" + instruction
+ PreferShiftHere() + "else" + instruction;
ifClause.Rule = ToTerm("if") + "(" + expr + ")" + instruction;
forClause.Rule = ToTerm("for") + "(" + forInitClause + ";" + forConditionClause + ";" + forIterClause + ")" + instruction;
forInitClause.Rule = MakeStarRule(forInitClause, ToTerm(","), embeddedInstruction);
forConditionClause.Rule = Empty | expr;
forIterClause.Rule = MakeStarRule(forIterClause, ToTerm(","), embeddedInstruction);
foreachClause.Rule = ToTerm("foreach") + "(" + foreachVarDecl + "in" + expr + ")" + instruction;
foreachVarDecl.Rule = varDeclaration | name;
whileClause.Rule = ToTerm("while") + "(" + expr + ")" + instruction;
doWhileClause.Rule = ToTerm("do") + instruction + ToTerm("while") + "(" + expr + ")" + ToTerm(";");
returnClause.Rule = "return" + expr;
emptyReturnClause.Rule = ToTerm("return") + ";";
breakClause.Rule = ToTerm("break") + ";";
continueClause.Rule = ToTerm("continue") + ";";
tryClause.Rule = "try" + block + (catchClause + finallyClause | finallyClause | catchClause);
catchClause.Rule = "catch" + ("(" + name + ")").Q() + block;
finallyClause.Rule = "finally" + block;
throwClause.Rule = "throw" + expr;
usingClause.Rule = ToTerm("using") + usingNamespace + ";";
usingNamespace.Rule = (name + "." + usingNamespace) | name;
varDeclaration.Rule = "var" + name + typeInfoOrEmpty;
varDeclarationAndAssign.Rule = "var" + name + typeInfoOrEmpty + "=" + expr;
assignment.Rule = objRef + assignmentOp + expr;
assignmentOp.Rule = ToTerm("=") | "+=" | "-=" | "*=" | "/=" | "%=" | "|=" | "^=" | "&=" | "<<=" | ">>=" | "**=";
objRef.Rule = name | array | memberAccess;
memberAccess.Rule = var + PreferShiftHere() + "." + name;
functionDef.Rule = "function" + name + "(" + paramList + ")" + ToTerm("extension").Q() + functionBody;
functionDef.NodeCaptionTemplate = "function #{0}(...)";
inlineFunctionDef.Rule = (ToTerm("function") + "(" + paramList + ")" + functionBody)
| ("(" + lambdaParamList + ")" + ToTerm("=>") + expr)
| (singleLambdaParamList + "=>" + expr);
externFunctionDef.Rule = ToTerm("extern") + "function" + name + "(" + paramList + ")" + ToTerm("extension").Q();
inlineFunctionDef.NodeCaptionTemplate = "function(...)";
functionBody.Rule = block | returnClause;
paramList.Rule = MakeStarRule(paramList, ToTerm(","), param);
lambdaParamList.Rule = MakeStarRule(lambdaParamList, ToTerm(","), lambdaParam);
singleLambdaParamList.Rule = lambdaParam;
lambdaParam.Rule = name + ReduceIf("=>", "+", "-", "*", "/", "%", "**", "&", "&&", "|", "||", "^", "==", "<=", ">=", "<", ">", "!=", "<<", ">>", ";", "(", "??");
param.Rule = paramsOrEmpty + name + typeInfoOrEmpty;
paramsOrEmpty.Rule = ToTerm("params") | Empty;
arrayDef.Rule = "{" + arrayDefList + "}";
arrayDefList.Rule = MakeStarRule(arrayDefList, ToTerm(","), arrayDefListItem);
arrayDefListItem.Rule = namedArrayItem | expr;
namedArrayItem.Rule = (name + ReduceHere() | _string) + "=" + expr;
rangeArrayDef.Rule = expr + PreferShiftHere() + ".." + expr + ((PreferShiftHere() + ":" + expr) | Empty);
rangeInclusiveArrayDef.Rule = expr + PreferShiftHere() + "..." + expr + ((PreferShiftHere() + ":" + expr) | Empty);
expr.Rule = prefixExpr | postfixExpr | ternaryIf
| inlineFunctionDef
| var | unExpr | binExpr
| arrayDef
| rangeArrayDef
| rangeInclusiveArrayDef
| assignment
| coalescence;
coalescence.Rule = expr + "??" + expr;
binExpr.Rule = expr + binOp + expr;
binOp.Rule = ToTerm("&&") | "||" | "&" | "|" | "^"
| ToTerm("==") | "<=" | ">=" | "<" | ">" | "!="
| ToTerm("+") | "-"
| ToTerm("*") | "/" | "%" | "**"
| ToTerm("<<") | ">>";
prefixExpr.Rule = incDecOp + objRef + ReduceHere();
postfixExpr.Rule = objRef + PreferShiftHere() + incDecOp;
unExpr.Rule = unaryOp + expr + ReduceHere();
var.Rule = objRef
| number
| boolVal
| nullVal
| thisVal
| _string
| _char
| functionCall + ReduceHere()
| ("(" + expr + ")");
ternaryIf.Rule = expr + "?" + expr + ":" + expr;
functionCall.Rule = var + PreferShiftHere() + "(" + varList + ")";
functionCall.NodeCaptionTemplate = "call #{0}(...)";
varList.Rule = MakeStarRule(varList, ToTerm(","), expr);
array.Rule = singleDimArray;
singleDimArray.Rule = var + PreferShiftHere() + "[" + expr + "]";
boolVal.Rule = ToTerm("true") | "false";
nullVal.Rule = ToTerm("null");
thisVal.Rule = ToTerm("this");
typeInfoOrEmpty.Rule = ":" + typeInfo | Empty;
typeInfo.Rule = ToTerm("string")
| "function"
| "number"
| "bool"
| "table"
| "char";
unaryOp.Rule = ToTerm("-") | "!" | "~";
incDecOp.Rule = ToTerm("++") | "--";
MarkPunctuation("(", ")", "?", ":", "[", "]", ";", "{", "}", ".", ",", "@", "=>", "??",
"return", "if", "else", "for", "while", "break", "continue",
"using", "do", "var", "foreach", "in",
"try", "catch", "finally", "throw", "extern");
RegisterBracePair("(", ")");
RegisterBracePair("[", "]");
RegisterBracePair("{", "}");
RegisterOperators(10, "?");
RegisterOperators(15, "&&", "||", "&", "|", "^");
RegisterOperators(20, "==", "<", "<=", ">", ">=", "!=");
RegisterOperators(25, "<<", ">>");
RegisterOperators(30, "+", "-");
RegisterOperators(40, "*", "/", "%", "**");
RegisterOperators(60, "!", "~");
RegisterOperators(70, "++", "--", "??");
MarkTransient(var, expr, binOp, unaryOp, block, instruction, embeddedInstruction, objRef, array, arrayDef, assignmentOp, arrayDefListItem, incDecOp, functionBody, lambdaBody, foreachVarDecl, paramsOrEmpty, typeInfoOrEmpty);
AddTermsReportGroup("assignment", "=", "+=", "-=", "*=", "/=", "%=", "&=", "|=", "^=", "<<=", ">>=");
AddTermsReportGroup("statement", "if", "while", "for", "return", "break", "continue", "using", "do", "try", "throw", "foreach");
AddTermsReportGroup("variable declaration", "var");
AddTermsReportGroup("function declaration", "function", "extern");
AddTermsReportGroup("constant", number, _string, _char);
AddTermsReportGroup("constant", "null", "false", "true", "this", "@");
AddTermsReportGroup("unary operator", "+", "-", "!");
AddTermsReportGroup("operator", "+", "-", "*", "/", "%", "**", "&", "&&", "|", "||", "^", "?", "==", "<=", "<", ">=", ">", "!=", "<<", ">>", "??", "..");
AddToNoReportGroup("(", "[", "{", ".", ",", "++", "--");
MarkReservedWords("if", "else", "return", "function", "while",
"for", "null", "false", "true", "this", "break", "continue",
"using", "do", "var", "foreach", "in", "params",
"try", "catch", "finally", "throw", "extern");
number.DefaultFloatType = TypeCode.Double;
number.DefaultIntTypes = new TypeCode[] { TypeCode.Int64 };
number.AddPrefix("0x", NumberOptions.Hex);
number.AddPrefix("0b", NumberOptions.Binary);
number.AddSuffix("d", TypeCode.Double);
number.AddSuffix("l", TypeCode.Int64);
number.AddSuffix("m", TypeCode.Decimal);
_string.AddPrefix("@", StringOptions.NoEscapes);
_string.AddPrefix("$", StringOptions.IsTemplate | StringOptions.AllowsAllEscapes);
var stringTemplateSettings = new StringTemplateSettings();
stringTemplateSettings.StartTag = "{";
stringTemplateSettings.EndTag = "}";
stringTemplateSettings.ExpressionRoot = expr;
this.SnippetRoots.Add(expr);
_string.AstConfig.NodeType = typeof(StringTemplateNode);
_string.AstConfig.Data = stringTemplateSettings;
this.Root = start;
this.LanguageFlags = LanguageFlags.CreateAst;
}
public CilGrammar()
: base(true)
{
LanguageFlags = LanguageFlags.CreateAst;
// comments
var SINGLELINECOMMENT = new CommentTerminal("SINGLELINECOMMENT", "//", "\n", "\r\n");
ConfigureAstNode(SINGLELINECOMMENT);
NonGrammarTerminals.Add(SINGLELINECOMMENT);
// lexical tokens
var HEXBYTE = new RegexBasedTerminal("HEXBYTE", @"[A-F0-9]{2}"); // DOCS: not specified in ECMA grammar
ConfigureAstNode(HEXBYTE);
var DOTTEDNAME = CreateNonTerminal("DOTTEDNAME");
DOTTEDNAME.Rule = _("TODO: DOTTEDNAME");
ConfigureAstNode(DOTTEDNAME);
var ID = new IdentifierTerminal("ID");
ID.AddPrefix("$", IdOptions.None); // DOCS: ECMA page 110
ConfigureAstNode(ID);
var QSTRING = new StringLiteral("QSTRING", "\"");
ConfigureAstNode(QSTRING);
var SQSTRING = new StringLiteral("SQSTRING", "'");
ConfigureAstNode(SQSTRING);
var INT32 = new NumberLiteral("INT32", NumberOptions.AllowSign | NumberOptions.IntOnly);
INT32.AddPrefix("0x", NumberOptions.Hex);
INT32.DefaultIntTypes = new TypeCode[] { TypeCode.Int32 };
ConfigureAstNode(INT32);
var INT64 = new NumberLiteral("INT64", NumberOptions.AllowSign | NumberOptions.IntOnly);
INT64.AddPrefix("0x", NumberOptions.Hex);
INT64.DefaultIntTypes = new TypeCode[] { TypeCode.Int64 };
ConfigureAstNode(INT64);
var FLOAT64 = new NumberLiteral("FLOAT64", NumberOptions.AllowStartEndDot | NumberOptions.AllowSign);
ConfigureAstNode(FLOAT64);
// non-terminals
var decls = CreateNonTerminal("decls");
var decl = CreateNonTerminal("decl");
var compQstring = CreateNonTerminal("compQstring");
var languageDecl = CreateNonTerminal("languageDecl");
var customAttrDecl = CreateNonTerminal("customAttrDecl");
var moduleHead = CreateNonTerminal("moduleHead");
var vtfixupDecl = CreateNonTerminal("vtfixupDecl");
var vtableDecl = CreateNonTerminal("vtableDecl");
var nameSpaceHead = CreateNonTerminal("nameSpaceHead");
var classHead = CreateNonTerminal("classHead");
var classAttr = CreateNonTerminal("classAttr");
var extendsClause = CreateNonTerminal("extendsClause");
var implClause = CreateNonTerminal("implClause");
var classNames = CreateNonTerminal("classNames");
var classDecls = CreateNonTerminal("classDecls");
var classDecl = CreateNonTerminal("classDecl");
var fieldDecl = CreateNonTerminal("fieldDecl");
var atOpt = CreateNonTerminal("atOpt");
var initOpt = CreateNonTerminal("initOpt");
var repeatOpt = CreateNonTerminal("repeatOpt");
var customHead = CreateNonTerminal("customHead");
var customHeadWithOwner = CreateNonTerminal("customHeadWithOwner");
var memberRef = CreateNonTerminal("memberRef");
var customType = CreateNonTerminal("customType");
var ownerType = CreateNonTerminal("ownerType");
var eventHead = CreateNonTerminal("eventHead");
var eventDecls = CreateNonTerminal("eventDecls");
var propHead = CreateNonTerminal("propHead");
var propDecls = CreateNonTerminal("propDecls");
var methodHeadPart1 = CreateNonTerminal("methodHeadPart1");
var methodHead = CreateNonTerminal("methodHead");
var methAttr = CreateNonTerminal("methAttr");
var pinvAttr = CreateNonTerminal("pinvAttr");
var methodName = CreateNonTerminal("methodName");
var paramAttr = CreateNonTerminal("paramAttr");
var fieldAttr = CreateNonTerminal("fieldAttr");
var implAttr = CreateNonTerminal("implAttr");
var localsHead = CreateNonTerminal("localsHead");
var methodDecl = CreateNonTerminal("methodDecl");
var scopeBlock = CreateNonTerminal("scopeBlock");
var sehBlock = CreateNonTerminal("sehBlock");
var methodDecls = CreateNonTerminal("methodDecls");
var dataDecl = CreateNonTerminal("dataDecl");
var ddHead = CreateNonTerminal("ddHead");
var tls = CreateNonTerminal("tls");
var ddBody = CreateNonTerminal("ddBody");
var ddItemList = CreateNonTerminal("ddItemList");
var ddItemCount = CreateNonTerminal("ddItemCount");
var ddItem = CreateNonTerminal("ddItem");
var fieldInit = CreateNonTerminal("fieldInit");
var bytearrayhead = CreateNonTerminal("bytearrayhead");
var bytes = CreateNonTerminal("bytes");
var hexbytes = CreateNonTerminal("hexbytes");
var instr_r_head = CreateNonTerminal("instr_r_head");
var instr_tok_head = CreateNonTerminal("instr_tok_head");
var methodSpec = CreateNonTerminal("methodSpec");
var instr = CreateNonTerminal("instr");
var sigArgs0 = CreateNonTerminal("sigArgs0");
var sigArgs1 = CreateNonTerminal("sigArgs1");
var sigArg = CreateNonTerminal("sigArg");
var name1 = CreateNonTerminal("name1");
var className = CreateNonTerminal("className");
var slashedName = CreateNonTerminal("slashedName");
var typeSpec = CreateNonTerminal("typeSpec");
var callConv = CreateNonTerminal("callConv");
var callKind = CreateNonTerminal("callKind");
var nativeType = CreateNonTerminal("nativeType");
var type = CreateNonTerminal("type");
var bounds1 = CreateNonTerminal("bounds1");
var bound = CreateNonTerminal("bound");
var labels = CreateNonTerminal("labels");
var id = CreateNonTerminal("id");
var int16s = CreateNonTerminal("int16s");
var int32 = CreateNonTerminal("int32");
var int64 = CreateNonTerminal("int64");
var float64 = CreateNonTerminal("float64");
var secDecl = CreateNonTerminal("secDecl");
var psetHead = CreateNonTerminal("psetHead");
var nameValPairs = CreateNonTerminal("nameValPairs");
var nameValPair = CreateNonTerminal("nameValPair");
var truefalse = CreateNonTerminal("truefalse");
var caValue = CreateNonTerminal("caValue");
var secAction = CreateNonTerminal("secAction");
var extSourceSpec = CreateNonTerminal("extSourceSpec");
var fileDecl = CreateNonTerminal("fileDecl");
var hashHead = CreateNonTerminal("hashHead");
var assemblyHead = CreateNonTerminal("assemblyHead");
var asmAttr = CreateNonTerminal("asmAttr");
var assemblyDecls = CreateNonTerminal("assemblyDecls");
var assemblyDecl = CreateNonTerminal("assemblyDecl");
var asmOrRefDecl = CreateNonTerminal("asmOrRefDecl");
var publicKeyHead = CreateNonTerminal("publicKeyHead");
var publicKeyTokenHead = CreateNonTerminal("publicKeyTokenHead");
var localeHead = CreateNonTerminal("localeHead");
var assemblyRefHead = CreateNonTerminal("assemblyRefHead");
var assemblyRefDecls = CreateNonTerminal("assemblyRefDecls");
var assemblyRefDecl = CreateNonTerminal("assemblyRefDecl");
var comtypeHead = CreateNonTerminal("comtypeHead");
var exportHead = CreateNonTerminal("exportHead");
var comtypeDecls = CreateNonTerminal("comtypeDecls");
var manifestResHead = CreateNonTerminal("manifestResHead");
var manresAttr = CreateNonTerminal("manresAttr");
var manifestResDecls = CreateNonTerminal("manifestResDecls");
var manifestResDecl = CreateNonTerminal("manifestResDecl");
// instructions
var INSTR_NONE = CreateNonTerminal("INSTR_NONE");
var INSTR_VAR = CreateNonTerminal("INSTR_VAR");
var INSTR_I = CreateNonTerminal("INSTR_I");
var INSTR_I8 = CreateNonTerminal("INSTR_I8");
var INSTR_R = CreateNonTerminal("INSTR_R");
var INSTR_BRTARGET = CreateNonTerminal("INSTR_BRTARGET");
var INSTR_METHOD = CreateNonTerminal("INSTR_METHOD");
var INSTR_FIELD = CreateNonTerminal("INSTR_FIELD");
var INSTR_TYPE = CreateNonTerminal("INSTR_TYPE");
var INSTR_STRING = CreateNonTerminal("INSTR_STRING");
var INSTR_SIG = CreateNonTerminal("INSTR_SIG");
var INSTR_RVA = CreateNonTerminal("INSTR_RVA");
var INSTR_SWITCH = CreateNonTerminal("INSTR_SWITCH");
var INSTR_PHI = CreateNonTerminal("INSTR_PHI");
var INSTR_TOK = CreateNonTerminal("INSTR_TOK");
INSTR_NONE.Rule =
_("add") |
___("add.ovf") |
___("add.ovf.un") |
_("and") |
_("arglist") |
_("break") |
_("ceq") |
_("cgt") |
___("cgt.un") |
_("ckfinite") |
_("clt") |
___("clt.un") |
___("conv.i") |
___("conv.i1") |
___("conv.i2") |
___("conv.i4") |
___("conv.i8") |
___("conv.ovf.i") |
___("conv.ovf.i.un") |
___("conv.ovf.i1") |
___("conv.ovf.i1.un") |
___("conv.ovf.i2") |
___("conv.ovf.i2.un") |
___("conv.ovf.i4") |
___("conv.ovf.i4.un") |
___("conv.ovf.i8") |
___("conv.ovf.i8.un") |
___("conv.ovf.u") |
___("conv.ovf.u.un") |
___("conv.ovf.u1") |
___("conv.ovf.u1.un") |
___("conv.ovf.u2") |
___("conv.ovf.u2.un") |
___("conv.ovf.u4") |
___("conv.ovf.u4.un") |
___("conv.ovf.u8") |
___("conv.ovf.u8.un") |
___("conv.r.un") |
___("conv.r4") |
___("conv.r8") |
___("conv.u") |
___("conv.u1") |
___("conv.u2") |
___("conv.u4") |
___("conv.u8") |
_("cpblk") |
_("div") |
___("div.un") |
_("dup") |
_("endfault") |
_("endfilter") |
_("endfinally") |
_("initblk") |
___("ldarg.0") |
___("ldarg.1") |
___("ldarg.2") |
___("ldarg.3") |
___("ldc.i4.0") |
___("ldc.i4.1") |
___("ldc.i4.2") |
___("ldc.i4.3") |
___("ldc.i4.4") |
___("ldc.i4.5") |
___("ldc.i4.6") |
___("ldc.i4.7") |
___("ldc.i4.8") |
___("ldc.i4.M1") |
___("ldc.i4.m1") | // DOCS: non present in ECMA grammar
___("ldelem.i") |
___("ldelem.i1") |
___("ldelem.i2") |
___("ldelem.i4") |
___("ldelem.i8") |
___("ldelem.r4") |
___("ldelem.r8") |
___("ldelem.ref") |
___("ldelem.u1") |
___("ldelem.u2") |
___("ldelem.u4") |
___("ldind.i") |
___("ldind.i1") |
___("ldind.i2") |
___("ldind.i4") |
___("ldind.i8") |
___("ldind.r4") |
___("ldind.r8") |
___("ldind.ref") |
___("ldind.u1") |
___("ldind.u2") |
___("ldind.u4") |
_("ldlen") |
___("ldloc.0") |
___("ldloc.1") |
___("ldloc.2") |
___("ldloc.3") |
_("ldnull") |
_("localloc") |
_("mul") |
___("mul.ovf") |
___("mul.ovf.un") |
_("neg") |
_("nop") |
_("not") |
_("or") |
_("pop") |
_("refanytype") |
_("rem") |
___("rem.un") |
_("ret") |
_("rethrow") |
_("shl") |
_("shr") |
___("shr.un") |
___("stelem.i") |
___("stelem.i1") |
___("stelem.i2") |
___("stelem.i4") |
___("stelem.i8") |
___("stelem.r4") |
___("stelem.r8") |
___("stelem.ref") |
___("stind.i") |
___("stind.i1") |
___("stind.i2") |
___("stind.i4") |
___("stind.i8") |
___("stind.r4") |
___("stind.r8") |
___("stind.ref") |
___("stloc.0") |
___("stloc.1") |
___("stloc.2") |
___("stloc.3") |
_("sub") |
___("sub.ovf") |
___("sub.ovf.un") |
_("tail.") |
_("throw") |
_("volatile.") |
_("xor");
INSTR_VAR.Rule =
_("ladrg") |
___("ldarg.s") |
_("ldarga") |
___("ldarga.s") |
_("ldloc") |
___("ldloc.s") |
_("ldloca") |
___("ldloca.s") |
_("starg") |
___("starg.s") |
_("stloc") |
___("stloc.s");
INSTR_I.Rule =
___("ldc.i4") |
___("ldc.i4.s") |
_("unaligned.");
INSTR_I8.Rule =
___("ldc.i8");
INSTR_R.Rule =
___("ldc.r4") |
___("ldc.r8");
INSTR_BRTARGET.Rule =
_("beq") |
___("beq.s") |
_("bge") |
___("bge.s") |
___("bge.un") |
___("bge.un.s") |
_("bgt") |
___("bgt.s") |
___("bgt.un") |
___("bgt.un.s") |
_("ble") |
___("ble.s") |
___("ble.un") |
___("ble.un.s") |
_("blt") |
___("blt.s") |
___("blt.un") |
___("blt.un.s") |
___("bne.un") |
___("bne.un.s") |
_("br") |
___("br.s") |
_("brfalse") |
___("brfalse.s") |
_("brtrue") |
___("brtrue.s") |
_("leave") |
___("leave.s");
INSTR_METHOD.Rule =
_("call") |
_("callvirt") |
_("jmp") |
_("ldftn") |
_("ldvirtftn") |
_("newobj");
INSTR_FIELD.Rule =
_("ldfld") |
_("ldflda") |
_("ldsfld") |
_("ldsflda") |
_("stfld") |
_("stsfld");
INSTR_TYPE.Rule =
_("box") |
_("castclass") |
_("cpobj") |
_("initobj") |
_("isinst") |
_("ldelem") | // DOCS: non-present in ECMA grammar
_("ldelema") |
_("ldobj") |
_("mkrefany") |
_("newarr") |
_("refanyval") |
_("sizeof") |
_("stelem") | // DOCS: non-present in ECMA grammar
_("stobj") |
_("unbox") |
___("unbox.any"); // DOCS: non-present in ECMA grammar
INSTR_STRING.Rule =
_("ldstr");
INSTR_SIG.Rule = _("TODO: INSTR_SIG");
INSTR_RVA.Rule = _("TODO: INSTR_RVA");
INSTR_SWITCH.Rule =
_("switch");
INSTR_PHI.Rule = _("TODO: INSTR_PHI");
INSTR_TOK.Rule =
_("ldtoken");
// rules
Root = decls;
decls.Rule =
Empty |
decls + decl;
decl.Rule =
classHead + _("{") + classDecls + _("}") |
nameSpaceHead + _("{") + decls + _("}") |
methodHead + methodDecls + _("}") |
fieldDecl |
dataDecl |
vtableDecl |
vtfixupDecl |
extSourceSpec |
fileDecl |
assemblyHead + _("{") + assemblyDecls + _("}") |
assemblyRefHead + _("{") + assemblyRefDecls + _("}") |
comtypeHead + _("{") + comtypeDecls + _("}") |
manifestResHead + _("{") + manifestResDecls + _("}") |
moduleHead |
secDecl |
customAttrDecl |
_(".subsystem") + int32 |
_(".corflags") + int32 |
_(".file") + _("alignment") + int32 |
_(".imagebase") + int64 |
languageDecl |
_(".stackreserve") + int64; // DOCS: not present in ECMA grammar
compQstring.Rule =
QSTRING |
compQstring + _("+") + QSTRING;
// TODO - languageDecl
languageDecl.Rule = _("TODO: languageDecl");
customAttrDecl.Rule =
_(".custom") + customType |
_(".custom") + customType + _("=") + compQstring |
customHead + bytes + _(")") |
_(".custom") + _("(") + ownerType + _(")") + customType |
_(".custom") + _("(") + ownerType + _(")") + customType + _("=") + compQstring |
customHeadWithOwner + bytes + _(")");
moduleHead.Rule =
_(".module") |
_(".module") + name1 |
_(".module") + _("extern") + name1;
// TODO - vtfixupDecl
vtfixupDecl.Rule = _("TODO: vtfixupDecl");
// TODO - vtableDecl
vtableDecl.Rule = _("TODO: vtableDecl");
// TODO - nameSpaceHead
nameSpaceHead.Rule = _("TODO: nameSpaceHead");
classHead.Rule =
_(".class") + classAttr + id + extendsClause + implClause |
_(".class") + classAttr + name1 + extendsClause + implClause; // DOCS: not present in ECMA grammar
classAttr.Rule =
Empty |
classAttr + _("public") |
classAttr + _("private") |
classAttr + _("value") |
classAttr + _("enum") |
classAttr + _("interface") |
classAttr + _("sealed") |
classAttr + _("abstract") |
classAttr + _("auto") |
classAttr + _("sequential") |
classAttr + _("explicit") |
classAttr + _("ansi") |
classAttr + _("unicode") |
classAttr + _("autochar") |
classAttr + _("import") |
classAttr + _("serializable") |
classAttr + _("nested") + _("public") |
classAttr + _("nested") + _("private") |
classAttr + _("nested") + _("family") |
classAttr + _("nested") + _("assembly") |
classAttr + _("nested") + _("famandassem") |
classAttr + _("nested") + _("famorassem") |
classAttr + _("beforefieldinit") |
classAttr + _("specialname") |
classAttr + _("rtspecialname");
extendsClause.Rule =
Empty |
_("extends") + className;
implClause.Rule =
Empty |
_("implements") + classNames;
classNames.Rule =
className + _(",") + className |
className;
classDecls.Rule =
Empty |
classDecls + classDecl;
classDecl.Rule =
methodHead + methodDecls + _("}") |
classHead + _("{") + classDecls + _("}") |
eventHead + _("{") + eventDecls + _("}") |
propHead + _("{") + propDecls + _("}") |
fieldDecl |
dataDecl |
secDecl |
extSourceSpec |
customAttrDecl |
_(".size") + int32 |
_(".pack") + int32 |
exportHead + _("{") + comtypeDecls + _("}") |
_(".override") + typeSpec + _("::") + methodName + _("with") + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
languageDecl;
fieldDecl.Rule =
_(".field") + repeatOpt + fieldAttr + type + id + atOpt + initOpt;
atOpt.Rule =
Empty |
_("at") + id;
initOpt.Rule =
Empty |
_("=") + fieldInit;
repeatOpt.Rule =
Empty |
_("[") + int32 + _("]");
customHead.Rule =
_(".custom") + customType + _("=") + _("(");
customHeadWithOwner.Rule =
_(".custom") + _("(") + ownerType + _(")") + customType + _("=") + _("(");
memberRef.Rule =
methodSpec + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
methodSpec + callConv + type + methodName + _("(") + sigArgs0 + _(")") |
_("field") + type + typeSpec + _("::") + id |
_("field") + type + id;
customType.Rule =
callConv + type + typeSpec + _("::") + _(".ctor") + _("(") + sigArgs0 + _(")") |
callConv + type + _(".ctor") + _("(") + sigArgs0 + _(")");
ownerType.Rule =
typeSpec |
memberRef;
// TODO - eventHead
eventHead.Rule = _("TODO: eventHead");
// TODO - eventDecls
eventDecls.Rule = _("TODO: eventDecls");
// TODO - propHead
propHead.Rule = _("TODO: propHead");
// TODO - propDecls
propDecls.Rule = _("TODO: propDecls");
methodHeadPart1.Rule =
_(".method");
methodHead.Rule =
methodHeadPart1 + methAttr + callConv + paramAttr + type + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{") |
methodHeadPart1 + methAttr + callConv + paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{");
methAttr.Rule =
Empty |
methAttr + _("static") |
methAttr + _("public") |
methAttr + _("private") |
methAttr + _("family") |
methAttr + _("final") |
methAttr + _("specialname") |
methAttr + _("virtual") |
methAttr + _("abstract") |
methAttr + _("assembly") |
methAttr + _("famandassem") |
methAttr + _("famorassem") |
methAttr + _("privatescope") |
methAttr + _("hidebysig") |
methAttr + _("newslot") |
methAttr + _("rtspecialname") |
methAttr + _("unmanagedexp") |
methAttr + _("reqsecobj") |
methAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") |
methAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") |
methAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")");
// TODO - pinvAttr
pinvAttr.Rule = _("TODO: pinvAttr");
methodName.Rule =
_(".ctor") |
_(".cctor") |
name1;
fieldAttr.Rule =
Empty |
fieldAttr + _("static") |
fieldAttr + _("public") |
fieldAttr + _("private") |
fieldAttr + _("family") |
fieldAttr + _("initonly") |
fieldAttr + _("rtspecialname") |
fieldAttr + _("specialname") |
fieldAttr + _("pinvokeimpl") + _("(") + compQstring + _("as") + compQstring + pinvAttr + _(")") |
fieldAttr + _("pinvokeimpl") + _("(") + compQstring + pinvAttr + _(")") |
fieldAttr + _("pinvokeimpl") + _("(") + pinvAttr + _(")") |
fieldAttr + _("marshal") + _("(") + nativeType + _(")") |
fieldAttr + _("assembly") |
fieldAttr + _("famandassem") |
fieldAttr + _("famorassem") |
fieldAttr + _("privatescope") |
fieldAttr + _("literal") |
fieldAttr + _("notserialized");
paramAttr.Rule =
Empty |
paramAttr + _("[") + _("in") + _("]") |
paramAttr + _("[") + _("out") + _("]") |
paramAttr + _("[") + _("opt") + _("]") |
paramAttr + _("[") + int32 + _("]");
implAttr.Rule =
Empty |
implAttr + _("native") |
implAttr + _("cil") |
implAttr + _("optil") |
implAttr + _("managed") |
implAttr + _("unmanaged") |
implAttr + _("forwardref") |
implAttr + _("preservesig") |
implAttr + _("runtime") |
implAttr + _("internalcall") |
implAttr + _("synchronized") |
implAttr + _("noinlining");
localsHead.Rule =
_(".locals");
methodDecl.Rule =
_(".emitbyte") + int32 |
sehBlock |
_(".maxstack") + int32 |
localsHead + _("(") + sigArgs0 + _(")") |
localsHead + _("init") + _("(") + sigArgs0 + _(")") |
_(".entrypoint") |
_(".zeroinit") |
dataDecl |
instr |
id + _(":") |
secDecl |
extSourceSpec |
languageDecl |
customAttrDecl |
_(".export") + _("[") + int32 + _("]") |
_(".export") + _("[") + int32 + _("]") + _("as") + id |
_(".vtentry") + int32 + _(":") + int32 |
_(".override") + typeSpec + _("::") + methodName |
scopeBlock |
_(".param") + _("[") + int32 + _("]") + initOpt;
// TODO - scopeBlock
scopeBlock.Rule = _("TODO: scopeBlock");
// TODO - sehBlock
sehBlock.Rule = _("TODO: sehBlock");
methodDecls.Rule =
Empty |
methodDecls + methodDecl;
dataDecl.Rule =
ddHead + ddBody;
ddHead.Rule =
_(".data") + tls + id + _("=") |
_(".data") + tls;
tls.Rule =
Empty |
_("tls") |
_("cil"); // DOCS: non-present in ECMA grammar
ddBody.Rule =
_("{") + ddItemList + _("}") |
ddItem;
ddItemList.Rule =
ddItem + _(",") + ddItemList |
ddItem;
ddItemCount.Rule =
Empty |
_("[") + int32 + _("]");
ddItem.Rule =
_("char") + _("*") + _("(") + compQstring + _(")") |
_("&") + _("(") + id + _(")") |
bytearrayhead + bytes + _(")") |
_("float32") + _("(") + float64 + _(")") + ddItemCount |
_("float64") + _("(") + float64 + _(")") + ddItemCount |
_("int64") + _("(") + int64 + _(")") + ddItemCount |
_("int32") + _("(") + int32 + _(")") + ddItemCount |
_("int16") + _("(") + int32 + _(")") + ddItemCount |
_("int8") + _("(") + int32 + _(")") + ddItemCount |
_("float32") + ddItemCount |
_("float64") + ddItemCount |
_("int64") + ddItemCount |
_("int32") + ddItemCount |
_("int16") + ddItemCount |
_("int8") + ddItemCount;
fieldInit.Rule =
_("float32") + _("(") + float64 + _(")") |
_("float64") + _("(") + float64 + _(")") |
_("float32") + _("(") + int64 + _(")") |
_("float64") + _("(") + int64 + _(")") |
_("int64") + _("(") + int64 + _(")") |
_("int32") + _("(") + int64 + _(")") |
_("int16") + _("(") + int64 + _(")") |
_("char") + _("(") + int64 + _(")") |
_("int8") + _("(") + int64 + _(")") |
_("uint8") + _("(") + int64 + _(")") | // DOCS: non-present in ECMA grammar
_("bool") + _("(") + truefalse + _(")") |
compQstring |
bytearrayhead + bytes + _(")") |
_("nullref");
bytearrayhead.Rule =
_("bytearray") + _("(");
bytes.Rule =
Empty |
hexbytes;
hexbytes.Rule =
HEXBYTE |
hexbytes + HEXBYTE;
// TODO - instr_r_head
instr_r_head.Rule = _("TODO: instr_r_head");
instr_tok_head.Rule =
INSTR_TOK;
// TODO - methodSpec
methodSpec.Rule = _("TODO: methodSpec");
instr.Rule =
INSTR_NONE |
INSTR_VAR + int32 |
INSTR_VAR + id |
INSTR_I + int32 |
INSTR_I8 + int64 |
INSTR_R + float64 |
INSTR_R + int64 |
instr_r_head + bytes + _(")") |
INSTR_BRTARGET + int32 |
INSTR_BRTARGET + id |
INSTR_METHOD + callConv + type + typeSpec + _("::") + methodName + _("(") + sigArgs0 + _(")") |
INSTR_METHOD + callConv + type + methodName + _("(") + sigArgs0 + _(")") |
INSTR_FIELD + type + typeSpec + _("::") + id |
INSTR_FIELD + type + id |
INSTR_TYPE + typeSpec |
INSTR_STRING + compQstring |
INSTR_STRING + bytearrayhead + bytes + _(")") |
INSTR_SIG + callConv + type + _("(") + sigArgs0 + _(")") |
INSTR_RVA + id |
INSTR_RVA + int32 |
instr_tok_head + ownerType |
INSTR_SWITCH + _("(") + labels + _(")") |
INSTR_PHI + int16s;
sigArgs0.Rule =
Empty |
sigArgs1;
sigArgs1.Rule =
sigArg |
sigArgs1 + _(",") + sigArg;
sigArg.Rule =
_("...") |
paramAttr + type |
paramAttr + type + id |
paramAttr + type + _("marshal") + _("(") + nativeType + _(")") |
paramAttr + type + _("marshal") + _("(") + nativeType + _(")") + id;
name1.Rule =
id |
DOTTEDNAME |
name1 + _(".") + name1;
className.Rule =
_("[") + name1 + _("]") + slashedName |
_("[") + _(".module") + name1 + _("]") + slashedName |
slashedName;
slashedName.Rule =
name1 |
slashedName + _("/") + name1;
typeSpec.Rule =
className |
_("[") + name1 + _("]") |
_("[") + _(".module") + name1 + _("]") |
type;
callConv.Rule =
_("instance") + callConv |
_("explicit") + callConv |
callKind;
callKind.Rule =
Empty |
_("default") |
_("vararg") |
_("unmanaged") + _("cdecl") |
_("unmanaged") + _("stdcall") |
_("unmanaged") + _("thiscall") |
_("unmanaged") + _("fastcall");
// TODO - nativeType
nativeType.Rule = _("TODO: nativeType");
type.Rule =
_("class") + className |
_("object") |
_("string") |
_("value") + _("class") + className |
_("valuetype") + className |
type + _("[") + _("]") |
type + ("[") + bounds1 + _("]") |
type + _("value") + _("[") + int32 + _("]") |
type + _("&") |
type + _("*") |
type + _("pinned") |
type + _("modreq") + _("(") + className + _(")") |
type + _("modopt") + _("(") + className + _(")") |
_("!") + int32 |
methodSpec + callConv + type + _("*") + _("(") + sigArgs0 + _(")") |
_("typedref") |
_("char") |
_("void") |
_("bool") |
_("int8") |
_("int16") |
_("int32") |
_("int64") |
_("float32") |
_("float64") |
_("unsigned") + _("int8") |
_("unsigned") + _("int16") |
_("unsigned") + _("int32") |
_("unsigned") + _("int64") |
_("native") + _("int") |
_("native") + _("unsigned") + _("int") |
_("native") + _("float") |
_("uint8") | // DOCS: not present in ECMA grammar
_("uint16") | // DOCS: not present in ECMA grammar
_("uint32") | // DOCS: not present in ECMA grammar
_("uint64"); // DOCS: not present in ECMA grammar
bounds1.Rule =
bound |
bounds1 + _(",") + bound;
bound.Rule =
Empty |
_("...") |
int32 |
int32 + _("...") + int32 |
int32 + _("...");
labels.Rule =
Empty |
id + _(",") + labels |
int32 + _(",") + labels |
id |
int32;
id.Rule =
ID |
SQSTRING;
// TODO - int16s
int16s.Rule = _("TODO: int16s");
int32.Rule =
INT32;
int64.Rule =
INT64;
float64.Rule =
FLOAT64 |
_("float32") + _("(") + int32 + _(")") |
_("float64") + _("(") + int64 + _(")");
secDecl.Rule =
_(".permission") + secAction + typeSpec + _("(") + nameValPairs + _(")") |
_(".permission") + secAction + typeSpec |
psetHead + bytes + _(")") |
_(".permissionset") + secAction + _("=") + _("{") + nameValPairs + _("}"); // DOCS: non-present in ECMA script
psetHead.Rule =
_(".permissionset") + secAction + _("=") + _("(");
nameValPairs.Rule =
nameValPair |
nameValPair + _(",") + nameValPairs;
nameValPair.Rule =
compQstring + _("=") + caValue |
className + _("=") + caValue; // DOCS: non-present in ECMA script
truefalse.Rule =
_("true") |
_("false");
caValue.Rule =
truefalse |
int32 |
_("int32") + ("(") + int32 + _(")") |
compQstring |
className + _("(") + _("int8") + _(":") + int32 + _(")") |
className + _("(") + _("int16") + _(":") + int32 + _(")") |
className + _("(") + _("int32") + _(":") + int32 + _(")") |
className + _("(") + int32 + _(")") |
_("{") + _("property") + _("bool") + SQSTRING + _("=") + _("bool") + _("(") + _("true") + _(")") + _("}"); // DOCS: non-present in ECMA script
secAction.Rule =
_("request") |
_("demand") |
_("assert") |
_("deny") |
_("permitonly") |
_("linkcheck") |
_("inheritcheck") |
_("reqmin") |
_("reqopt") |
_("reqrefuse") |
_("prejitgrant") |
_("prejitdeny") |
_("noncasdemand") |
_("noncaslinkdemand") |
_("noncasinheritance");
// TODO - extSourceSpec
extSourceSpec.Rule = _("TODO: extSourceSpec");
// TODO - fileDecl
fileDecl.Rule = _("TODO: fileDecl");
// TODO - hashHead
hashHead.Rule = _("TODO: hashHead");
assemblyHead.Rule =
_(".assembly") + asmAttr + name1;
asmAttr.Rule =
Empty |
asmAttr + _("noappdomain") |
asmAttr + _("noprocess") |
asmAttr + _("nomachine");
assemblyDecls.Rule =
Empty |
assemblyDecls + assemblyDecl;
assemblyDecl.Rule =
_(".hash") + _("algorithm") + int32 |
secDecl |
asmOrRefDecl;
asmOrRefDecl.Rule =
publicKeyHead + bytes + _(")") |
_(".ver") + int32 + _(":") + int32 + _(":") + int32 + _(":") + int32 |
_(".locale") + compQstring |
localeHead + bytes + _(")") |
customAttrDecl;
// TODO - publicKeyHead
publicKeyHead.Rule = _("TODO: publicKeyHead");
publicKeyTokenHead.Rule =
_(".publickeytoken") + _("=") + _("(");
// TODO - localeHead
localeHead.Rule = _("TODO: localeHead");
assemblyRefHead.Rule =
_(".assembly") + _("extern") + name1 |
_(".assembly") + _("extern") + name1 + _("as") + name1;
assemblyRefDecls.Rule =
Empty |
assemblyRefDecls + assemblyRefDecl;
assemblyRefDecl.Rule =
hashHead + bytes + _(")") |
asmOrRefDecl |
publicKeyTokenHead + bytes + _(")");
// TODO - comtypeHead
comtypeHead.Rule = _("TODO: comtypeHead");
// TODO - exportHead
exportHead.Rule = _("TODO: exportHead");
// TODO - comtypeDecls
comtypeDecls.Rule = _("TODO: comtypeDecls");
manifestResHead.Rule =
_(".mresource") + manresAttr + name1;
manresAttr.Rule =
Empty |
manresAttr + _("public") |
manresAttr + _("private");
manifestResDecls.Rule =
Empty |
manifestResDecls + manifestResDecl;
manifestResDecl.Rule =
_(".file") + name1 + _("at") + int32 |
_(".assembly") + _("extern") + name1 |
customAttrDecl;
}
//http://docs.python.org/ref/numbers.html
public static NumberLiteral CreatePythonNumber(string name) {
NumberLiteral term = new NumberLiteral(name, NumberOptions.AllowStartEndDot);
//default int types are Integer (32bit) -> LongInteger (BigInt); Try Int64 before BigInt: Better performance?
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
// term.DefaultFloatType = TypeCode.Double; -- it is default
//float type is implementation specific, thus try decimal first (higher precision)
//term.DefaultFloatTypes = new TypeCode[] { TypeCode.Decimal, TypeCode.Double };
term.AddPrefix("0x", NumberOptions.Hex);
term.AddPrefix("0", NumberOptions.Octal);
term.AddSuffix("L", TypeCode.Int64, NumberLiteral.TypeCodeBigInt);
term.AddSuffix("J", NumberLiteral.TypeCodeImaginary);
return term;
}
public CovfefeGrammar() : base(false) // true means case sensitive
{
GrammarComments = @"A Fantastic Language. Case-insensitive.";
//comments
CommentTerminal eolComment = new CommentTerminal("eolComment", "//", "\n", "\r");
NonGrammarTerminals.Add(eolComment);
//numbers
NumberLiteral integer = new NumberLiteral("integer", NumberOptions.IntOnly | NumberOptions.AllowSign, typeof(IntegerAstNode));
integer.DefaultIntTypes = new TypeCode[] { TypeCode.Int32 };
integer.AddPrefix("0b", NumberOptions.Binary);
integer.AddPrefix("0x", NumberOptions.Hex);
//identifier
IdentifierTerminal label_terminal = new IdentifierTerminal("label_terminal");
//keywords
KeyTerm TRIGGER = ToTerm("trigger");
KeyTerm OPENBRACE = ToTerm("{");
KeyTerm CLOSEBRACE = ToTerm("}");
KeyTerm CUCK = ToTerm("cuck");
KeyTerm GRAB = ToTerm("grab");
KeyTerm ASSIGNOR = ToTerm("=");
KeyTerm ADD = ToTerm("+++");
KeyTerm SUB = ToTerm("---");
KeyTerm BING = ToTerm("bing");
KeyTerm BONG = ToTerm("bong");
KeyTerm SHITPOST = ToTerm("shitpost");
KeyTerm BTFO = ToTerm("btfo");
KeyTerm YERFIRED = ToTerm("yerfired");
KeyTerm IF = ToTerm("if");
KeyTerm OPENPAREN = ToTerm("(");
KeyTerm CLOSEPAREN = ToTerm(")");
KeyTerm EQUALS = ToTerm("==");
KeyTerm CATERPILLAR = ToTerm("caterpillar");
KeyTerm IMPORT = ToTerm("import");
//label
NonTerminal label = new NonTerminal("label", typeof(LabelAstNode));
label.Rule = label_terminal;
//labels
NonTerminal labels = new NonTerminal("labels");
labels.Rule = MakeStarRule(labels, "," + label);
//operators
NonTerminal @operator = new NonTerminal("operator", typeof(OperatorAstNode));
@operator.Rule = ADD | SUB;
//lValue
NonTerminal lValue = new NonTerminal("lValue", typeof(LValueAstNode));
lValue.Rule = (label | integer) | ((label | integer) + @operator + (label | integer));
//lValues
NonTerminal lValues = new NonTerminal("lValues");
lValues.Rule = MakeStarRule(lValues, "," + lValue);
//assignment
NonTerminal assignment = new NonTerminal("assignment", typeof(AssignmentAstNode));
assignment.Rule = label + ASSIGNOR + lValue;
//cuck
NonTerminal cuck = new NonTerminal("cuck", typeof(CuckAstNode));
cuck.Rule = CUCK + label + (ASSIGNOR + lValue | Empty);
//pop
NonTerminal pop = new NonTerminal("grab", typeof(GrabAstNode));
pop.Rule = GRAB + label;
//bing
NonTerminal bing = new NonTerminal("bing", typeof(BingAstNode));
bing.Rule = BING + label;
//bong
NonTerminal bong = new NonTerminal("bong", typeof(BongAstNode));
bong.Rule = BONG + label;
//shitpost
NonTerminal shitpost = new NonTerminal("shitpost", typeof(ShitPostAstNode));
//shitpost.Rule = SHITPOST + ((OPENPAREN + lValue + CLOSEPAREN) | Empty);
shitpost.Rule = SHITPOST + OPENPAREN + lValue + CLOSEPAREN;
//btfo
NonTerminal btfo = new NonTerminal("btfo", typeof(BtfoAstNode));
btfo.Rule = BTFO + ((OPENPAREN + lValue + CLOSEPAREN) | Empty);
//yerfired
NonTerminal yerfired = new NonTerminal("yerfired", typeof(YerFiredAstNode));
yerfired.Rule = YERFIRED;
//statements
NonTerminal statements = new NonTerminal("statements");
//test
NonTerminal test = new NonTerminal("test", typeof(TestAstNode));
@test.Rule = EQUALS;
//if
NonTerminal @if = new NonTerminal("if", typeof(IfAstNode));
@if.Rule = IF + OPENPAREN + lValue + test + lValue + CLOSEPAREN + OPENBRACE + statements + CLOSEBRACE;
//caterpillar
NonTerminal caterpillar = new NonTerminal("caterpillar", typeof(CaterpillarAstNode));
caterpillar.Rule = CATERPILLAR + OPENBRACE + statements + CLOSEBRACE;
//arguments
NonTerminal arguments = new NonTerminal("arguments", typeof(ArgumentsAstNode));
arguments.Rule = (lValue | Empty) + lValues;
//call
NonTerminal call = new NonTerminal("call", typeof(CallAstNode));
call.Rule = label + OPENPAREN + arguments + CLOSEPAREN;
//statement
NonTerminal statement = new NonTerminal("statement", typeof(StatementAstNode));
statement.Rule = cuck | assignment | bing | bong | shitpost | btfo | yerfired | @if | caterpillar | call | pop;
//build statements rule last to include blocks
statements.Rule = MakeStarRule(statements, statement);
//parameters
NonTerminal parameters = new NonTerminal("parameters", typeof(ParametersAstNode));
parameters.Rule = (label | Empty) + labels;
//trigger
NonTerminal trigger = new NonTerminal("trigger", typeof(TriggerAstNode));
trigger.Rule = TRIGGER + label + OPENPAREN + parameters + CLOSEPAREN + OPENBRACE + (statements) + CLOSEBRACE;
//triggers
NonTerminal triggers = new NonTerminal("triggers");
triggers.Rule = MakeStarRule(triggers, trigger);
/*
* //import
* NonTerminal import = new NonTerminal("import", typeof(ImportAstNode));
* import.Rule = IMPORT + label + OPENPAREN + parameters + CLOSEPAREN;
*
* //imports
* NonTerminal imports = new NonTerminal("imports");
* imports.Rule = MakeStarRule(imports, import);
*/
//file structure
NonTerminal source_file = new NonTerminal("source_file", typeof(SourceFileAstNode));
source_file.Rule = triggers;
Root = source_file;
LanguageFlags |= LanguageFlags.CreateAst;
}
public PCodeGrammar()
: base(false)
{
// ReSharper disable InconsistentNaming
this.LanguageFlags = LanguageFlags.NewLineBeforeEOF;
var integerLiteral = new NumberLiteral("INTEGER");
integerLiteral.Options |= NumberOptions.IntOnly;
integerLiteral.DefaultIntTypes = new[]
{
TypeCode.Int64
};
integerLiteral.AddPrefix("0x", NumberOptions.Hex);
var floatLiteral = new NumberLiteral("FLOAT")
{
DefaultIntTypes = new[]
{
TypeCode.Double
},
};
var stringLiteral = new StringLiteral("STRING",
"\"",
StringOptions.AllowsLineBreak |
StringOptions.AllowsOctalEscapes |
StringOptions.AllowsXEscapes);
var name = new IdentifierTerminal("NAME", IdOptions.IsNotKeyword);
var comment = new CommentTerminal("comment", "#", "\n");
var comma = ToTerm(",", "comma");
var colon = ToTerm(":", "colon");
var staticLiteral = new NonTerminal("STATIC")
{
Rule = this.ToTerm("Activation") | "AdjustLevel" | "Application" |
"ClickableTracker" | "Contact" | "Context" | "CurNode" |
"CurrentState" | "curStateTracker" | "dependencyVal" |
"Encounter" | "Encounter2" | "EncounterDef" | "EncounterTemplate" |
"Entity" | "Forever" | "GenData" | "GenInstanceColumn" |
"GenInstanceColumnCount" | "GenInstanceCount" | "GenInstanceData" |
"GenInstanceNumber" | "GenInstanceRow" | "GenInstanceRowCount" |
"HP" | "HPMax" | "iLevelINTERNAL_LayerFSM" | "IsDisabled" |
"IsSelectable" | "IsVisible" | "me" | "Mission" |
"MissionClickable" | "MissionDef" | "Mod" | "ModDef" | "MouseX" |
"MouseY" | "MouseZ" | "NewTreeLevel" | "NumTeamMembers" |
"ParentValue" | "pathOldValue" | "Player" | "Power" | "PowerDef" |
"PowerMax" | "PowerVolumeData" | "Prediction" | "RowData" |
"Self" | "Source" | "SpawnLocation" | "TableValue" | "Target" |
"TargetEnt" | "TeamHP" | "TeamHPMax" | "Volume",
};
var PROGRAM = new NonTerminal("PROGRAM");
var LINE = new NonTerminal("LINE");
var STATEMENT = new NonTerminal("STATEMENT");
var VALUE = new NonTerminal("VALUE");
var LABEL = new NonTerminal("LABEL");
var LABEL_OPT = new NonTerminal("LABEL_OPT");
var STATEMENT_OPT = new NonTerminal("STATEMENT_OPT");
var COMMENT_OPT = new NonTerminal("COMMENT_OPT");
var BINARY = new NonTerminal("BINARY");
var OP_NON = new NonTerminal("OP_NON");
var OP_INT = new NonTerminal("OP_INT");
var OP_FLT = new NonTerminal("OP_FLT");
var OP_INS = new NonTerminal("OP_INS");
var OP_FLS = new NonTerminal("OP_FLS");
var OP_VEC = new NonTerminal("OP_VEC");
var OP_VC4 = new NonTerminal("OP_VC4");
var OP_MAT = new NonTerminal("OP_MAT");
var OP_QAT = new NonTerminal("OP_QAT");
var OP_STR = new NonTerminal("OP_STR");
var OP_FIL = new NonTerminal("OP_FIL");
var OP_ENT = new NonTerminal("OP_ENT");
var OP_PTR = new NonTerminal("OP_PTR");
var OP_ADD = new NonTerminal("OP_ADD");
var OP_SUB = new NonTerminal("OP_SUB");
var OP_NEG = new NonTerminal("OP_NEG");
var OP_MUL = new NonTerminal("OP_MUL");
var OP_DIV = new NonTerminal("OP_DIV");
var OP_EXP = new NonTerminal("OP_EXP");
var OP_BAN = new NonTerminal("OP_BAN");
var OP_BOR = new NonTerminal("OP_BOR");
var OP_BNT = new NonTerminal("OP_BNT");
var OP_BXR = new NonTerminal("OP_BXR");
var OP_O_P = new NonTerminal("OP_O_P");
var OP_C_P = new NonTerminal("OP_C_P");
var OP_O_B = new NonTerminal("OP_O_B");
var OP_C_B = new NonTerminal("OP_C_B");
var OP_EQU = new NonTerminal("OP_EQU");
var OP_LES = new NonTerminal("OP_LES");
var OP_NGR = new NonTerminal("OP_NGR");
var OP_GRE = new NonTerminal("OP_GRE");
var OP_NLE = new NonTerminal("OP_NLE");
var OP_FUN = new NonTerminal("OP_FUN");
var OP_IDS = new NonTerminal("OP_IDS");
var OP_S_V = new NonTerminal("OP_S_V");
var OP_COM = new NonTerminal("OP_COM");
var OP_AND = new NonTerminal("OP_AND");
var OP_ORR = new NonTerminal("OP_ORR");
var OP_NOT = new NonTerminal("OP_NOT");
var OP_IF_ = new NonTerminal("OP_IF_");
var OP_ELS = new NonTerminal("OP_ELS");
var OP_ELF = new NonTerminal("OP_ELF");
var OP_EIF = new NonTerminal("OP_EIF");
var OP_RET = new NonTerminal("OP_RET");
var OP_RZ_ = new NonTerminal("OP_RZ_");
var OP_J__ = new NonTerminal("OP_J__");
var OP_JZ_ = new NonTerminal("OP_JZ_");
var OP_CON = new NonTerminal("OP_CON");
var OP_STM = new NonTerminal("OP_STM");
var OP_RP_ = new NonTerminal("OP_RP_");
var OP_OBJ = new NonTerminal("OP_OBJ");
var OP_L_M = new NonTerminal("OP_L_M");
var OP_L_S = new NonTerminal("OP_L_S");
this.Root = PROGRAM;
VALUE.Rule = integerLiteral | stringLiteral;
PROGRAM.Rule = MakePlusRule(PROGRAM, LINE);
LINE.Rule = LABEL_OPT + STATEMENT_OPT + COMMENT_OPT + NewLine;
LABEL_OPT.Rule = LABEL | Empty;
STATEMENT_OPT.Rule = STATEMENT | Empty;
COMMENT_OPT.Rule = comment | Empty;
STATEMENT.Rule =
OP_NON | OP_INT | OP_FLT |
OP_INS | OP_FLS |
OP_VEC | OP_VC4 |
/*OP_MAT | OP_QAT |*/
OP_STR | /*OP_FIL |*/
/*OP_ENT | OP_PTR |*/
OP_ADD | OP_SUB | OP_NEG | OP_MUL | OP_DIV | OP_EXP |
OP_BAN | OP_BOR | OP_BNT | OP_BXR |
OP_O_P | OP_C_P |
OP_O_B | OP_C_B |
OP_EQU | OP_LES | OP_NGR | OP_GRE | OP_NLE |
OP_FUN |
OP_IDS | OP_S_V |
OP_COM |
OP_AND | OP_ORR | OP_NOT |
OP_IF_ | OP_ELS | OP_ELF | OP_EIF |
OP_RET | OP_RZ_ |
OP_J__ | OP_JZ_ |
OP_CON |
OP_STM |
OP_RP_ |
OP_OBJ |
OP_L_M | OP_L_S;
LABEL.Rule = name + ":";
BINARY.Rule = "binary";
OP_NON.Rule = "null";
OP_INT.Rule = "int" + integerLiteral;
OP_FLT.Rule = "float" + floatLiteral;
OP_INS.Rule = "ints" + stringLiteral; // todo: fixme
OP_FLS.Rule = "floats" + stringLiteral; // todo: fixme
OP_VEC.Rule = "vec3" + stringLiteral; // todo: fixme
OP_VC4.Rule = "vec4" + stringLiteral; // todo: fixme
OP_STR.Rule = "str" + stringLiteral;
OP_ADD.Rule = "add";
OP_SUB.Rule = "sub";
OP_NEG.Rule = "neg";
OP_MUL.Rule = "mul";
OP_DIV.Rule = "div";
OP_EXP.Rule = "exp";
OP_BAN.Rule = BINARY + "and";
OP_BOR.Rule = BINARY + "or";
OP_BNT.Rule = BINARY + "not";
OP_BXR.Rule = BINARY + "xor";
OP_O_P.Rule = "(";
OP_C_P.Rule = ")";
OP_O_B.Rule = "[";
OP_C_B.Rule = "]";
OP_EQU.Rule = "equals";
OP_LES.Rule = "less";
OP_NGR.Rule = "notgreater";
OP_GRE.Rule = "greater";
OP_NLE.Rule = "notless";
OP_FUN.Rule = "call" + stringLiteral;
OP_IDS.Rule = "ident" + stringLiteral;
OP_S_V.Rule = "static" + staticLiteral;
OP_COM.Rule = "comma";
OP_AND.Rule = "and";
OP_ORR.Rule = "or";
OP_NOT.Rule = "not";
OP_IF_.Rule = "if";
OP_ELS.Rule = "else";
OP_ELF.Rule = "elif";
OP_EIF.Rule = "endif";
OP_RET.Rule = "return";
OP_RZ_.Rule = "retifzero";
OP_J__.Rule = "j" + name;
OP_JZ_.Rule = "jz" + name;
OP_CON.Rule = "continue";
OP_STM.Rule = ";";
OP_RP_.Rule = "rootpath" + stringLiteral;
OP_OBJ.Rule = "objpath" + stringLiteral;
OP_L_M.Rule = "locm" + stringLiteral; // todo: fixme
OP_L_S.Rule = "locs" + stringLiteral; // todo: fixme
this.MarkPunctuation(",", ":");
this.MarkTransient(
VALUE,
LABEL_OPT,
STATEMENT_OPT,
COMMENT_OPT,
staticLiteral);
// ReSharper restore InconsistentNaming
}
public UnrealscriptGrammar() : base(false)
{
#region Identifiers
var Identifier = new IdentifierTerminal("Identifer");
#endregion
#region Literals
// Number
var Number = new NumberLiteral("Number", NumberOptions.AllowSign)
{
DefaultIntTypes = new[] { TypeCode.Int32 },
DefaultFloatType = TypeCode.Single
};
Number.AddPrefix("0x", NumberOptions.Hex);
// Integer
var Integer = new NumberLiteral("Integer", NumberOptions.IntOnly);
// String
var String = new StringLiteral("String", "\"", StringOptions.None);
// Name
var Name = new StringLiteral("Name", "'");
// Vector
var VectKeyTerm = ToTerm("vect");
var Vector = new NonTerminal("Vector", typeof(VectorNode));
Vector.Rule = VectKeyTerm + "(" + Number + "," + Number + "," + Number + ")";
var Literal = new NonTerminal("Literal");
Literal.Rule = Number | String | Name | "true" | "false" | "none" | Vector;
#endregion
var VarEdit = new NonTerminal("VarEdit", typeof(AuxiliaryNode));
VarEdit.Rule = "(" + Identifier + ")" |
"(" + ")";
var VarEditOpt = new NonTerminal("VarEdit?", typeof(AuxiliaryNode));
VarEditOpt.Rule = Empty | VarEdit;
var Extends = new NonTerminal("Extends", typeof(AuxiliaryNode));
Extends.Rule = ToTerm("extends") + Identifier;
var ExtendsOpt = Extends.Q();
var CompilerDirective = new RegexBasedTerminal("#(\\w+)\\s+(.+)");
#region Variables
var VarModifier = new NonTerminal("VarModifier", typeof(Modifier));
VarModifier.Rule = ToTerm("config") |
ToTerm("const") |
ToTerm("editconst") |
ToTerm("editconstarray") |
ToTerm("editinline") |
ToTerm("export") |
ToTerm("noexport") |
ToTerm("globalconfig") |
ToTerm("input") |
ToTerm("localized") |
ToTerm("native") |
ToTerm("private") |
ToTerm("protected") |
ToTerm("transient") |
ToTerm("travel");
var VarModifiers = new NonTerminal("VarModifier*", typeof(AuxiliaryNode));
VarModifiers.Rule = MakeStarRule(VarModifiers, VarModifier);
#endregion
#region Comments
var SingleLineComment = new CommentTerminal("SingleLineComment", "//", "\n");
var MultiLineComment = new CommentTerminal("MultiLineComment", "/*", "*/");
NonGrammarTerminals.Add(SingleLineComment);
NonGrammarTerminals.Add(MultiLineComment);
#endregion
var Identifiers = new NonTerminal("Identifiers", typeof(AuxiliaryNode));
Identifiers.Rule = MakePlusRule(Identifiers, ToTerm(","), Identifier);
var Const = new NonTerminal("Const", typeof(Const));
Const.Rule = ToTerm("const") + Identifier + "=" + Literal + ";";
var PreClassDeclaration = new NonTerminal("PreClassDeclaration");
PreClassDeclaration.Rule = Const;
var Declarations = new NonTerminal("PreClassDeclaration*", typeof(AuxiliaryNode));
Declarations.Rule = MakeStarRule(Declarations, PreClassDeclaration);
#region Types
var ByteTerm = ToTerm("byte");
var IntTerm = ToTerm("int");
var BoolTerm = ToTerm("bool");
var FloatTerm = ToTerm("float");
var StringTerm = ToTerm("string");
var NameTerm = ToTerm("name");
var Type = new NonTerminal("Type", typeof(Ast.Type));
var Array = new NonTerminal("Array", typeof(Ast.Array));
Array.Rule = ToTerm("array") + "<" + Type + ">";
var Class = new NonTerminal("Class", typeof(Ast.Class));
Class.Rule = ToTerm("class") + "<" + Identifier + ">"; // TODO: won't work for A.Type
var PackageIdentifier = new NonTerminal("PackageIdentifier");
PackageIdentifier.Rule = Identifier + "." + Identifier;
Type.Rule = ByteTerm | IntTerm | BoolTerm | FloatTerm | StringTerm | NameTerm | Array | Class | Identifier | PackageIdentifier;
#endregion
var ArraySize = new NonTerminal("ArraySize", typeof(AuxiliaryNode));
ArraySize.Rule = Empty |
"[" + Integer + "]" |
"[" + Identifier + "]";
#region Struct
var StructVarEdit = new NonTerminal("StructVarEdit");
StructVarEdit.Rule = Empty | "(" + ")";
var StructVar = new NonTerminal("StructVar", typeof(Variable));
StructVar.Rule = ToTerm("var") + StructVarEdit + Type + Identifier + ArraySize + ";";
var StructVars = new NonTerminal("StructVar+");
StructVars.Rule = MakePlusRule(StructVars, StructVar);
var Struct = new NonTerminal("Struct", typeof(Struct));
Struct.Rule = ToTerm("struct") + Identifier + "{" + StructVars + "}";
var StructStatement = new NonTerminal("StructStatement", typeof(AuxiliaryNode));
StructStatement.Rule = Struct + ";";
#endregion
// Enum
var EnumTerm = ToTerm("enum");
var Enum = new NonTerminal("Enum", typeof(Ast.Enum));
Enum.Rule = EnumTerm + Identifier + "{" + Identifiers + "}";
var EnumStatement = new NonTerminal("EnumStatement", typeof(AuxiliaryNode));
EnumStatement.Rule = Enum + ";";
#region Variables
// Variables
var VarType = new NonTerminal("VarType");
var VarName = new NonTerminal("VarName", typeof(VariableName));
var VarNames = new NonTerminal("VarName+", typeof(AuxiliaryNode));
var Var = new NonTerminal("Var", typeof(Variable));
var Vars = new NonTerminal("Var*", typeof(AuxiliaryNode));
VarType.Rule = Type | Struct | Enum;
VarName.Rule = Identifier + ArraySize;
VarNames.Rule = MakePlusRule(VarNames, ToTerm(","), VarName);
Var.Rule = ToTerm("var") + VarEditOpt + VarModifiers + VarType + VarNames + ";";
Vars.Rule = MakeStarRule(Vars, Var);
#endregion
var VarStructEnumConst = new NonTerminal("VarStructEnumConst");
VarStructEnumConst.Rule = Var | StructStatement | EnumStatement | Const;
var PreFunctionDeclarations = new NonTerminal("VarStructEnumConst*", typeof(AuxiliaryNode));
PreFunctionDeclarations.Rule = MakeStarRule(PreFunctionDeclarations, VarStructEnumConst);
// MEAT OF THE LOGIC!
var Reference = new NonTerminal("Reference"); // TODO: probably won't work, my guess
Reference.Rule = Identifier + Name |
ToTerm("class") + Name;
var Allocation = new NonTerminal("Allocation");
Allocation.Rule = ToTerm("new") + Reference;
var Atom = new NonTerminal("Atom");
Atom.Rule = Identifier | Literal | Reference | Class | Allocation;
var Primary = new NonTerminal("Primary");
var ExpressionParen = new NonTerminal("ExpressionParen");
var Expression = new NonTerminal("Expression");
Expression.Rule = Primary | ExpressionParen;
ExpressionParen.Rule = "(" + Expression + ")";
var Default = new NonTerminal("Default");
Default.Rule = ToTerm("default") + "." + Identifier;
var Subscription = new NonTerminal("Subscription");
Subscription.Rule = Primary + "[" + Expression + "]";
var Arguments = new NonTerminal("Argument*");
Arguments.Rule = MakeStarRule(Arguments, ToTerm(","), Expression.Q());
var Call = new NonTerminal("Call");
Call.Rule = Identifier + "(" + Arguments + ")" |
Class + "(" + Arguments + ")"; // TODO: what's this one for?
var SuperCall = new NonTerminal("SuperCall");
SuperCall.Rule = ToTerm("super") + "." + Call |
ToTerm("super") + "(" + Identifier + ")" + "." + Call;
var StaticCall = new NonTerminal("StaticCall");
StaticCall.Rule = Primary + "." + ToTerm("static") + "." + Call |
ToTerm("static") + "." + Call;
var GlobalCall = new NonTerminal("GlobalCall");
GlobalCall.Rule = ToTerm("global") + "." + Call;
var PreUnaryOperator = new NonTerminal("PreUnaryOperator", ToTerm("-") | ToTerm("!") | ToTerm("++") | ToTerm("--") | ToTerm("^"));
var PostUnaryOperator = new NonTerminal("PostUnaryOperator", ToTerm("++") | ToTerm("--"));
var UnaryOp = new NonTerminal("UnaryOp");
UnaryOp.Rule = PreUnaryOperator + Expression |
Expression + PostUnaryOperator;
var BinaryOperator = new NonTerminal("BinaryOperator");
BinaryOperator.Rule = ToTerm("==") |
ToTerm("!=") |
ToTerm("<=") |
ToTerm(">=") |
ToTerm("~=") |
ToTerm("%") |
ToTerm("*") |
ToTerm("/") |
ToTerm("+") |
ToTerm("-") |
ToTerm("<") |
ToTerm(">") |
ToTerm("$") |
ToTerm("@") |
ToTerm("||") |
ToTerm("+=") |
ToTerm("-=") |
ToTerm("*=") |
ToTerm("/=") |
ToTerm("dot") |
ToTerm("&&") |
ToTerm(">>") |
ToTerm("<<") |
ToTerm("<<<") |
ToTerm(">>>") |
ToTerm("**") |
ToTerm("cross") |
ToTerm("&") |
ToTerm("|") |
ToTerm("^") |
ToTerm("^^");
var AssignmentOperator = new NonTerminal("AssignmentOperator");
AssignmentOperator.Rule = ToTerm("=") | ToTerm("$=") | ToTerm("@=");
var Target = new NonTerminal("Target");
var Attribute = new NonTerminal("Attribute");
Target.Rule = Identifier | Attribute | Default | Subscription;
var Assignment = new NonTerminal("Assignment");
Assignment.Rule = Target + AssignmentOperator + Expression;
var BinaryOp = new NonTerminal("BinaryOp", Expression + BinaryOperator + Expression);
Primary.Rule = Atom | Attribute | Default | Subscription | SuperCall | StaticCall | GlobalCall | Call | UnaryOp | BinaryOp | ExpressionParen;
Attribute.Rule = Primary + "." + Primary;
var Return = new NonTerminal("Return");
Return.Rule = ToTerm("return") + Expression.Q();
var SimpleStatement = new NonTerminal("SimpleStatement");
SimpleStatement.Rule = Return | ToTerm("break") | ToTerm("continue") | Assignment /*| Goto*/ | Expression;
var SimpleStatements = new NonTerminal("SimpleStatements");
SimpleStatements.Rule = MakeStarRule(SimpleStatements, ToTerm(","), SimpleStatement);
var Codeline = new NonTerminal("Codeline");
Codeline.Rule = SimpleStatement + ";";
var Statement = new NonTerminal("Statement");
var CompoundStatement = new NonTerminal("CompoundStatement");
Statement.Rule = Codeline | Const | CompoundStatement /* | Label*/;
var Statements = new NonTerminal("Statements");
Statements.Rule = MakeStarRule(Statements, Statement);
var For = new NonTerminal("For");
For.Rule = ToTerm("for") + "(" + SimpleStatements + ";" + Expression.Q() + ";" + SimpleStatement + ")" + "{" + Statements + "}" |
ToTerm("for") + "(" + SimpleStatements + ";" + Expression.Q() + ";" + SimpleStatement + ")" + Statement;
var ForEach = new NonTerminal("ForEeach");
ForEach.Rule = ToTerm("foreach") + Primary + Statement |
ToTerm("foreach") + Primary + "{" + Statements + "}";
var Until = new NonTerminal("Until");
Until.Rule = ToTerm("until") + "(" + Expression + ")" + ToTerm(";").Q();
var Do = new NonTerminal("Do");
Do.Rule = ToTerm("do") + "{" + Statements + "}" + Until.Q();
var While = new NonTerminal("While");
While.Rule = ToTerm("while") + "(" + Expression + ")" + Statement |
ToTerm("while") + "(" + Expression + ")" + "{" + Statements + "}";
var ElseIf = new NonTerminal("ElseIf");
ElseIf.Rule = ToTerm("else") + ToTerm("if") + "(" + Expression + ")" + Statement |
ToTerm("else") + ToTerm("if") + "(" + Expression + ")" + "{" + Statements + "}";
var ElseIfs = new NonTerminal("ElseIf*");
ElseIf.Rule = MakeStarRule(ElseIfs, ElseIf);
var Else = new NonTerminal("Else");
Else.Rule = ToTerm("else") + Statement |
ToTerm("else") + "{" + Statements + "}";
var If = new NonTerminal("If");
If.Rule = ToTerm("if") + "(" + Expression + ")" + Statement + ElseIfs + Else.Q() |
ToTerm("if") + "(" + Expression + ")" + "{" + Statements + "}" + ElseIfs + Else.Q();
var DefaultCaseLabel = new RegexBasedTerminal("default\\s*:");
var SwitchCase = new NonTerminal("SwitchCase");
SwitchCase.Rule = ToTerm("case") + Atom + ":" + Statements |
DefaultCaseLabel + Statements;
var SwitchCases = new NonTerminal("SwitchCase*");
SwitchCases.Rule = MakeStarRule(SwitchCases, SwitchCase);
var Switch = new NonTerminal("Switch");
Switch.Rule = ToTerm("switch") + "(" + Expression + ")" + "{" + SwitchCases + "}";
CompoundStatement.Rule = For | ForEach | While | If | Switch | Do;
#region Functions
var Local = new NonTerminal("Local", typeof(Local));
Local.Rule = ToTerm("local") + Type + VarNames + ";";
var Locals = new NonTerminal("Local*", typeof(AuxiliaryNode));
Locals.Rule = MakeStarRule(Locals, Local);
var Ignores = new NonTerminal("Ignores", typeof(AuxiliaryNode));
Ignores.Rule = ToTerm("ignores") + Identifiers;
var FunctionModifier = new NonTerminal("FunctionModifier");
FunctionModifier.Rule = ToTerm("exec") |
ToTerm("final") |
ToTerm("iterator") |
ToTerm("latent") |
ToTerm("native") |
ToTerm("simulated") |
ToTerm("singular") |
ToTerm("static") |
ToTerm("private") |
ToTerm("protected");
var FunctionModifiers = new NonTerminal("FunctionModifier*", typeof(AuxiliaryNode));
FunctionModifiers.Rule = MakeStarRule(FunctionModifiers, FunctionModifier);
var FunctionType = new NonTerminal("FunctionType");
FunctionType.Rule = ToTerm("function") | ToTerm("event");
var FunctionArgumentModifer = new NonTerminal("FunctionArgumentModifier");
FunctionArgumentModifer.Rule = ToTerm("coerce") | ToTerm("optional") | ToTerm("out");
var FunctionArgumentModifers = new NonTerminal("FunctionArgumentModifer*", typeof(AuxiliaryNode));
FunctionArgumentModifers.Rule = MakeStarRule(FunctionArgumentModifers, FunctionArgumentModifer);
var FunctionArgument = new NonTerminal("FunctionArgument", typeof(FunctionArgument));
FunctionArgument.Rule = FunctionArgumentModifers + Type + Identifier + ArraySize;
var FunctionArguments = new NonTerminal("FunctionArgument*", typeof(AuxiliaryNode));
FunctionArguments.Rule = MakeStarRule(FunctionArguments, ToTerm(","), FunctionArgument);
var FunctionDefinition = new NonTerminal("FunctionDefinition", typeof(Function));
FunctionDefinition.Rule = FunctionModifiers + FunctionType + FunctionModifiers + Type + Identifier + "(" + FunctionArguments + ")" |
FunctionModifiers + FunctionType + FunctionModifiers + Identifier + "(" + FunctionArguments + ")";
var FunctionDeclaration = new NonTerminal("FunctionDeclaration", typeof(FunctionDeclaration));
FunctionDeclaration.Rule = FunctionDefinition + ";" |
FunctionDefinition + "{" + Locals + Statements + "}";
#endregion
#region States
var StateDeclaration = new NonTerminal("StateDeclaration", typeof(AuxiliaryNode));
StateDeclaration.Rule = Const | FunctionDeclaration;
var StateDeclarations = new NonTerminal("StateDeclaration*", typeof(AuxiliaryNode));
StateDeclarations.Rule = MakeStarRule(StateDeclarations, StateDeclaration);
var Label = new NonTerminal("Label");
Label.Rule = Identifier + ":" + Statements;
var LabelOpt = new NonTerminal("LabelOpt");
LabelOpt.Rule = Label.Q();
var State = new NonTerminal("State", typeof(AuxiliaryNode));
var StateModifier = new NonTerminal("StateModifier");
var StateModifiers = new NonTerminal("StateModifier*", typeof(AuxiliaryNode));
StateModifier.Rule = ToTerm("simulated") | ToTerm("auto");
StateModifiers.Rule = MakeStarRule(StateModifiers, StateModifier);
State.Rule = StateModifiers + ToTerm("state") + Identifier + ExtendsOpt + "{" + Ignores.Q() + StateDeclarations + LabelOpt + "}";
#endregion
// funcstateconst
var FunctionStateConst = new NonTerminal("FunctionStateConst");
FunctionStateConst.Rule = FunctionDeclaration | Const | State; // TODO: add state
var FuncStateConstDeclarations = new NonTerminal("FuncStateConstDeclarations", typeof(AuxiliaryNode));
FuncStateConstDeclarations.Rule = MakeStarRule(Declarations, FunctionStateConst);
var ClassModifier = new NonTerminal("ClassModifier", typeof(ClassDeclaration.Modifier));
ClassModifier.Rule = ToTerm("abstract") |
ToTerm("cacheexempt") |
ToTerm("config") + "(" + Identifier + ")" |
ToTerm("dependson") + "(" + Identifier + ")" |
ToTerm("instanced") |
ToTerm("parseconfig") |
ToTerm("perobjectconfig") |
ToTerm("safereplace") |
ToTerm("transient") |
ToTerm("collapsecategories") + "(" + Identifiers + ")" |
ToTerm("dontcollapsecategories") + "(" + Identifiers + ")" |
ToTerm("editinline") |
ToTerm("noteditinline") |
ToTerm("hidecategories") + "(" + Identifiers + ")" |
ToTerm("showcategories") + "(" + Identifiers + ")" |
ToTerm("hidedropdown") |
ToTerm("placeable") |
ToTerm("notplaceable") |
ToTerm("exportstructs") |
ToTerm("native") |
ToTerm("nativereplication") |
ToTerm("noexport");
#region Replication
var Replication = new NonTerminal("Replication");
var ReplicationCondition = new NonTerminal("ReplicationCondition");
var ReplicationConditions = new NonTerminal("ReplicationCondition");
var ReplicationReliability = new NonTerminal("ReplicationReliability");
ReplicationConditions.Rule = MakeStarRule(ReplicationConditions, ReplicationCondition);
ReplicationCondition.Rule = ReplicationReliability + ToTerm("if") + "(" + Expression + ")" + Identifiers + ";";
ReplicationReliability.Rule = ToTerm("reliable") | ToTerm("unreliable");
Replication.Rule = Empty | ToTerm("replication") + "{" + ReplicationConditions + "}";
#endregion
#region DefaultProperties
var DefaultPropertiesKey = new NonTerminal("DefaultPropertiesKey", typeof(DefaultPropertiesKey));
var DefaultPropertiesAssignmentValue = new NonTerminal("DefaultPropertiesAssignmentValue");
var DefaultPropertiesAssignment = new NonTerminal("DefaultPropertiesAssignment", typeof(DefaultPropertiesAssignment));
var DefaultPropertiesAssignments = new NonTerminal("DefaultPropertiesAssignments", typeof(AuxiliaryNode));
var DefaultPropertiesObjectArguments = new NonTerminal("DefaultPropertiesObjectArguments", typeof(AuxiliaryNode));
var DefaultPropertiesArrayArgument = new NonTerminal("DefaultPropertiesArrayArgument");
var DefaultPropertiesArrayArguments = new NonTerminal("DefaultPropertiesArrayArguments", typeof(AuxiliaryNode));
var DefaultPropertiesArray = new NonTerminal("DefaultPropertiesArray");
var DefaultPropertiesDeclaration = new NonTerminal("DefaultPropertiesDeclaration");
var DefaultPropertiesDeclarations = new NonTerminal("DefaultPropertiesDeclarations", typeof(AuxiliaryNode));
var DefaultPropertiesObject = new NonTerminal("DefaultPropertiesObject");
var DefaultPropertiesObjectAssignment = new NonTerminal("DefaultPropertiesObjectAssignment");
var DefaultPropertiesObjectAssignments = new NonTerminal("DefaultPropertiesObjectAssignments", typeof(AuxiliaryNode));
var DefaultProperties = new NonTerminal("DefaultProperties", typeof(DefaultProperties));
DefaultPropertiesKey.Rule = Identifier | Identifier + "(" + Integer + ")" | Identifier + "[" + Integer + "]";
DefaultPropertiesObjectAssignment.Rule = DefaultPropertiesKey + "=" + DefaultPropertiesAssignmentValue;
DefaultPropertiesObjectAssignments.Rule = MakeStarRule(DefaultPropertiesObjectAssignments, DefaultPropertiesObjectAssignment);
DefaultPropertiesObject.Rule = ToTerm("Begin") + ToTerm("Object") + DefaultPropertiesObjectAssignments + ToTerm("End") + ToTerm("Object");
DefaultPropertiesDeclaration.Rule = DefaultPropertiesAssignment | DefaultPropertiesObject;
DefaultPropertiesDeclarations.Rule = MakeStarRule(DefaultPropertiesDeclarations, DefaultPropertiesDeclaration);
DefaultPropertiesAssignmentValue.Rule = Literal | Reference | Identifier | DefaultPropertiesObjectArguments | DefaultPropertiesArray;
DefaultPropertiesAssignment.Rule = DefaultPropertiesKey + "=" + DefaultPropertiesAssignmentValue;
DefaultPropertiesAssignments.Rule = MakeStarRule(DefaultPropertiesAssignments, ToTerm(","), DefaultPropertiesAssignment);
DefaultPropertiesObjectArguments.Rule = "(" + DefaultPropertiesAssignments + ")";
DefaultPropertiesArrayArgument.Rule = DefaultPropertiesObjectArguments |
DefaultPropertiesArrayArguments + "," + DefaultPropertiesObjectArguments;
DefaultPropertiesArrayArguments.Rule = MakeStarRule(DefaultPropertiesArrayArguments, ToTerm(","), DefaultPropertiesArrayArgument);
DefaultPropertiesArray.Rule = "(" + DefaultPropertiesArrayArguments + ")";
DefaultProperties.Rule = Empty | ToTerm("defaultproperties") + "{" + DefaultPropertiesDeclarations + "}";
#endregion
var ClassModifiers = new NonTerminal("ClassModifiers", typeof(AuxiliaryNode));
ClassModifiers.Rule = MakeStarRule(ClassModifiers, ClassModifier);
var ClassDeclaration = new NonTerminal("ClassDeclaration", typeof(ClassDeclaration));
ClassDeclaration.Rule = ToTerm("class") + Identifier + Extends + ClassModifiers + ";";
var Program = new NonTerminal("Program", typeof(Program));
Program.Rule = Declarations + ClassDeclaration + PreFunctionDeclarations + Replication + FuncStateConstDeclarations + DefaultProperties;
Root = Program;
RegisterBracePair("(", ")");
RegisterBracePair("[", "]");
//RegisterBracePair("<", ">"); // TODO: complains about matching brace
MarkPunctuation(".", ":", ";", ",", "(", ")", "<", ">", "=", "[", "]", "{", "}");
MarkTransient(Literal, PreClassDeclaration, VarType, VarStructEnumConst, FunctionModifier, FunctionArgumentModifer, Primary, Atom, DefaultPropertiesAssignmentValue, DefaultPropertiesDeclaration);
LanguageFlags = LanguageFlags.None;
}
public RefalGrammar() : base(true) // case sensitive
{
GrammarComments = "Refal-5 language interpreter based on Irony toolkit.";
// Terminals
var Number = new NumberLiteral("Number");
Number.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
Number.AddPrefix("0x", NumberOptions.Hex);
Number.AddSuffix("u", TypeCode.UInt32);
Number.AddSuffix("l", TypeCode.Int64);
Number.AddSuffix("ul", TypeCode.UInt64);
Number.Options |= NumberOptions.IntOnly;
var CharLiteral = new StringLiteral("Char", "'", StringOptions.AllowsAllEscapes);
var StringLiteral = new StringLiteral("String", "\"", StringOptions.AllowsAllEscapes);
var Identifier = new IdentifierTerminal("Identifier", "_-", "");
var LineComment = new CommentTerminal("LineComment", "*", "\n", "\r");
LineComment.ValidateToken += LineComment_ValidateToken;
var BlockComment = new CommentTerminal("BlockComment", "/*", "*/");
NonGrammarTerminals.Add(LineComment);
NonGrammarTerminals.Add(BlockComment);
// Non-terminals
var Program = new NonTerminal("Program", typeof(Program));
var Definition = new NonTerminal("Definition");
var Function = new NonTerminal("Function", typeof(DefinedFunction));
var External = new NonTerminal("External", typeof(AuxiliaryNode));
var IdentifierList = new NonTerminal("Identifier+", typeof(AuxiliaryNode));
var Block = new NonTerminal("Block", typeof(Block));
var Sentence = new NonTerminal("Sentence", typeof(Sentence));
var RSentence = new NonTerminal("RSentence", typeof(AuxiliaryNode));
var SentenceList = new NonTerminal("Sentence+", typeof(AuxiliaryNode));
var Pattern = new NonTerminal("Pattern", typeof(Pattern));
var PatternItem = new NonTerminal("PatternItem");
var PatternInParentheses = new NonTerminal("(Pattern)", typeof(ExpressionInBraces));
var Expression = new NonTerminal("Expression", typeof(Expression));
var ExpressionItem = new NonTerminal("ExpressionItem");
var ExpressionInParentheses = new NonTerminal("(Expression)", typeof(ExpressionInBraces));
var Var = new NonTerminal("Variable", Variable.CreateVariableNode);
var VarPrefix = new NonTerminal("VariablePrefix");
var VarIndex = new NonTerminal("VariableIndex");
var Symbol = new NonTerminal("Symbol", LiteralValueNodeHelper.InitNode);
var Call = new NonTerminal("Call", typeof(FunctionCall));
var FunctionName = new NonTerminal("FunctionName", typeof(AuxiliaryNode));
var WhereOrWithClause = new NonTerminal("WhereOrWithClause", typeof(Conditions));
var CommaOrAmpersand = new NonTerminal("CommaOrAmpersand");
var RWhereOrWithClause = new NonTerminal("RWhereOrWithClause", typeof(AuxiliaryNode));
var RExpressionOrWhereOrWithClause = new NonTerminal("RExpressionOrWhereOrWithClause");
var SemicolonOpt = new NonTerminal("[;]", Empty | ";");
var EntryOpt = new NonTerminal("[ENTRY]", Empty | "$ENTRY");
var Extern = new NonTerminal("Extern", ToTerm("$EXTRN") | "$EXTERN" | "$EXTERNAL");
// Rules
Root = Program;
Program.Rule = MakePlusRule(Program, Definition);
Definition.Rule = Function | External;
External.Rule = Extern + IdentifierList + ";";
IdentifierList.Rule = MakePlusRule(IdentifierList, ToTerm(","), Identifier);
Function.Rule = EntryOpt + Identifier + Block + SemicolonOpt;
Block.Rule = "{" + SentenceList + SemicolonOpt + "}";
SentenceList.Rule = MakePlusRule(SentenceList, ToTerm(";"), Sentence);
Sentence.Rule = Pattern + RSentence;
RSentence.Rule = "=" + Expression | WhereOrWithClause;
Pattern.Rule = MakeStarRule(Pattern, PatternItem);
PatternItem.Rule = Var | Symbol | PatternInParentheses;
PatternInParentheses.Rule = "(" + Pattern + ")";
Expression.Rule = MakeStarRule(Expression, ExpressionItem);
ExpressionItem.Rule = Call | Var | Symbol | ExpressionInParentheses;
ExpressionInParentheses.Rule = "(" + Expression + ")";
Var.Rule = VarPrefix + "." + VarIndex;
VarPrefix.Rule = ToTerm("e") | "s" | "t";
VarIndex.Rule = Number | Identifier;
Symbol.Rule = StringLiteral | CharLiteral | Number | "True" | "False" | Identifier;
Call.Rule = "<" + FunctionName + Expression + ">";
FunctionName.Rule = Identifier | "+" | "-" | "*" | "/";
WhereOrWithClause.Rule = CommaOrAmpersand + Expression + ":" + RWhereOrWithClause;
CommaOrAmpersand.Rule = ToTerm(",") | "&";
RWhereOrWithClause.Rule = Block // with-clause
| Pattern + RExpressionOrWhereOrWithClause; // where-clause
RExpressionOrWhereOrWithClause.Rule = ToTerm("=") + Expression | WhereOrWithClause;
// Punctuation, braces, transient terms, options
MarkPunctuation("(", ")");
MarkPunctuation("{", "}");
MarkPunctuation("<", ">");
MarkPunctuation("=", ",", "&", ";");
RegisterBracePair("(", ")");
RegisterBracePair("<", ">");
RegisterBracePair("{", "}");
MarkTransient(Definition, PatternItem, ExpressionItem, SemicolonOpt, EntryOpt, Extern, CommaOrAmpersand, VarPrefix, VarIndex, RExpressionOrWhereOrWithClause);
LanguageFlags = LanguageFlags.CreateAst | LanguageFlags.SupportsBigInt | LanguageFlags.TailRecursive;
}
protected static NumberLiteral CreateLuaNumber(string name)
{
NumberLiteral term = new NumberLiteral(name, NumberOptions.AllowStartEndDot);
//default int types are Integer (32bit) -> LongInteger (BigInt); Try Int64 before BigInt: Better performance?
term.DefaultIntTypes = new TypeCode[] { TypeCode.Int32, TypeCode.Int64, NumberLiteral.TypeCodeBigInt };
term.DefaultFloatType = TypeCode.Double; // it is default
term.AddPrefix("0x", NumberOptions.Hex);
return term;
}
public ASMGrammar()
{
this.LanguageFlags = LanguageFlags.CreateAst;
#region Lexical structure
// Comments
var comment = new CommentTerminal("Comment", ";", "\r", "\n", "\u2085", "\u2028", "\u2029");
this.NonGrammarTerminals.Add(comment);
// Literals
var stringLiteral = new StringLiteral("StringLiteral", "\"", StringOptions.AllowsAllEscapes);
var numberLiteral = new NumberLiteral("NumberLiteral");
numberLiteral.AddPrefix("0x", NumberOptions.Hex);
var identifier = new IdentifierTerminal("Label");
identifier.StartCharCategories.AddRange(new UnicodeCategory[]
{
UnicodeCategory.UppercaseLetter,
UnicodeCategory.LowercaseLetter
});
identifier.CharCategories.AddRange(identifier.StartCharCategories);
identifier.CharCategories.AddRange(new UnicodeCategory[]
{
UnicodeCategory.DecimalDigitNumber
});
// Symbols
var colon = ToTerm(":", "colon");
var comma = ToTerm(",", "comma");
var plus = ToTerm("+", "plus");
var bracketLeft = ToTerm("[", "BracketLeft");
var bracketRight = ToTerm("]", "BracketRight");
MarkPunctuation(colon, comma, plus, bracketLeft, bracketRight);
#endregion
#region Non-terminals
var lines = new NonTerminal("Lines", typeof(Ast.LinesNode));
var line = new NonTerminal("Line", typeof(Ast.LineNode));
var label = new NonTerminal("Label", typeof(Ast.LabelNode));
var instruction = new NonTerminal("Instruction", typeof(Ast.InstructionNode));
var instructionWithLabel = new NonTerminal("InstructionWithLabel", typeof(Ast.InstructionWithLabelNode));
var opcode = new NonTerminal("OpCode", typeof(Ast.DefaultNode));
var values = new NonTerminal("Values", typeof(Ast.DefaultNode));
var value = new NonTerminal("Value");
var simpleValue = new NonTerminal("SimpleValue", typeof(Ast.SimpleValueNode));
var memoryValue = new NonTerminal("MemoryValue", typeof(Ast.MemoryValueNode));
var memoryOffsetValue = new NonTerminal("MemoryOffsetValue", typeof(Ast.MemoryOffsetValueNode));
var labelValue = new NonTerminal("LabelValue", typeof(Ast.LabelValueNode));
var register = new NonTerminal("Register", typeof(Ast.DefaultNode));
var misc = new NonTerminal("Misc", typeof(Ast.DefaultNode));
#endregion
lines.Rule = MakeListRule(lines, null, line, TermListOptions.PlusList);
line.Rule = label + Eos | instruction + Eos | instructionWithLabel + Eos;
label.Rule = colon + identifier;
instructionWithLabel.Rule = label + instruction;
instruction.Rule = opcode + values;
opcode.Rule = identifier;
values.Rule = MakeListRule(values, comma, value, TermListOptions.PlusList);
value.Rule = simpleValue | memoryValue | memoryOffsetValue | labelValue;
simpleValue.Rule = stringLiteral | numberLiteral | register | misc;
memoryValue.Rule = bracketLeft + simpleValue + bracketRight;
memoryOffsetValue.Rule = bracketLeft + numberLiteral + plus + register + bracketRight;
labelValue.Rule = identifier;
register.Rule = ToTerm("A") | "B" | "C" | "X" | "Y" | "Z" | "I" | "J";
misc.Rule = ToTerm("SP") | "PC" | "O" | "POP" | "PEEK" | "PUSH";
// Set the grammar root.
this.Root = lines;
MarkTransient(value, register, misc);
}
public ASMGrammar()
{
this.LanguageFlags = LanguageFlags.CreateAst;
#region Lexical structure
// Comments
var comment = new CommentTerminal("Comment", ";", "\r", "\n", "\u2085", "\u2028", "\u2029");
this.NonGrammarTerminals.Add(comment);
// Literals
var stringLiteral = new StringLiteral("StringLiteral", "\"", StringOptions.AllowsAllEscapes);
var numberLiteral = new NumberLiteral("NumberLiteral");
numberLiteral.AddPrefix("0x", NumberOptions.Hex);
var identifier = new IdentifierTerminal("Label");
identifier.StartCharCategories.AddRange(new UnicodeCategory[]
{
UnicodeCategory.UppercaseLetter,
UnicodeCategory.LowercaseLetter
});
identifier.CharCategories.AddRange(identifier.StartCharCategories);
identifier.CharCategories.AddRange(new UnicodeCategory[]
{
UnicodeCategory.DecimalDigitNumber
});
// Symbols
var colon = ToTerm(":", "colon");
var comma = ToTerm(",", "comma");
var plus = ToTerm("+", "plus");
var bracketLeft = ToTerm("[", "BracketLeft");
var bracketRight = ToTerm("]", "BracketRight");
MarkPunctuation(colon, comma, plus, bracketLeft, bracketRight);
#endregion
#region Non-terminals
var lines = new NonTerminal("Lines", typeof(Ast.LinesNode));
var line = new NonTerminal("Line", typeof(Ast.LineNode));
var label = new NonTerminal("Label", typeof(Ast.LabelNode));
var instruction = new NonTerminal("Instruction", typeof(Ast.InstructionNode));
var instructionWithLabel = new NonTerminal("InstructionWithLabel", typeof(Ast.InstructionWithLabelNode));
var opcode = new NonTerminal("OpCode", typeof(Ast.DefaultNode));
var values = new NonTerminal("Values", typeof(Ast.DefaultNode));
var value = new NonTerminal("Value");
var simpleValue = new NonTerminal("SimpleValue", typeof(Ast.SimpleValueNode));
var memoryValue = new NonTerminal("MemoryValue", typeof(Ast.MemoryValueNode));
var memoryOffsetValue = new NonTerminal("MemoryOffsetValue", typeof(Ast.MemoryOffsetValueNode));
var labelValue = new NonTerminal("LabelValue", typeof(Ast.LabelValueNode));
var register = new NonTerminal("Register", typeof(Ast.DefaultNode));
var misc = new NonTerminal("Misc", typeof(Ast.DefaultNode));
#endregion
lines.Rule = MakeListRule(lines, null, line, TermListOptions.PlusList);
line.Rule = label + Eos | instruction + Eos | instructionWithLabel + Eos;
label.Rule = colon + identifier;
instructionWithLabel.Rule = label + instruction;
instruction.Rule = opcode + values;
opcode.Rule = identifier;
values.Rule = MakeListRule(values, comma, value, TermListOptions.PlusList);
value.Rule = simpleValue | memoryValue | memoryOffsetValue | labelValue;
simpleValue.Rule = stringLiteral | numberLiteral | register | misc;
memoryValue.Rule = bracketLeft + simpleValue + bracketRight;
memoryOffsetValue.Rule = bracketLeft + numberLiteral + plus + register + bracketRight;
labelValue.Rule = identifier;
register.Rule = ToTerm("A") | "B" | "C" | "X" | "Y" | "Z" | "I" | "J";
misc.Rule = ToTerm("SP") | "PC" | "O" | "POP" | "PEEK" | "PUSH";
// Set the grammar root.
this.Root = lines;
MarkTransient(value, register, misc);
}
