public PEAPI.FieldDef Resolve(CodeGen code_gen) { if (is_resolved) { return(field_def); } type.Resolve(code_gen); field_def = code_gen.PEFile.AddField(attr, name, type.PeapiType); is_resolved = true; return(field_def); }
public override void Emit(CodeGen code_gen, MethodDef meth, PEAPI.CILInstructions cil) { PEAPI.Type[] param_array; PEAPI.CalliSig callisig; if (param != null) { param_array = new PEAPI.Type[param.Length]; int count = 0; foreach (BaseTypeRef typeref in param) { typeref.Resolve(code_gen); param_array[count++] = typeref.PeapiType; } } else { param_array = new PEAPI.Type[0]; } ret_type.Resolve(code_gen); callisig = new PEAPI.CalliSig(call_conv, ret_type.PeapiType, param_array); cil.calli(callisig); }
public PEAPI.Event Resolve(CodeGen code_gen, PEAPI.ClassDef classdef) { if (is_resolved) { return(event_def); } type.Resolve(code_gen); event_def = classdef.AddEvent(name, type.PeapiType); if ((attr & FeatureAttr.Rtspecialname) != 0) { event_def.SetRTSpecialName(); } if ((attr & FeatureAttr.Specialname) != 0) { event_def.SetSpecialName(); } if (customattr_list != null) { foreach (CustomAttr customattr in customattr_list) { customattr.AddTo(code_gen, event_def); } } is_resolved = true; return(event_def); }
public void Resolve(CodeGen code_gen) { if (is_resolved) { return; } owner.Resolve(code_gen); if (owner.UseTypeSpec) { PEAPI.Type owner_ref = owner.PeapiType; code_gen.PEFile.AddFieldToTypeSpec(owner_ref, name, type.PeapiType); } else { PEAPI.ClassRef owner_ref; owner_ref = (PEAPI.ClassRef)owner.PeapiType; type.Resolve(code_gen); peapi_field = owner_ref.AddField(name, type.PeapiType); } is_resolved = true; }
public void Define(CodeGen code_gen) { if (is_defined) { return; } typeref.Resolve(code_gen); peapi_param = new PEAPI.Param(attr, name, typeref.PeapiType); if (defval != null) { peapi_param.AddDefaultValue(defval); } if (customattr_list != null) { foreach (CustomAttr customattr in customattr_list) { customattr.AddTo(code_gen, peapi_param); } } if (native_type != null) { peapi_param.AddMarshallInfo(native_type); } is_defined = true; }
public PEAPI.PermissionMember Resolve(CodeGen code_gen) { type_ref.Resolve(code_gen); member = new PEAPI.PermissionMember(member_type, type_ref.PeapiType, name, value); return(member); }
public override void Resolve(CodeGen code_gen) { if (is_resolved) { return; } PEAPI.Type [] arg_array; PEAPI.Type [] opt_array; bool is_vararg = false; if (param_list != null) { ArrayList opt_list = new ArrayList(); ArrayList arg_list = new ArrayList(); bool in_opt = false; int max = param_list.Count; for (int i = 0; i < max; i++) { ParamDef param = (ParamDef)param_list [i]; if (param.IsSentinel()) { is_vararg = true; in_opt = true; param.Type.Resolve(code_gen); } else if (in_opt) { param.Type.Resolve(code_gen); opt_list.Add(param.Type.PeapiType); } else { param.Type.Resolve(code_gen); arg_list.Add(param.Type.PeapiType); } } arg_array = (PEAPI.Type [])arg_list.ToArray(typeof(PEAPI.Type)); opt_array = (PEAPI.Type [])opt_list.ToArray(typeof(PEAPI.Type)); } else { arg_array = new PEAPI.Type [0]; opt_array = new PEAPI.Type [0]; } ret.Resolve(code_gen); type = new PEAPI.MethPtrType(callconv, ret.PeapiType, arg_array, is_vararg, opt_array); type = Modify(code_gen, type); is_resolved = true; }
public PEAPI.HandlerBlock Resolve(CodeGen code_gen, MethodDef method) { PEAPI.CILLabel from = handler_block.GetFromLabel(code_gen, method); PEAPI.CILLabel to = handler_block.GetToLabel(code_gen, method); PEAPI.Catch katch; type_ref.Resolve(code_gen); katch = new PEAPI.Catch(type_ref.PeapiType, from, to); return(katch); }
public void Resolve(CodeGen code_gen) { if (is_resolved) { return; } owner.Resolve(code_gen); type.Resolve(code_gen); peapi_field = code_gen.PEFile.AddFieldToTypeSpec(owner.PeapiType, name, type.PeapiType); is_resolved = true; }
PEAPI.Type GetType(CodeGen code_gen, PEAPI.CustomModifier modifier, BaseTypeRef klass) { klass.Resolve(code_gen); var bcr = klass as BaseClassRef; if (bcr != null) { return(new PEAPI.CustomModifiedType(peapi_type, modifier, bcr.PeapiClass)); } var pt = klass as PrimitiveTypeRef; return(new PEAPI.CustomModifiedType(peapi_type, modifier, code_gen.PEFile.AddPrimitiveType((PEAPI.PrimitiveType)pt.PeapiType))); throw new NotSupportedException(klass.GetType().ToString()); }
public PEAPI.Property Resolve(CodeGen code_gen, PEAPI.ClassDef classdef) { if (is_resolved) { return(prop_def); } PEAPI.Type[] type_list = new PEAPI.Type[arg_list.Count]; for (int i = 0; i < type_list.Length; i++) { BaseTypeRef arg_type = (BaseTypeRef)arg_list[i]; arg_type.Resolve(code_gen); type_list[i] = arg_type.PeapiType; } type.Resolve(code_gen); prop_def = classdef.AddProperty(name, type.PeapiType, type_list); if ((attr & FeatureAttr.Rtspecialname) != 0) { prop_def.SetRTSpecialName(); } if ((attr & FeatureAttr.Specialname) != 0) { prop_def.SetSpecialName(); } prop_def.SetInstance((attr & FeatureAttr.Instance) != 0); if (customattr_list != null) { foreach (CustomAttr customattr in customattr_list) { customattr.AddTo(code_gen, prop_def); } } is_resolved = true; return(prop_def); }
public PEAPI.Permission Resolve(CodeGen code_gen) { string fname; type_ref.Resolve(code_gen); if (type_ref is ExternTypeRef) { ExternAssembly ea = ((ExternTypeRef)type_ref).ExternRef as ExternAssembly; if (ea == null) { //FIXME: module.. ? throw new NotImplementedException(); } string name; ExternTypeRef etr = type_ref as ExternTypeRef; if (etr != null) { name = etr.Name; } else { name = type_ref.FullName; } fname = String.Format("{0}, {1}", name, ea.AssemblyName.FullName); } else { fname = type_ref.FullName; } perm = new PEAPI.Permission(type_ref.PeapiType, fname); foreach (PermissionMember member in members) { perm.AddMember(member.Resolve(code_gen)); } return(perm); }
public PEAPI.Local GetPeapiLocal(CodeGen code_gen) { int ec = Report.ErrorCount; BaseGenericTypeRef gtr = type as BaseGenericTypeRef; if (gtr == null) { type.Resolve(code_gen); } else { gtr.ResolveNoTypeSpec(code_gen); } if (Report.ErrorCount > ec) { return(null); } return(new PEAPI.Local(name, type.PeapiType)); }
public override void Emit(CodeGen code_gen, MethodDef meth, PEAPI.CILInstructions cil) { if (field_ref != null) { field_ref.Resolve(code_gen); cil.FieldInst(PEAPI.FieldOp.ldtoken, field_ref.PeapiField); } else if (method_ref != null) { method_ref.Resolve(code_gen); cil.MethInst(PEAPI.MethodOp.ldtoken, method_ref.PeapiMethod); } else if (type_ref != null) { type_ref.Resolve(code_gen); cil.TypeInst(PEAPI.TypeOp.ldtoken, type_ref.PeapiType); } }
public void DefineContents(CodeGen code_gen) { ArrayList fielddef_list = new ArrayList(); foreach (FieldDef fielddef in field_list) { if (is_enum_class && fielddef.Name == "value__") { fielddef.Attributes |= PEAPI.FieldAttr.SpecialName | PEAPI.FieldAttr.RTSpecialName; } fielddef.Define(code_gen, classdef); fielddef_list.Add(fielddef.PeapiFieldDef); } classdef.SetFieldOrder(fielddef_list); foreach (MethodDef methoddef in method_list) { methoddef.Define(code_gen); } if (event_list != null) { foreach (EventDef eventdef in event_list) { eventdef.Define(code_gen, classdef); } } if (property_list != null) { foreach (PropertyDef propdef in property_list) { propdef.Define(code_gen, classdef); } } if (customattr_list != null) { foreach (CustomAttr customattr in customattr_list) { customattr.AddTo(code_gen, classdef); if (customattr.IsSuppressUnmanaged(code_gen)) { classdef.AddAttribute(PEAPI.TypeAttr.HasSecurity); } } } /// Add declarative security to this class if (decl_sec != null) { decl_sec.AddTo(code_gen, classdef); classdef.AddAttribute(PEAPI.TypeAttr.HasSecurity); } if (override_list != null) { foreach (DictionaryEntry entry in override_list) { MethodDef body = (MethodDef)entry.Key; DictionaryEntry decl = (DictionaryEntry)entry.Value; BaseTypeRef parent_type = (BaseTypeRef)decl.Key; parent_type.Resolve(code_gen); string over_name = (string)decl.Value; BaseMethodRef over_meth = parent_type.GetMethodRef(body.RetType, body.CallConv, over_name, body.ParamTypeList(), body.GenParamCount); over_meth.Resolve(code_gen); classdef.AddMethodOverride(over_meth.PeapiMethod, body.PeapiMethodDef); } } if (override_long_list != null) { foreach (DictionaryEntry entry in override_long_list) { string sig = (string)entry.Key; BaseMethodRef decl = (BaseMethodRef)entry.Value; MethodDef body = (MethodDef)method_table[sig]; decl.Resolve(code_gen); classdef.AddMethodOverride(decl.PeapiMethod, body.PeapiMethodDef); } } }
public override void Emit(CodeGen code_gen, MethodDef meth, PEAPI.CILInstructions cil) { operand.Resolve(code_gen); cil.TypeInst(op, operand.PeapiType); }
PEAPI.Type GetType (CodeGen code_gen, PEAPI.CustomModifier modifier, BaseTypeRef klass) { klass.Resolve (code_gen); var bcr = klass as BaseClassRef; if (bcr != null) return new PEAPI.CustomModifiedType (peapi_type, modifier, bcr.PeapiClass); var pt = klass as PrimitiveTypeRef; return new PEAPI.CustomModifiedType (peapi_type, modifier, code_gen.PEFile.AddPrimitiveType ((PEAPI.PrimitiveType) pt.PeapiType)); throw new NotSupportedException (klass.GetType ().ToString ()); }