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