public static IdentifierTerminal CreateCSharpIdentifier(string name)
{
IdentifierTerminal id = new IdentifierTerminal(name, IdOptions.AllowsEscapes | IdOptions.CanStartWithEscape);
id.AddPrefix("@", IdOptions.IsNotKeyword);
//From spec:
//Start char is "_" or letter-character, which is a Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
id.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber //Nl
});
//Internal chars
/* From spec:
* identifier-part-character: letter-character | decimal-digit-character | connecting-character | combining-character |
* formatting-character
*/
id.CharCategories.AddRange(id.StartCharCategories); //letter-character categories
id.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//Chars to remove from final identifier
id.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return(id);
}
public static IdentifierTerminal CreateCSharpIdentifier(String name)
{
IdentifierTerminal id = new IdentifierTerminal(name, IdFlags.AllowsEscapes | IdFlags.CanStartWithEscape);
id.AddPrefix("@", IdFlags.IsNotKeyword);
//From spec:
//Start char is "_" or letter-character, which is a Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nl
id.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.UppercaseLetter, //Ul
UnicodeCategory.LowercaseLetter, //Ll
UnicodeCategory.TitlecaseLetter, //Lt
UnicodeCategory.ModifierLetter, //Lm
UnicodeCategory.OtherLetter, //Lo
UnicodeCategory.LetterNumber //Nl
});
//Internal chars
/* From spec:
identifier-part-character: letter-character | decimal-digit-character | connecting-character | combining-character |
formatting-character
*/
id.CharCategories.AddRange(id.StartCharCategories); //letter-character categories
id.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber, //Nd
UnicodeCategory.ConnectorPunctuation, //Pc
UnicodeCategory.SpacingCombiningMark, //Mc
UnicodeCategory.NonSpacingMark, //Mn
UnicodeCategory.Format //Cf
});
//Chars to remove from final identifier
id.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return id;
}
static IdentifierTerminal createClassInstanceVarName()
{
var ClassInstanceVarName = new IdentifierTerminal("ClassInstanceVarName");
ClassInstanceVarName.AllFirstChars = "@@";
ClassInstanceVarName.AddPrefix("@", IdOptions.NameIncludesPrefix);
return(ClassInstanceVarName);
}
static IdentifierTerminal createSymbolId()
{
var SymbolId = new IdentifierTerminal("SymbolId");
SymbolId.AllFirstChars = ":";
SymbolId.AddPrefix(":", IdOptions.NameIncludesPrefix);
return(SymbolId);
}
private IdentifierTerminal CreateIdentifier(string name)
{
var term = new IdentifierTerminal(name);
term.AddPrefix("@", IdOptions.IsNotKeyword);
term.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.LowercaseLetter,
UnicodeCategory.UppercaseLetter,
UnicodeCategory.TitlecaseLetter,
UnicodeCategory.ModifierLetter,
UnicodeCategory.OtherLetter,
UnicodeCategory.LetterNumber
});
term.CharCategories.AddRange(term.StartCharCategories);
term.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber
});
term.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return term;
}
private IdentifierTerminal CreateIdentifier(string name)
{
var term = new IdentifierTerminal(name);
term.AddPrefix("@", IdOptions.IsNotKeyword);
term.StartCharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.LowercaseLetter,
UnicodeCategory.UppercaseLetter,
UnicodeCategory.TitlecaseLetter,
UnicodeCategory.ModifierLetter,
UnicodeCategory.OtherLetter,
UnicodeCategory.LetterNumber
});
term.CharCategories.AddRange(term.StartCharCategories);
term.CharCategories.AddRange(new UnicodeCategory[] {
UnicodeCategory.DecimalDigitNumber
});
term.CharsToRemoveCategories.Add(UnicodeCategory.Format);
return(term);
}
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;
}
internal VariableDomainGrammar()
: base(caseSensitive: false)
{
LanguageFlags = LanguageFlags.CreateAst |
LanguageFlags.NewLineBeforeEOF;
var RANGE = ToTerm("..", "range");
var COMMA = ToTerm(",");
var OPEN_ARG = ToTerm("(");
var CLOSE_ARG = ToTerm(")");
var TABLE_REFERENCE_MARKER = ToTerm("!");
var TABLE_RANGE_SEPERATOR = ToTerm(":");
// Terminals
var numberLiteral = new NumberLiteral("number literal", NumberOptions.IntOnly, typeof(NumberLiteralNode));
var characterLiteral = new StringLiteral("character literal", "'", StringOptions.IsChar);
characterLiteral.AstConfig.NodeType = typeof(CharacterLiteralNode);
var item = new StringLiteral("string literal", "\"", StringOptions.None);
item.AstConfig.NodeType = typeof(ItemNameNode);
var functionCallArgumentStringLiteral = new IdentifierTerminal("function call argument string literal");
functionCallArgumentStringLiteral.AstConfig.NodeType = typeof(FunctionCallArgumentStringLiteralNode);
var functionName = new IdentifierTerminal("function name");
functionName.AstConfig.NodeType = typeof(FunctionNameNode);
var domainName = new IdentifierTerminal("domain name");
domainName.AddPrefix("$", IdOptions.NameIncludesPrefix);
domainName.AstConfig.NodeType = typeof(DomainNameNode);
var tableCellReference = new IdentifierTerminal("table cell reference");
tableCellReference.AstConfig.NodeType = typeof(TableCellReferenceNode);
var tableReference = new IdentifierTerminal("cell reference", IdOptions.IsNotKeyword);
tableReference.AstConfig.NodeType = typeof(TableReferenceNode);
// Non-terminals
var domainExpression = new NonTerminal("domainExpression", typeof(VariableDomainExpressionNode));
var rangeDomainExpression = new NonTerminal("range domain expression", typeof(RangeDomainExpressionNode));
var itemsList = new NonTerminal("list items", typeof(ItemsListNode));
var listDomainExpression = new NonTerminal("list domain expression", typeof(ListDomainExpressionNode));
var bandExpression = new NonTerminal("expression", typeof(BandExpressionNode));
var functionCall = new NonTerminal("function call", typeof(FunctionInvocationNode));
var functionCallArgumentList = new NonTerminal("function call arguments", typeof(FunctionArgumentListNode));
var functionCallArgument = new NonTerminal("function argument", typeof(FunctionCallArgumentNode));
var sharedDomainReference = new NonTerminal("shared domain reference", typeof(SharedDomainReferenceNode));
var tableExpression = new NonTerminal("table range", typeof(TableExpressionNode));
var cellExpression = new NonTerminal("cell expression", typeof(CellExpressionNode));
var cellRangeExpression = new NonTerminal("cell range", typeof(TableRangeExpressionNode));
var cellListExpression = new NonTerminal("cell list", typeof(TableListExpressionNode));
// BNF rules
itemsList.Rule = MakePlusRule(itemsList, COMMA, item);
listDomainExpression.Rule = itemsList;
functionCallArgument.Rule = numberLiteral | functionCallArgumentStringLiteral;
functionCall.Rule = functionName + OPEN_ARG + functionCallArgumentList + CLOSE_ARG;
functionCallArgumentList.Rule = MakePlusRule(functionCallArgumentList, COMMA, functionCallArgument);
bandExpression.Rule = numberLiteral | functionCall | characterLiteral;
rangeDomainExpression.Rule = bandExpression + RANGE + bandExpression;
sharedDomainReference.Rule = domainName;
cellRangeExpression.Rule = tableCellReference + TABLE_RANGE_SEPERATOR + tableCellReference;
cellListExpression.Rule = MakePlusRule(cellListExpression, COMMA, tableCellReference);
cellExpression.Rule = cellRangeExpression | cellListExpression;
tableExpression.Rule = tableReference + TABLE_REFERENCE_MARKER + cellExpression;
domainExpression.Rule = NewLine | rangeDomainExpression | sharedDomainReference | listDomainExpression | tableExpression;
Root = domainExpression;
MarkPunctuation(RANGE, COMMA);
MarkPunctuation(OPEN_ARG, CLOSE_ARG);
MarkPunctuation(TABLE_REFERENCE_MARKER, TABLE_RANGE_SEPERATOR);
MarkTransient(cellExpression);
RegisterBracePair("(", ")");
}
internal ConstraintExpressionGrammar()
: base(caseSensitive: false)
{
LanguageFlags = LanguageFlags.CreateAst |
LanguageFlags.NewLineBeforeEOF;
var EQUALS = ToTerm("=", "equal");
var NOT_EQUAL = ToTerm("<>", "not equal");
var ALT_NOT_EQUAL = ToTerm("!=", "alternative not equal");
var GREATER = ToTerm(">", "greater");
var GREATER_EQUAL = ToTerm(">=", "greater or equal");
var LESS = ToTerm("<", "less");
var LESS_EQUAL = ToTerm("<=", "less or equal");
var BRACKET_OPEN = ToTerm("[");
var BRACKET_CLOSE = ToTerm("]");
var PLUS = ToTerm("+");
var MINUS = ToTerm("-");
var PIPE = ToTerm("|", "pipe");
var COMMA = ToTerm(",", "separator");
var OPEN_ARG = ToTerm("(", "function call open args");
var CLOSE_ARG = ToTerm(")", "function call close args");
var SIZE_FUNC = ToTerm("size", "size function");
var RANGE = ToTerm("..", "range");
var IN = ToTerm("in");
// Terminals
var numberLiteral = new NumberLiteral("integer literal", NumberOptions.IntOnly, typeof(IntegerLiteralNode));
var characterLiteral = new StringLiteral("character literal", "'", StringOptions.IsChar);
characterLiteral.AstConfig.NodeType = typeof(CharacterLiteralNode);
var subscript = new NumberLiteral("subscript", NumberOptions.IntOnly, typeof(SubscriptNode));
var variableName = new IdentifierTerminal("variable name");
variableName.AstConfig.NodeType = typeof(VariableNameNode);
variableName.AddPrefix("$", IdOptions.IsNotKeyword);
var bucketName = new IdentifierTerminal("bucket name");
bucketName.AstConfig.NodeType = typeof(BucketNameNode);
bucketName.AddPrefix("%", IdOptions.IsNotKeyword);
var counterReference = new IdentifierTerminal("counter reference");
counterReference.AstConfig.NodeType = typeof(CounterReferenceNode);
var counterDeclaration = new IdentifierTerminal("counter declaration");
counterDeclaration.AstConfig.NodeType = typeof(CounterDeclarationNode);
var variableReference = new IdentifierTerminal("variable reference", IdOptions.IsNotKeyword);
variableReference.AstConfig.NodeType = typeof(FunctionCallArgumentStringLiteralNode);
var itemName = new IdentifierTerminal("string literal", IdOptions.IsNotKeyword);
itemName.AstConfig.NodeType = typeof(ItemNameNode);
// Non-terminals
var infixStatement = new NonTerminal("infix statement", typeof(InfixStatementNode));
var infixOperators = new NonTerminal("infix");
var subscriptStatement = new NonTerminal("subscript statement", typeof(SubscriptStatementNode));
var aggregateVariableReference = new NonTerminal("aggregateVariableReference", typeof(AggregateVariableReferenceNode));
var aggregateVariableReferenceExpression = new NonTerminal("aggregate expression", typeof(AggregateVariableReferenceExpressionNode));
var singletonVariableReference = new NonTerminal("singletonVariableReference", typeof(SingletonVariableReferenceNode));
var singletonVariableReferenceExpression = new NonTerminal("singleton expression", typeof(SingletonVariableReferenceExpressionNode));
var bucketVariableReference = new NonTerminal("bucket variable reference", typeof(BucketVariableReferenceNode));
var bucketVariableReferenceExpression = new NonTerminal("bucket variable expression", typeof(BucketVariableReferenceExpressionNode));
var binaryOperators = new NonTerminal("binary operators", "operator");
var expression = new NonTerminal("expression", typeof(ExpressionNode));
var scopeLimitStatement = new NonTerminal("scope limit statement", typeof(ScopeLimitSatementNode));
var expanderCountStatement = new NonTerminal("expander counter", typeof(ExpanderCountNode));
var scopeStatement = new NonTerminal("scope", typeof(ScopeStatementNode));
var expanderScopeStatement = new NonTerminal("expander scope", typeof(ExpanderScopeNode));
var multiCounterDeclaration = new NonTerminal("counters", typeof(CounterDeclarationListNode));
var multiExpanderScopeStatement = new NonTerminal("scopes", typeof(ScopeDeclarationListNode));
var multiExpanderStatement = new NonTerminal("multi-expander", typeof(MultiRepeaterStatementNode));
var binaryExpression = new NonTerminal("binary expression", typeof(BinaryExpressionNode));
var constraintExpression = new NonTerminal("constraint expression", typeof(ConstraintExpressionNode));
var functionName = new NonTerminal("function name", typeof(FunctionNameNode));
var functionInvocation = new NonTerminal("function call", typeof(FunctionInvocationNode));
var functionArgumentList = new NonTerminal("function arguments", typeof(FunctionArgumentListNode));
var functionArgument = new NonTerminal("function argument", typeof(FunctionCallArgumentNode));
// BNF rules
functionName.Rule = SIZE_FUNC;
functionArgument.Rule = variableReference;
functionArgumentList.Rule = MakePlusRule(functionArgumentList, COMMA, functionArgument);
functionInvocation.Rule = functionName + OPEN_ARG + functionArgumentList + CLOSE_ARG;
infixStatement.Rule = numberLiteral | counterReference;
infixOperators.Rule = PLUS | MINUS;
subscriptStatement.Rule = subscript | counterReference;
aggregateVariableReference.Rule = variableName + BRACKET_OPEN + subscriptStatement + BRACKET_CLOSE;
aggregateVariableReferenceExpression.Rule = aggregateVariableReference + infixOperators + infixStatement;
singletonVariableReference.Rule = variableName;
singletonVariableReferenceExpression.Rule = singletonVariableReference + infixOperators + infixStatement;
bucketVariableReference.Rule = bucketName + BRACKET_OPEN + subscriptStatement + BRACKET_CLOSE + ToTerm(".") + variableName;
bucketVariableReferenceExpression.Rule = bucketVariableReference + infixOperators + infixStatement;
binaryOperators.Rule = EQUALS |
NOT_EQUAL | ALT_NOT_EQUAL |
LESS | LESS_EQUAL |
GREATER | GREATER_EQUAL;
expression.Rule = aggregateVariableReference | aggregateVariableReferenceExpression |
singletonVariableReference | singletonVariableReferenceExpression |
bucketVariableReference | bucketVariableReferenceExpression |
numberLiteral |
characterLiteral |
itemName;
expanderCountStatement.Rule = functionInvocation | numberLiteral | counterReference;
scopeLimitStatement.Rule = functionInvocation | numberLiteral | counterReference;
scopeStatement.Rule = scopeLimitStatement + RANGE + scopeLimitStatement;
expanderScopeStatement.Rule = scopeStatement | expanderCountStatement;
multiCounterDeclaration.Rule = MakePlusRule(multiCounterDeclaration, COMMA, counterDeclaration);
multiExpanderScopeStatement.Rule = MakePlusRule(multiExpanderScopeStatement, COMMA, expanderScopeStatement);
multiExpanderStatement.Rule = PIPE + multiCounterDeclaration + IN + multiExpanderScopeStatement;
binaryExpression.Rule = expression + binaryOperators + expression;
constraintExpression.Rule = binaryExpression |
binaryExpression + multiExpanderStatement |
Empty;
Root = constraintExpression;
MarkTransient(binaryOperators, infixOperators, functionName);
MarkPunctuation(PIPE, RANGE);
MarkPunctuation(COMMA);
MarkPunctuation(OPEN_ARG, CLOSE_ARG);
RegisterBracePair("(", ")");
MarkReservedWords("in");
}
public SeeNoSQLGrammar()
: base(false)
{
//Terminals
var lineComment = new CommentTerminal("LINE_COMMENT", "//", "\n", "\r\n");
var blockComment = new CommentTerminal("BLOCK_COMMENT", "/*", "*/");
NonGrammarTerminals.Add(lineComment);
NonGrammarTerminals.Add(blockComment);
var number = new NumberLiteral("number");
var intVal = new NumberLiteral("integer", NumberOptions.IntOnly);
var stringLiteral = new StringLiteral("string", "'", StringOptions.AllowsDoubledQuote);
var id = new IdentifierTerminal("id") {Priority = Terminal.HighestPriority};
var param = new IdentifierTerminal("param");
param.AddPrefix("@",IdOptions.None);
param.Priority = Terminal.LowestPriority;
var constantTerminal = new ConstantTerminal("constantTerminal");
constantTerminal.Add("true", true);
constantTerminal.Add("false", false);
constantTerminal.Add("null", null);
constantTerminal.Add("MAX_STRING", new object());
constantTerminal.Add("MIN_STRING", null);
constantTerminal.Priority = Terminal.HighestPriority;
var ALL = ToTerm("ALL");
var ALLOW_STALE = ToTerm("ALLOW_STALE");
var AND = ToTerm("AND");
var BETWEEN = ToTerm("BETWEEN");
var COMMA = ToTerm(",");
var DESCENDING = ToTerm("DESCENDING");
var DOCUMENT = ToTerm("DOCUMENT");
var FALSE = ToTerm("false");
var FROM = ToTerm("FROM");
var GROUP = ToTerm("GROUP");
var GROUP_LEVEL = ToTerm("GROUP_LEVEL");
var IN = ToTerm("IN");
var INCLUDE_DOCS = ToTerm("INCLUDE_DOCS");
var INCLUSIVE_END = ToTerm("INCLUSIVE_END");
var KEY = ToTerm("KEY");
var LIMIT = ToTerm("LIMIT");
var OR = ToTerm("OR");
var QUERYOPTIONS = ToTerm("QUERYOPTIONS");
var REDUCE = ToTerm("REDUCE");
var SKIP = ToTerm("SKIP");
var TRUE = ToTerm("true");
var UNION = ToTerm("UNION");
var USING = ToTerm("USING");
var VIEW = ToTerm("VIEW");
var WHERE = ToTerm("WHERE");
var WITH = ToTerm("WITH");
//Non-terminals
var betweenStatement = new NonTerminal("between");
var binExpr = new NonTerminal("binExpr");
var binOp = new NonTerminal("binOp");
var constOperand = new NonTerminal("constOperand");
var documentStatement = new NonTerminal("documentStatement");
var expression = new NonTerminal("expression");
var fromStatement = new NonTerminal("from");
var keyArrayStatement = new NonTerminal("keyArray");
var keyList = new NonTerminal("keys");
var keyObjectStatement = new NonTerminal("keyObject");
var keyValueStatement = new NonTerminal("keyValue");
var keyStatement = new NonTerminal("key");
var query = new NonTerminal("query");
var queryOption = new NonTerminal("queryOption");
var queryOptionList = new NonTerminal("queryOptionList");
var queryOptions = new NonTerminal("queryOptions");
var stmt = new NonTerminal("stmt");
var unionStatement = new NonTerminal("unionStatement");
var term = new NonTerminal("term");
var view = new NonTerminal("view");
var whereStatement = new NonTerminal("where");
//Rules
this.Root = query;
query.Rule = MakePlusRule(query, unionStatement, stmt);
stmt.Rule = fromStatement + queryOptions + keyStatement + whereStatement | fromStatement + queryOptions;
unionStatement.Rule = UNION + ALL;
term.Rule = id | stringLiteral | number | param | constOperand;
binOp.Rule = ToTerm("=") | ">" | "<" | ">=" | "<=" | AND | OR | IN | BETWEEN;
binExpr.Rule = expression + binOp + expression;
expression.Rule = term | binExpr | betweenStatement | "(" + expression + ")";
constOperand.Rule = constantTerminal;
view.Rule = VIEW + "(" + id + COMMA + id + ")";
queryOptions.Rule = Empty | USING + QUERYOPTIONS + "(" + queryOptionList + ")";
queryOption.Rule = ALLOW_STALE + binOp + constOperand | DESCENDING + binOp + constOperand | GROUP + binOp + constOperand |
GROUP_LEVEL + binOp + intVal | INCLUDE_DOCS + binOp + constOperand | INCLUSIVE_END + binOp + constOperand |
LIMIT + binOp + intVal | REDUCE + binOp + constOperand | SKIP + binOp + intVal;
queryOptionList.Rule = MakePlusRule(queryOptionList, COMMA, queryOption);
fromStatement.Rule = FROM + view | FROM + documentStatement;
documentStatement.Rule = DOCUMENT + "(" + term + ")";
keyStatement.Rule = keyArrayStatement | keyObjectStatement | keyValueStatement;
keyArrayStatement.Rule = WITH + KEY + "[" + keyList + "]";
keyObjectStatement.Rule = WITH + KEY + "{" + keyList + "}";
keyValueStatement.Rule = WITH + KEY + id;
keyList.Rule = MakePlusRule(keyList, COMMA, id);
whereStatement.Rule = Empty | WHERE + expression;
betweenStatement.Rule = "(" + term + COMMA + term + ")";
//Operators
RegisterOperators(10, "=", "<", ">", "<=", ">=", "BETWEEN");
RegisterOperators(9, "AND");
RegisterOperators(8, "OR");
RegisterOperators(7, "IN");
MarkPunctuation("[", "]", "(", ")", "{", "}", ",");
MarkTransient(term,expression, binOp, constOperand, keyStatement);
}
internal VisualizerBindingGrammar()
: base(caseSensitive: false)
{
LanguageFlags = LanguageFlags.CreateAst |
LanguageFlags.NewLineBeforeEOF;
// Terms
var EQUALS = ToTerm("=", "equal");
var NOT_EQUAL = ToTerm("<>", "not equal");
var ALT_NOT_EQUAL = ToTerm("!=", "alternative not equal");
var GREATER = ToTerm(">", "greater");
var GREATER_EQUAL = ToTerm(">=", "greater or equal");
var LESS = ToTerm("<", "less");
var LESS_EQUAL = ToTerm("<=", "less or equal");
var PARENTHESIS_OPEN = ToTerm("(");
var PARENTHESIS_CLOSE = ToTerm(")");
var PLUS = ToTerm("+");
var MINUS = ToTerm("-");
var COMMA = ToTerm(",", "comma");
var IF = ToTerm("if");
var COLON = ToTerm(":", "colon");
var FOR = ToTerm("for");
var IN = ToTerm("in");
var RANGE = ToTerm("..", "range");
var SIZE_FUNC = ToTerm("size", "size function");
// Terminals
var visualizerNameReference = new IdentifierTerminal("visualizer reference");
visualizerNameReference.AstConfig.NodeType = typeof(VisualizerNameReferenceNode);
var numberLiteral = new NumberLiteral("literal", NumberOptions.IntOnly, typeof(IntegerLiteralNode));
var characterLiteral = new StringLiteral("character literal", "'", StringOptions.IsChar);
characterLiteral.AstConfig.NodeType = typeof(CharacterLiteralNode);
var variableName = new IdentifierTerminal("variable");
variableName.AstConfig.NodeType = typeof(VariableNameNode);
var counterReference = new IdentifierTerminal("counter reference");
counterReference.AstConfig.NodeType = typeof(CounterReferenceNode);
counterReference.AddPrefix("%", IdOptions.IsNotKeyword);
var counterDeclaration = new IdentifierTerminal("counter declaration");
counterDeclaration.AstConfig.NodeType = typeof(CounterDeclarationNode);
var callArgumentNumberValue = new NumberLiteral("call argument value number", NumberOptions.IntOnly, typeof(CallArgumentNumberValueNode));
var callArgumentStringValue = new IdentifierTerminal("call argument value string");
callArgumentStringValue.AstConfig.NodeType = typeof(CallArgumentStringValueNode);
var callArgumentName = new IdentifierTerminal("call argument name");
callArgumentName.AstConfig.NodeType = typeof(CallArgumentNameNode);
var variableReference = new IdentifierTerminal("variable reference", IdOptions.IsNotKeyword);
variableReference.AstConfig.NodeType = typeof(FunctionCallArgumentStringLiteralNode);
var itemName = new IdentifierTerminal("string literal", IdOptions.IsNotKeyword);
itemName.AstConfig.NodeType = typeof(ItemNameNode);
// Non-terminals
var functionName = new NonTerminal("function name", typeof(FunctionNameNode));
var functionInvocation = new NonTerminal("function call", typeof(FunctionInvocationNode));
var functionArgumentList = new NonTerminal("function arguments", typeof(FunctionArgumentListNode));
var functionArgument = new NonTerminal("function argument", typeof(FunctionCallArgumentNode));
var ifStatement = new NonTerminal("if", typeof(IfStatementNode));
var statement = new NonTerminal("statement", typeof(StatementNode));
var statementList = new NonTerminal("statement list", typeof(StatementListNode));
var bindingExpression = new NonTerminal("binding expression", typeof(VisualizerBindingExpressionNode));
var infixStatement = new NonTerminal("infix statement", typeof(InfixStatementNode));
var valueReferenceStatement = new NonTerminal("binary expression", typeof(ValueReferenceStatementNode));
var valueOffset = new NonTerminal("offset", typeof(ValueOffsetNode));
var binaryOperator = new NonTerminal("binary operators", "operator");
var infixOperator = new NonTerminal("infix");
var callArgumentValue = new NonTerminal("call argument value", typeof(CallArgumentValueNode));
var callArgument = new NonTerminal("call argument", typeof(CallArgumentNode));
var callArgumentList = new NonTerminal("call argument list", typeof(CallArgumentListNode));
var callStatement = new NonTerminal("call statement", typeof(CallStatementNode));
var expression = new NonTerminal("expression", typeof(VisualizerExpressionNode));
var scopeLimitStatement = new NonTerminal("scope limit statement", typeof(ScopeLimitSatementNode));
var expanderCountStatement = new NonTerminal("expander counter", typeof(ExpanderCountNode));
var scopeStatement = new NonTerminal("scope", typeof(ScopeStatementNode));
var expanderScopeStatement = new NonTerminal("expander scope", typeof(ExpanderScopeNode));
var counterDeclarationList = new NonTerminal("counters", typeof(CounterDeclarationListNode));
var expanderStatement = new NonTerminal("multi-expander", typeof(MultiRepeaterStatementNode));
var expanderScopeStatementList = new NonTerminal("scopes", typeof(ScopeDeclarationListNode));
var binaryExpression = new NonTerminal("binary expression", typeof(VisualizerBinaryExpressionNode));
// BNF rules
functionName.Rule = SIZE_FUNC;
functionArgument.Rule = variableReference;
functionArgumentList.Rule = MakePlusRule(functionArgumentList, COMMA, functionArgument);
functionInvocation.Rule = functionName + PARENTHESIS_OPEN + functionArgumentList + PARENTHESIS_CLOSE;
infixStatement.Rule = numberLiteral | counterReference;
infixOperator.Rule = PLUS | MINUS;
valueOffset.Rule = numberLiteral | counterReference;
// A value reference can either reference a singleton or one element of an aggregate
valueReferenceStatement.Rule = ToTerm("<") + variableName + COMMA + valueOffset + ToTerm(">") |
ToTerm("<") + variableName + ToTerm(">");
callArgumentValue.Rule = valueReferenceStatement | callArgumentNumberValue | callArgumentStringValue;
callArgument.Rule = callArgumentName + COLON + callArgumentValue;
callArgumentList.Rule = MakePlusRule(callArgumentList, COMMA, callArgument);
callStatement.Rule = visualizerNameReference + PARENTHESIS_OPEN + callArgumentList + PARENTHESIS_CLOSE;
binaryOperator.Rule = EQUALS |
NOT_EQUAL | ALT_NOT_EQUAL |
LESS | LESS_EQUAL |
GREATER | GREATER_EQUAL;
expression.Rule = valueReferenceStatement |
numberLiteral |
characterLiteral |
itemName |
counterReference;
binaryExpression.Rule = expression + binaryOperator + expression;
scopeLimitStatement.Rule = numberLiteral | counterReference | functionInvocation;
expanderCountStatement.Rule = numberLiteral | counterReference | functionInvocation;
scopeStatement.Rule = scopeLimitStatement + RANGE + scopeLimitStatement;
expanderScopeStatement.Rule = scopeStatement | expanderCountStatement;
counterDeclarationList.Rule = MakePlusRule(counterDeclarationList, COMMA, counterDeclaration);
expanderScopeStatementList.Rule = MakePlusRule(expanderScopeStatementList, COMMA, expanderScopeStatement);
expanderStatement.Rule = FOR + counterDeclarationList + IN + expanderScopeStatementList + COLON + statement;
ifStatement.Rule = IF + binaryExpression + COLON + callStatement;
statement.Rule = ifStatement | callStatement;
statementList.Rule = MakePlusRule(statementList, COMMA, statement);
bindingExpression.Rule = NewLine |
statementList + NewLine |
expanderStatement + NewLine;
Root = bindingExpression;
// Operator precedence
RegisterOperators(1, PLUS, MINUS);
// Punctuation and transient terms
MarkReservedWords("for", "if", "in");
RegisterBracePair("(", ")");
RegisterBracePair("<", ">");
MarkTransient(binaryOperator, infixOperator, functionName);
MarkPunctuation(PARENTHESIS_OPEN, PARENTHESIS_CLOSE);
MarkPunctuation(FOR, IF, COLON, COMMA, RANGE);
MarkPunctuation("<", ">");
}
