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("<", ">"); }