public override MethodBuilder Define (TypeContainer parent) { parameters.Resolve (this); base.Define (parent); Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, ParameterInfo, ModFlags); method_data = new MethodData (method, ModFlags, flags, this); if (!method_data.Define (parent.PartialContainer, method.GetFullName (MemberName))) return null; method_data.DefineMethodBuilder (parent.PartialContainer, ParameterInfo); return method_data.MethodBuilder; }
public override bool Define () { if (!base.Define ()) return false; if (!CheckBase ()) return false; MemberKind kind; if (this is Operator) kind = MemberKind.Operator; else if (this is Destructor) kind = MemberKind.Destructor; else kind = MemberKind.Method; string explicit_name; if (IsPartialDefinition) { caching_flags &= ~Flags.Excluded_Undetected; caching_flags |= Flags.Excluded; // Add to member cache only when a partial method implementation has not been found yet if ((caching_flags & Flags.PartialDefinitionExists) != 0) return true; if (IsExplicitImpl) return true; explicit_name = null; } else { MethodData = new MethodData (this, ModFlags, flags, this, base_method); if (!MethodData.Define (Parent.PartialContainer, GetFullName (MemberName))) return false; explicit_name = MethodData.MetadataName; } spec = new MethodSpec (kind, Parent.Definition, this, ReturnType, parameters, ModFlags); if (MemberName.Arity > 0) spec.IsGeneric = true; Parent.MemberCache.AddMember (this, explicit_name, spec); return true; }
public override MethodBuilder Define (DeclSpace parent) { parameters.Resolve (this); base.Define (parent); Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, null, ParameterInfo, ModFlags); method_data = new MethodData (method, ModFlags, flags, this); if (!method_data.Define (parent, method.GetFullName (MemberName), Report)) return null; Spec.SetMetaInfo (method_data.MethodBuilder); return method_data.MethodBuilder; }
public virtual MethodBuilder Define (TypeContainer parent) { // Fill in already resolved event type to speed things up and // avoid confusing duplicate errors ((Parameter) parameters.FixedParameters[0]).Type = method.member_type; parameters.Types = new TypeSpec[] { method.member_type }; method_data = new MethodData (method, method.ModFlags, method.flags | MethodAttributes.HideBySig | MethodAttributes.SpecialName, this); if (!method_data.Define (parent.PartialContainer, method.GetFullName (MemberName))) return null; method_data.DefineMethodBuilder (parent.PartialContainer, ParameterInfo); if (Compiler.Settings.WriteMetadataOnly) block = null; Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, ParameterInfo, method.ModFlags); Spec.IsAccessor = true; return method_data.MethodBuilder; }
public override bool Define () { if (!base.Define ()) return false; if (!CheckBase ()) return false; MemberKind kind; if (this is Operator) kind = MemberKind.Operator; else if (this is Destructor) kind = MemberKind.Destructor; else kind = MemberKind.Method; if (IsPartialDefinition) { caching_flags &= ~Flags.Excluded_Undetected; caching_flags |= Flags.Excluded; // Add to member cache only when a partial method implementation has not been found yet if ((caching_flags & Flags.PartialDefinitionExists) == 0) { // MethodBase mb = new PartialMethodDefinitionInfo (this); spec = new MethodSpec (kind, Parent.Definition, this, ReturnType, null, parameters, ModFlags); if (MemberName.Arity > 0) { spec.IsGeneric = true; // TODO: Have to move DefineMethod after Define (ideally to Emit) throw new NotImplementedException ("Generic partial methods"); } Parent.MemberCache.AddMember (spec); } return true; } MethodData = new MethodData ( this, ModFlags, flags, this, MethodBuilder, base_method); if (!MethodData.Define (Parent.PartialContainer, GetFullName (MemberName))) return false; MethodBuilder = MethodData.MethodBuilder; spec = new MethodSpec (kind, Parent.Definition, this, ReturnType, MethodBuilder, parameters, ModFlags); if (MemberName.Arity > 0) spec.IsGeneric = true; Parent.MemberCache.AddMember (this, MethodBuilder.Name, spec); return true; }
public virtual MethodBuilder Define (DeclSpace parent) { parameters.Resolve (this); method_data = new MethodData (method, method.ModFlags, method.flags | MethodAttributes.HideBySig | MethodAttributes.SpecialName, this); if (!method_data.Define (parent, method.GetFullName (MemberName), Report)) return null; MethodBuilder mb = method_data.MethodBuilder; ParameterInfo.ApplyAttributes (mb); Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, mb, ParameterInfo, method.ModFlags); Spec.IsAccessor = true; return mb; }
public virtual MethodBuilder Define (DeclSpace parent) { // Fill in already resolved event type to speed things up and // avoid confusing duplicate errors ((Parameter) parameters.FixedParameters[0]).Type = method.member_type; parameters.Types = new TypeSpec[] { method.member_type }; method_data = new MethodData (method, method.ModFlags, method.flags | MethodAttributes.HideBySig | MethodAttributes.SpecialName, this); if (!method_data.Define (parent, method.GetFullName (MemberName), Report)) return null; MethodBuilder mb = method_data.MethodBuilder; Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, mb, ParameterInfo, method.ModFlags); Spec.IsAccessor = true; return mb; }
public override void Define (TypeContainer parent) { base.Define (parent); Spec = new MethodSpec (MemberKind.Method, parent.PartialContainer.Definition, this, ReturnType, ParameterInfo, ModFlags); method_data = new MethodData (method, ModFlags, flags, this); method_data.Define (parent.PartialContainer, method.GetFullName (MemberName)); }
public override bool Define (TypeContainer parent) { EventAttributes e_attr = EventAttributes.RTSpecialName | EventAttributes.SpecialName; if (!DoDefine (parent)) return false; if (init != null && ((ModFlags & Modifiers.ABSTRACT) != 0)){ Report.Error (74, Location, "'" + parent.Name + "." + Name + "': abstract event can not have an initializer"); return false; } if (!MemberType.IsSubclassOf (TypeManager.delegate_type)) { Report.Error (66, Location, "'" + parent.Name + "." + Name + "' : event must be of a delegate type"); return false; } Type [] parameter_types = new Type [1]; parameter_types [0] = MemberType; Parameter [] parms = new Parameter [1]; parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null); InternalParameters ip = new InternalParameters ( parent, new Parameters (parms, null, Location)); if (!CheckBase (parent)) return false; // // Now define the accessors // AddData = new MethodData (this, "add", TypeManager.void_type, parameter_types, ip, CallingConventions.Standard, (Add != null) ? Add.OptAttributes : null, ModFlags, flags, false); if (!AddData.Define (parent)) return false; AddBuilder = AddData.MethodBuilder; AddBuilder.DefineParameter (1, ParameterAttributes.None, "value"); RemoveData = new MethodData (this, "remove", TypeManager.void_type, parameter_types, ip, CallingConventions.Standard, (Remove != null) ? Remove.OptAttributes : null, ModFlags, flags, false); if (!RemoveData.Define (parent)) return false; RemoveBuilder = RemoveData.MethodBuilder; RemoveBuilder.DefineParameter (1, ParameterAttributes.None, "value"); if (!IsExplicitImpl){ EventBuilder = new MyEventBuilder (this, parent.TypeBuilder, Name, e_attr, MemberType); if (Add == null && Remove == null) { FieldBuilder = parent.TypeBuilder.DefineField ( Name, MemberType, FieldAttributes.Private | ((ModFlags & Modifiers.STATIC) != 0 ? FieldAttributes.Static : 0)); TypeManager.RegisterPrivateFieldOfEvent ( (EventInfo) EventBuilder, FieldBuilder); TypeManager.RegisterFieldBase (FieldBuilder, this); } EventBuilder.SetAddOnMethod (AddBuilder); EventBuilder.SetRemoveOnMethod (RemoveBuilder); if (!TypeManager.RegisterEvent (EventBuilder, AddBuilder, RemoveBuilder)) { Report.Error (111, Location, "Class `" + parent.Name + "' already contains a definition for the event `" + Name + "'"); return false; } } return true; }
public override bool Define (TypeContainer parent) { PropertyAttributes prop_attr = PropertyAttributes.RTSpecialName | PropertyAttributes.SpecialName; if (!DoDefine (parent)) return false; IndexerName = Attribute.ScanForIndexerName (ec, OptAttributes); if (IndexerName == null) IndexerName = "Item"; else if (IsExplicitImpl) Report.Error (592, Location, "Attribute 'IndexerName' is not valid on this declaration " + "type. It is valid on `property' declarations only."); ShortName = IndexerName; if (IsExplicitImpl) { InterfaceIndexerName = TypeManager.IndexerPropertyName (InterfaceType); Name = InterfaceType.FullName + "." + IndexerName; } else { InterfaceIndexerName = IndexerName; Name = ShortName; } if (!CheckBase (parent)) return false; flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName; if (Get != null){ InternalParameters ip = new InternalParameters (parent, Parameters); GetData = new MethodData (this, "get", MemberType, ParameterTypes, ip, CallingConventions.Standard, Get.OptAttributes, ModFlags, flags, false); if (!GetData.Define (parent)) return false; GetBuilder = GetData.MethodBuilder; } if (Set != null){ int top = ParameterTypes.Length; Type [] set_pars = new Type [top + 1]; ParameterTypes.CopyTo (set_pars, 0); set_pars [top] = MemberType; Parameter [] fixed_parms = Parameters.FixedParameters; if (fixed_parms == null){ throw new Exception ("We currently do not support only array arguments in an indexer"); // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG // // Here is the problem: the `value' parameter has // to come *after* the array parameter in the declaration // like this: // X (object [] x, Type value) // .param [0] // // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG // BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG } Parameter [] tmp = new Parameter [fixed_parms.Length + 1]; fixed_parms.CopyTo (tmp, 0); tmp [fixed_parms.Length] = new Parameter ( Type, "value", Parameter.Modifier.NONE, null); Parameters set_formal_params = new Parameters (tmp, null, Location); InternalParameters ip = new InternalParameters (parent, set_formal_params); SetData = new MethodData (this, "set", TypeManager.void_type, set_pars, ip, CallingConventions.Standard, Set.OptAttributes, ModFlags, flags, false); if (!SetData.Define (parent)) return false; SetBuilder = SetData.MethodBuilder; } // // Now name the parameters // Parameter [] p = Parameters.FixedParameters; if (p != null) { int i; for (i = 0; i < p.Length; ++i) { if (Get != null) GetBuilder.DefineParameter ( i + 1, p [i].Attributes, p [i].Name); if (Set != null) SetBuilder.DefineParameter ( i + 1, p [i].Attributes, p [i].Name); } if (Set != null) SetBuilder.DefineParameter ( i + 1, ParameterAttributes.None, "value"); if (i != ParameterTypes.Length) { Parameter array_param = Parameters.ArrayParameter; SetBuilder.DefineParameter ( i + 1, array_param.Attributes, array_param.Name); } } if (GetData != null) IsImplementing = GetData.IsImplementing; else if (SetData != null) IsImplementing = SetData.IsImplementing; // // Define the PropertyBuilder if one of the following conditions are met: // a) we're not implementing an interface indexer. // b) the indexer has a different IndexerName and this is no // explicit interface implementation. // if (!IsExplicitImpl) { PropertyBuilder = parent.TypeBuilder.DefineProperty ( IndexerName, prop_attr, MemberType, ParameterTypes); if (GetData != null) PropertyBuilder.SetGetMethod (GetBuilder); if (SetData != null) PropertyBuilder.SetSetMethod (SetBuilder); TypeManager.RegisterIndexer (PropertyBuilder, GetBuilder, SetBuilder, ParameterTypes); } return true; }
public override bool Define (TypeContainer parent) { if (!DoDefine (parent)) return false; if (!CheckBase (parent)) return false; flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName; if (Get != null) { Type [] parameters = TypeManager.NoTypes; InternalParameters ip = new InternalParameters ( parent, Parameters.EmptyReadOnlyParameters); GetData = new MethodData (this, "get", MemberType, parameters, ip, CallingConventions.Standard, Get.OptAttributes, ModFlags, flags, false); if (!GetData.Define (parent)) return false; GetBuilder = GetData.MethodBuilder; } if (Set != null) { Type [] parameters = new Type [1]; parameters [0] = MemberType; Parameter [] parms = new Parameter [1]; parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null); InternalParameters ip = new InternalParameters ( parent, new Parameters (parms, null, Location)); SetData = new MethodData (this, "set", TypeManager.void_type, parameters, ip, CallingConventions.Standard, Set.OptAttributes, ModFlags, flags, false); if (!SetData.Define (parent)) return false; SetBuilder = SetData.MethodBuilder; SetBuilder.DefineParameter (1, ParameterAttributes.None, "value"); } // FIXME - PropertyAttributes.HasDefault ? PropertyAttributes prop_attr = PropertyAttributes.RTSpecialName | PropertyAttributes.SpecialName; if (!IsExplicitImpl){ PropertyBuilder = parent.TypeBuilder.DefineProperty ( Name, prop_attr, MemberType, null); if (Get != null) PropertyBuilder.SetGetMethod (GetBuilder); if (Set != null) PropertyBuilder.SetSetMethod (SetBuilder); // // HACK for the reasons exposed above // if (!TypeManager.RegisterProperty (PropertyBuilder, GetBuilder, SetBuilder)) { Report.Error ( 111, Location, "Class `" + parent.Name + "' already contains a definition for the property `" + Name + "'"); return false; } } return true; }
// // Creates the type // public override bool Define (TypeContainer parent) { if (!DoDefine (parent)) return false; if (!CheckBase (parent)) return false; CallingConventions cc = GetCallingConvention (parent is Class); MethodData = new MethodData (this, null, MemberType, ParameterTypes, ParameterInfo, cc, OptAttributes, ModFlags, flags, true); if (!MethodData.Define (parent)) return false; MethodBuilder = MethodData.MethodBuilder; // // This is used to track the Entry Point, // if (Name == "Main" && ((ModFlags & Modifiers.STATIC) != 0) && (RootContext.MainClass == null || RootContext.MainClass == parent.TypeBuilder.FullName)){ if (IsEntryPoint (MethodBuilder, ParameterInfo)) { if (RootContext.EntryPoint == null) { RootContext.EntryPoint = MethodBuilder; RootContext.EntryPointLocation = Location; } else { DuplicateEntryPoint (RootContext.EntryPoint, RootContext.EntryPointLocation); DuplicateEntryPoint (MethodBuilder, Location); } } else Report28(MethodBuilder); } return true; }
public virtual MethodBuilder Define (DeclSpace parent) { method_data = new MethodData (method, method.ModFlags, method.flags | MethodAttributes.HideBySig | MethodAttributes.SpecialName, this); if (!method_data.Define (parent, method.GetFullName (MemberName), Report)) return null; MethodBuilder mb = method_data.MethodBuilder; ParameterInfo.ApplyAttributes (mb); return mb; }
public override MethodBuilder Define (DeclSpace parent) { parameters.Resolve (this); base.Define (parent); if (IsDummy) return null; method_data = new MethodData (method, ModFlags, flags, this); if (!method_data.Define (parent, method.GetFullName (MemberName), Report)) return null; return method_data.MethodBuilder; }
public override bool Define () { if (!base.Define ()) return false; if (!CheckBase ()) return false; if (block != null && block.IsIterator && !(Parent is IteratorStorey)) { // // Current method is turned into automatically generated // wrapper which creates an instance of iterator // Iterator.CreateIterator (this, Parent.PartialContainer, ModFlags, Compiler); ModFlags |= Modifiers.DEBUGGER_HIDDEN; } if (IsPartialDefinition) { caching_flags &= ~Flags.Excluded_Undetected; caching_flags |= Flags.Excluded; // Add to member cache only when a partial method implementation is not there if ((caching_flags & Flags.MethodOverloadsExist) == 0) { MethodBase mb = new PartialMethodDefinitionInfo (this); Parent.MemberCache.AddMember (mb, this); TypeManager.AddMethod (mb, this); } return true; } MethodData = new MethodData ( this, ModFlags, flags, this, MethodBuilder, GenericMethod, base_method); if (!MethodData.Define (Parent.PartialContainer, GetFullName (MemberName), Report)) return false; MethodBuilder = MethodData.MethodBuilder; if (TypeManager.IsGenericMethod (MethodBuilder)) Parent.MemberCache.AddGenericMember (MethodBuilder, this); Parent.MemberCache.AddMember (MethodBuilder, this); return true; }