|
public Define ( |
||
| parent | ||
| method_full_name | string | |
| Report | ||
| Résultat | bool | |
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;
}
