public override void Init(AstContext context, ParseTreeNode parseNode) { // typeSpec var typeSpecChildren = AstChildren.Empty() .Add <TypeSpecAstNode>(); if (typeSpecChildren.PopulateWith(parseNode)) { TypeSpec = typeSpecChildren.Child1.TypeSpec; return; } // memberRef var memberRefChildren = AstChildren.Empty() .Add <MemberRefAstNode>(); if (memberRefChildren.PopulateWith(parseNode)) { FieldType = memberRefChildren.Child1.FieldType; FieldTypeSpec = memberRefChildren.Child1.FieldTypeSpec; FieldId = memberRefChildren.Child1.FieldId; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // ___("ldc.i4.s") var ldci4sChildren = AstChildren.Empty() .Add("ldc.i4.s"); if (ldci4sChildren.PopulateWith(parseNode)) { Instruction = new LoadConstI4ShortInstruction(); return; } // ___("ldc.i4") var ldci4Children = AstChildren.Empty() .Add("ldc.i4"); if (ldci4Children.PopulateWith(parseNode)) { Instruction = new LoadConstI4Instruction(); return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { // TODO - handle return; } // _("=") + fieldInit var fieldInitChildren = AstChildren.Empty() .Add("=") .Add <FieldInitAstNode>(); if (fieldInitChildren.PopulateWith(parseNode)) { InitValue = fieldInitChildren.Child2.InitValue; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { Value = new byte[0]; return; } // hexbytes var hexbytesChildren = AstChildren.Empty() .Add <HexbytesAstNode>(); if (hexbytesChildren.PopulateWith(parseNode)) { Value = hexbytesChildren.Child1.Value; return; } throw new InitAstNodeException(nameof(BytesAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // bound var boundChildren = AstChildren.Empty() .Add <BoundAstNode>(); if (boundChildren.PopulateWith(parseNode)) { Bounds = new List <CilBound> { boundChildren.Child1.Bound }; return; } // bounds1 + _(",") + bound var bounds1Children = AstChildren.Empty() .Add <Bounds1AstNode>() .Add(",") .Add <BoundAstNode>(); if (bounds1Children.PopulateWith(parseNode)) { Bounds = bounds1Children.Child1.Bounds; Bounds.Add(bounds1Children.Child3.Bound); return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // sigArg var sigArgChildren = AstChildren.Empty() .Add <SigArgAstNode>(); if (sigArgChildren.PopulateWith(parseNode)) { SigArgs = new List <CilSigArg> { sigArgChildren.Child1.SigArg }; return; } // sigArgs1 + _(",") + sigArg var sigArgs1Children = AstChildren.Empty() .Add <SigArgs1AstNode>() .Add(",") .Add <SigArgAstNode>(); if (sigArgs1Children.PopulateWith(parseNode)) { var sigArgs = sigArgs1Children.Child1.SigArgs; sigArgs.Add(sigArgs1Children.Child3.SigArg); SigArgs = sigArgs; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // className var classNameChildren = AstChildren.Empty() .Add <ClassNameAstNode>(); if (classNameChildren.PopulateWith(parseNode)) { TypeSpec = new CilTypeSpec { ClassName = classNameChildren.Child1.ClassName }; return; } // type var typeChildren = AstChildren.Empty() .Add <TypeAstNode>(); if (typeChildren.PopulateWith(parseNode)) { TypeSpec = new CilTypeSpec { Type = typeChildren.Child1.Type }; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { // TODO - handle return; } // _("implements") + classNames var implementsChildren = AstChildren.Empty() .Add("implements") .Add <ClassNamesAstNode>(); if (implementsChildren.PopulateWith(parseNode)) { ClassNames = implementsChildren.Child2.ClassNames; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // ___("ldc.r4") var ldcr4Children = AstChildren.Empty() .Add("ldc.r4"); if (ldcr4Children.PopulateWith(parseNode)) { Instruction = new LoadConstR4Instruction(); return; } // ___("ldc.r8") var ldcr8Children = AstChildren.Empty() .Add("ldc.r8"); if (ldcr8Children.PopulateWith(parseNode)) { Instruction = new LoadConstR8Instruction(); return; } throw new InitAstNodeException(nameof(INSTR_RAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // ID var IDChildren = AstChildren.Empty() .Add <IDAstNode>(); if (IDChildren.PopulateWith(parseNode)) { Value = IDChildren.Child1.Value; return; } // SQSTRING var SQSTRINGChildren = AstChildren.Empty() .Add <SQSTRINGAstNode>(); if (SQSTRINGChildren.PopulateWith(parseNode)) { Value = SQSTRINGChildren.Child1.Value; return; } throw new InitAstNodeException(nameof(IdAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // id var idChildren = AstChildren.Empty() .Add <IdAstNode>(); if (idChildren.PopulateWith(parseNode)) { Value = idChildren.Child1.Value; return; } // name1 + _(".") + name1 var name1Children = AstChildren.Empty() .Add <Name1AstNode>() .Add(".") .Add <Name1AstNode>(); if (name1Children.PopulateWith(parseNode)) { Value = name1Children.Child1.Value + "." + name1Children.Child3.Value; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // name1 var name1Children = AstChildren.Empty() .Add <Name1AstNode>(); if (name1Children.PopulateWith(parseNode)) { Value = name1Children.Child1.Value; return; } // slashedName + _("/") + name1 var slashedNameChildren = AstChildren.Empty() .Add <SlashedNameAstNode>() .Add("/") .Add <Name1AstNode>(); if (slashedNameChildren.PopulateWith(parseNode)) { Value = slashedNameChildren.Child1.Value + "/" + slashedNameChildren.Child3.Value; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { SigArgs = new List <CilSigArg>(); return; } // sigArgs1 var sigArgs1Children = AstChildren.Empty() .Add <SigArgs1AstNode>(); if (sigArgs1Children.PopulateWith(parseNode)) { SigArgs = sigArgs1Children.Child1.SigArgs; return; } throw new InitAstNodeException(nameof(SigArgs0AstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { // TODO - handle return; } // implAttr + _("cil") var cilChildren = AstChildren.Empty() .Add <ImplAttrAstNode>() .Add("cil"); if (cilChildren.PopulateWith(parseNode)) { // TODO - handle return; } // implAttr + _("managed") var managedChildren = AstChildren.Empty() .Add <ImplAttrAstNode>() .Add("managed"); if (managedChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // methodHeadPart1 + methAttr + callConv + paramAttr + type + methodName + _("(") + sigArgs0 + _(")") + implAttr + _("{") var shortChildren = AstChildren.Empty() .Add <MethodHeadPart1AstNode>() .Add <MethAttrAstNode>() .Add <CallConvAstNode>() .Add <ParamAttrAstNode>() .Add <TypeAstNode>() .Add <MethodNameAstNode>() .Add("(") .Add <SigArgs0AstNode>() .Add(")") .Add <ImplAttrAstNode>() .Add("{"); if (shortChildren.PopulateWith(parseNode)) { MethodName = shortChildren.Child6.MethodName; Arguments = shortChildren.Child8.SigArgs; CallConv = shortChildren.Child3.CallConv; ReturnType = shortChildren.Child5.Type; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // HEXBYTE var hexbyteChildren = AstChildren.Empty() .Add <HEXBYTEAstNode>(); if (hexbyteChildren.PopulateWith(parseNode)) { Value = new byte[] { hexbyteChildren.Child1.Value }; return; } // hexbytes + HEXBYTE var hexbytesChildren = AstChildren.Empty() .Add <HexbytesAstNode>() .Add <HEXBYTEAstNode>(); if (hexbytesChildren.PopulateWith(parseNode)) { var hexbytesNode = hexbytesChildren.Child1; Value = new byte[hexbytesNode.Value.Length + 1]; Array.Copy(hexbytesNode.Value, Value, hexbytesNode.Value.Length); Value[Value.Length - 1] = hexbytesChildren.Child2.Value; return; } throw new InitAstNodeException(nameof(HexbytesAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // _(".field") + repeatOpt + fieldAttr + type + id + atOpt + initOpt var fieldChildren = AstChildren.Empty() .Add(".field") .Add <RepeatOptAstNode>() .Add <FieldAttrAstNode>() .Add <TypeAstNode>() .Add <IdAstNode>() .Add <AtOptAstNode>() .Add <InitOptAstNode>(); if (fieldChildren.PopulateWith(parseNode)) { Field = new CilField { Name = fieldChildren.Child5.Value, Type = fieldChildren.Child4.Type, InitValue = fieldChildren.Child7.InitValue, Attributes = fieldChildren.Child3.FieldAttributes, AtId = fieldChildren.Child6.AtId }; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { // TODO - handle return; } // _("at") + id var atChildren = AstChildren.Empty() .Add("at") .Add <IdAstNode>(); if (atChildren.PopulateWith(parseNode)) { AtId = atChildren.Child2.Value; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // callConv + type + typeSpec + _("::") + _(".ctor") + _("(") + sigArgs0 + _(")") var typeSpecChildren = AstChildren.Empty() .Add <CallConvAstNode>() .Add <TypeAstNode>() .Add <TypeSpecAstNode>() .Add("::") .Add(".ctor") .Add("(") .Add <SigArgs0AstNode>() .Add(")"); if (typeSpecChildren.PopulateWith(parseNode)) { CustomType = new CilCustomType { CallConv = typeSpecChildren.Child1.CallConv, Type = typeSpecChildren.Child2.Type, TypeSpec = typeSpecChildren.Child3.TypeSpec, SigArgs = typeSpecChildren.Child7.SigArgs }; return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // _("stsfld") var stsfldChildren = AstChildren.Empty() .Add("stsfld"); if (stsfldChildren.PopulateWith(parseNode)) { Instruction = new StoreStaticFieldInstruction(); return; } // _("ldsfld") var ldsfldChildren = AstChildren.Empty() .Add("ldsfld"); if (ldsfldChildren.PopulateWith(parseNode)) { Instruction = new LoadStaticFieldInstruction(); return; } // _("stfld") var stfldChildren = AstChildren.Empty() .Add("stfld"); if (stfldChildren.PopulateWith(parseNode)) { Instruction = new StoreFieldInstruction(); return; } // _("ldfld") var ldfldChildren = AstChildren.Empty() .Add("ldfld"); if (ldfldChildren.PopulateWith(parseNode)) { Instruction = new LoadFieldInstruction(); return; } // _("ldflda") var ldfldaChildren = AstChildren.Empty() .Add("ldflda"); if (ldfldaChildren.PopulateWith(parseNode)) { Instruction = new LoadFieldAddressInstruction(); return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // ___("stloc.s") var stlocsChildren = AstChildren.Empty() .Add("stloc.s"); if (stlocsChildren.PopulateWith(parseNode)) { Instruction = new StoreLocalShortInstruction(); return; } // ___("ldloc.s") var ldlocsChildren = AstChildren.Empty() .Add("ldloc.s"); if (ldlocsChildren.PopulateWith(parseNode)) { Instruction = new LoadLocalShortInstruction(); return; } // ___("ldloca.s") var ldlocasChildren = AstChildren.Empty() .Add("ldloca.s"); if (ldlocasChildren.PopulateWith(parseNode)) { Instruction = new LoadLocalAddressShortInstruction(); return; } // ___("ldarg.s") var ldargsChildren = AstChildren.Empty() .Add("ldarg.s"); if (ldargsChildren.PopulateWith(parseNode)) { Instruction = new LoadArgumentShortInstruction(); return; } // ___("starg.s") var stargsChildren = AstChildren.Empty() .Add("starg.s"); if (stargsChildren.PopulateWith(parseNode)) { Instruction = new StoreArgumentShortInstruction(); return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { AssemblyRefDecls = new CilAssemblyRefDecls { PublicKeyTokens = new List <byte[]>(), Versions = new List <CilAssemblyVersion>() }; return; } // assemblyRefDecls + assemblyRefDecl var assemblyRefDeclsChildren = AstChildren.Empty() .Add <AssemblyRefDeclsAstNode>() .Add <AssemblyRefDeclAstNode>(); if (assemblyRefDeclsChildren.PopulateWith(parseNode)) { AssemblyRefDecls = assemblyRefDeclsChildren.Child1.AssemblyRefDecls; var declType = assemblyRefDeclsChildren.Child2.DeclType; if (!declType.HasValue) { throw new AstNodeException($"\"{nameof(declType)}\" is not specified."); } switch (declType.Value) { case AssemblyRefDeclType.PublicKeyToken: AssemblyRefDecls.PublicKeyTokens.Add(assemblyRefDeclsChildren.Child2.PublicKeyToken); break; case AssemblyRefDeclType.Ver: AssemblyRefDecls.Versions.Add(assemblyRefDeclsChildren.Child2.Version); break; default: throw new AstNodeException($"\"{nameof(declType)}\" cannot be recognized."); } return; } throw new InitAstNodeException(nameof(AssemblyRefDeclsAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { return; } // paramAttr + _("[") + int32 + _("]") var int32Children = AstChildren.Empty() .Add <ParamAttrAstNode>() .Add("[") .Add <Int32AstNode>() .Add("]"); if (int32Children.PopulateWith(parseNode)) { // TODO - handle return; } // paramAttr + _("[") + _("out") + _("]") var outChildren = AstChildren.Empty() .Add <ParamAttrAstNode>() .Add("[") .Add("out") .Add("]"); if (outChildren.PopulateWith(parseNode)) { // TODO - handle return; } // paramAttr + _("[") + _("opt") + _("]") var optChildren = AstChildren.Empty() .Add <ParamAttrAstNode>() .Add("[") .Add("opt") .Add("]"); if (optChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // nameValPair var nameValPairChildren = AstChildren.Empty() .Add <NameValPairAstNode>(); if (nameValPairChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // Empty var emptyChildren = AstChildren.Empty(); if (emptyChildren.PopulateWith(parseNode)) { Attributes = new List <CilAssemblyAttribute>(); return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // _(".method") var methodChildren = AstChildren.Empty() .Add(".method"); if (methodChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new InitAstNodeException(nameof(MethodHeadPart1AstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // _(".locals") var localsChildren = AstChildren.Empty() .Add(".locals"); if (localsChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new InitAstNodeException(nameof(LocalsHeadAstNode)); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // _("bytearray") + _("(") var bytearrayChildren = AstChildren.Empty() .Add("bytearray") .Add("("); if (bytearrayChildren.PopulateWith(parseNode)) { // TODO - handle return; } throw new NotImplementedException(); }
public override void Init(AstContext context, ParseTreeNode parseNode) { // INSTR_TOK var instrTokChildren = AstChildren.Empty() .Add <INSTR_TOKAstNode>(); if (instrTokChildren.PopulateWith(parseNode)) { Instruction = instrTokChildren.Child1.Instruction; return; } throw new NotImplementedException(); }