public AdditionResult AddClass (Class c)
{
AdditionResult res;
-
+
if ((res = IsValid (c.Basename)) != AdditionResult.Success)
return res;
-
+
+
+
DefineName (c.Name, c);
types.Add (c);
-
+
+ // FIXME: Do we really need to explicitly add an empty default static constructor?
+ // Apparently we don't
+/* if (c.default_static_constructor == null)
+ {
+ bool isModule = c is Mono.MonoBASIC.Module;
+ Constructor dc = new Constructor ("New", Parameters.EmptyReadOnlyParameters, null, c.Location);
+ dc.ModFlags = isModule ? Modifiers.PUBLIC | Modifiers.STATIC : Modifiers.PUBLIC;
+ c.AddConstructor (dc);
+ }
+*/
+ // --------------------------------------------------------------
+
return AdditionResult.Success;
}
public AdditionResult AddConstructor (Constructor c)
{
- if (c.Name != Basename)
+ if (c.Name != "New")
return AdditionResult.NotAConstructor;
bool is_static = (c.ModFlags & Modifiers.STATIC) != 0;
fields.Add (field);
- if (field.HasInitializer){
- if ((field.ModFlags & Modifiers.STATIC) != 0){
+ if (field.HasInitializer){
+ if ((field.ModFlags & Modifiers.STATIC) != 0) {
if (initialized_static_fields == null)
initialized_static_fields = new ArrayList ();
Modifiers.ABSTRACT |
Modifiers.SEALED |
Modifiers.UNSAFE;
-
+
public Class (TypeContainer parent, string name, int mod, Attributes attrs, Location l)
: base (parent, name, l)
{
}
public abstract class MethodCore : MemberBase {
- public readonly Parameters Parameters;
+ public /* readonly */ Parameters Parameters;
Block block;
//
}
public void LabelParameters (EmitContext ec, Type [] parameters, MethodBase builder)
+ {
+ LabelParameters (ec, parameters, builder, null);
+ }
+
+ public void LabelParameters (EmitContext ec, Type [] parameters, MethodBase builder, Parameters p_params)
{
//
// Define each type attribute (in/out/ref) and
// the argument names.
//
- Parameter [] p = Parameters.FixedParameters;
+ Parameter [] p = p_params == null ? Parameters.FixedParameters : p_params.FixedParameters;
int i = 0;
MethodBuilder mb = null;
public Method (Expression return_type, int mod, string name, Parameters parameters,
Attributes attrs, Location l)
: base (return_type, mod, AllowedModifiers, name, attrs, parameters, l)
- { }
+ {
+ Implements = null;
+ }
+
+ public Method (Expression return_type, int mod, string name, Parameters parameters,
+ Attributes attrs, Expression impl_what, Location l)
+ : base (return_type, mod, AllowedModifiers, name, attrs, parameters, l)
+ {
+ Implements = impl_what;
+ }
//
// Returns the `System.Type' for the ReturnType of this
if (Name == "Main" &&
((ModFlags & Modifiers.STATIC) != 0) &&
(RootContext.MainClass == null ||
- RootContext.MainClass == parent.TypeBuilder.FullName)){
+ RootContext.MainClass == parent.TypeBuilder.FullName ||
+ (RootContext.RootNamespace != null &&
+ RootContext.RootNamespace.Length > 0 &&
+ (RootContext.RootNamespace + "." + RootContext.MainClass) == parent.TypeBuilder.FullName))) {
if (IsEntryPoint (MethodBuilder, ParameterInfo)) {
if (RootContext.EntryPoint == null) {
RootContext.EntryPoint = MethodBuilder;
loc);
if (parent_constructor_group == null){
- Report.Error (1501, loc,
- "Can not find a constructor for this argument list");
+ string s = String.Format ("'{0}': Can not find a constructor for this argument list", t);
+ Report.Error (1501, loc, s);
return false;
}
-
+
parent_constructor = (ConstructorInfo) Invocation.OverloadResolve (ec,
(MethodGroupExpr) parent_constructor_group, argument_list, loc);
if (parent_constructor == null){
- Report.Error (1501, loc,
- "Can not find a constructor for this argument list");
+ string s = String.Format ("'{0}': Can not find a constructor for this argument list", t);
+ Report.Error (1501, loc, s);
return false;
}
} catch (Exception) {
}
- ec.EmitTopBlock (block, ParameterInfo, Location);
+ ec.EmitTopBlock (block, member.Name, ParameterInfo, Location);
sw.CloseMethod ();
} else
- ec.EmitTopBlock (block, ParameterInfo, Location);
+ ec.EmitTopBlock (block, member.Name, ParameterInfo, Location);
}
}
abstract public class MemberBase : MemberCore {
public Expression Type;
public readonly Attributes OptAttributes;
+ public Expression Implements;
protected MethodAttributes flags;
return true;
}
- public void Emit (TypeContainer tc)
+ public virtual void Emit (TypeContainer tc)
{
//
// The PropertyBuilder can be null for explicit implementations, in that
//
if (PropertyBuilder != null)
Attribute.ApplyAttributes (ec, PropertyBuilder, this, OptAttributes, Location);
-
+/*
if (GetData != null)
GetData.Emit (tc, Get.Block, Get);
if (SetData != null)
SetData.Emit (tc, Set.Block, Set);
+*/
}
}
Modifiers.EXTERN |
Modifiers.VIRTUAL;
+ string set_parameter_name;
+ Parameters get_params;
+ Parameters set_params;
+
+ public Property (Expression type, string name, int mod_flags,
+ Accessor get_block, Accessor set_block,
+ Attributes attrs, Location loc, string set_name,
+ Parameters p_get, Parameters p_set)
+ : base (type, name, mod_flags, AllowedModifiers,
+ p_set,
+ get_block, set_block, attrs, loc)
+ {
+ set_parameter_name = set_name;
+ get_params = p_get;
+ set_params = p_set;
+ Implements = null;
+ }
+
+ public Property (Expression type, string name, int mod_flags,
+ Accessor get_block, Accessor set_block,
+ Attributes attrs, Location loc, string set_name,
+ Parameters p_get, Parameters p_set, Expression impl_what)
+ : base (type, name, mod_flags, AllowedModifiers,
+ p_set,
+ get_block, set_block, attrs, loc)
+ {
+ set_parameter_name = set_name;
+ get_params = p_get;
+ set_params = p_set;
+ Implements = impl_what;
+ }
+
public Property (Expression type, string name, int mod_flags,
Accessor get_block, Accessor set_block,
Attributes attrs, Location loc)
Parameters.EmptyReadOnlyParameters,
get_block, set_block, attrs, loc)
{
+ set_parameter_name = "Value";
+ get_params = Parameters.EmptyReadOnlyParameters;
+ set_params = Parameters.EmptyReadOnlyParameters;
}
public override bool Define (TypeContainer parent)
{
+ Type [] g_parameters=null, s_parameters=null;
+ Parameter [] g_parms, s_parms;
+ InternalParameters g_ip=null, s_ip=null;
+
if (!DoDefine (parent))
return false;
flags |= MethodAttributes.HideBySig | MethodAttributes.SpecialName;
if (Get != null) {
- Type [] parameters = TypeManager.NoTypes;
-
- InternalParameters ip = new InternalParameters (
- parent, Parameters.EmptyReadOnlyParameters);
+ if (get_params == Parameters.EmptyReadOnlyParameters)
+ {
+ g_parameters = TypeManager.NoTypes;
+ g_ip = new InternalParameters (
+ parent, Parameters.EmptyReadOnlyParameters);
+ }
+ else
+ {
+ g_parameters = new Type [get_params.FixedParameters.Length];
+ for (int i = 0; i < get_params.FixedParameters.Length; i ++)
+ {
+ g_parameters[i] = get_params.FixedParameters[i].ParameterType;
+ }
+ g_parms = new Parameter [get_params.FixedParameters.Length];
+ for (int i = 0; i < get_params.FixedParameters.Length; i ++)
+ {
+ Parameter tp = get_params.FixedParameters[i];
+ g_parms[i] = new Parameter (tp.TypeName, tp.Name,
+ Parameter.Modifier.NONE, null);
+ }
+ g_ip = new InternalParameters (
+ parent, new Parameters (g_parms, null, Location));
+ }
GetData = new MethodData (this, "get", MemberType,
- parameters, ip, CallingConventions.Standard,
+ g_parameters, g_ip, CallingConventions.Standard,
Get.OptAttributes, ModFlags, flags, false);
if (!GetData.Define (parent))
}
if (Set != null) {
- Type [] parameters = new Type [1];
- parameters [0] = MemberType;
+ if (set_params == Parameters.EmptyReadOnlyParameters)
+ {
+ s_parameters = new Type [1];
+ s_parameters [0] = MemberType;
+
+ s_parms = new Parameter [1];
+ s_parms [0] = new Parameter (Type, /* was "value" */ set_parameter_name,
+ Parameter.Modifier.NONE, null);
+ }
+ else
+ {
+ s_parameters = new Type [set_params.FixedParameters.Length];
+ for (int i = 0; i < set_params.FixedParameters.Length; i ++)
+ {
+ s_parameters[i] = set_params.FixedParameters[i].ParameterType;
+ }
- 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));
+ s_parms = new Parameter [set_params.FixedParameters.Length];
+ for (int i = 0; i < set_params.FixedParameters.Length; i ++)
+ {
+ Parameter tp = set_params.FixedParameters[i];
+ s_parms[i] = new Parameter (tp.TypeName, tp.Name,
+ Parameter.Modifier.NONE, null);
+ }
+ }
+
+ s_ip = new InternalParameters (
+ parent, new Parameters (s_parms, null, Location));
+
SetData = new MethodData (this, "set", TypeManager.void_type,
- parameters, ip, CallingConventions.Standard,
+ s_parameters, s_ip, CallingConventions.Standard,
Set.OptAttributes, ModFlags, flags, false);
if (!SetData.Define (parent))
return false;
SetBuilder = SetData.MethodBuilder;
- SetBuilder.DefineParameter (1, ParameterAttributes.None, "value");
+ SetBuilder.DefineParameter (1, ParameterAttributes.None,
+ /* was "value" */ set_parameter_name);
}
// FIXME - PropertyAttributes.HasDefault ?
}
return true;
}
+
+ public override void Emit (TypeContainer tc)
+ {
+ base.Emit (tc);
+
+ if (GetData != null)
+ {
+ Parameters = get_params;
+ GetData.Emit (tc, Get.Block, Get);
+ }
+
+ if (SetData != null)
+ {
+ Parameters = set_params;
+ SetData.Emit (tc, Set.Block, Set);
+ }
+
+ }
}
/// </summary>
parameter_types [0] = MemberType;
Parameter [] parms = new Parameter [1];
- parms [0] = new Parameter (Type, "value", Parameter.Modifier.NONE, null);
+ parms [0] = new Parameter (Type, /* was "value" */ this.Name, Parameter.Modifier.NONE, null);
InternalParameters ip = new InternalParameters (
parent, new Parameters (parms, null, Location));
return false;
AddBuilder = AddData.MethodBuilder;
- AddBuilder.DefineParameter (1, ParameterAttributes.None, "value");
+ AddBuilder.DefineParameter (1, ParameterAttributes.None, /* was "value" */ this.Name);
RemoveData = new MethodData (this, "remove", TypeManager.void_type,
parameter_types, ip, CallingConventions.Standard,
return false;
RemoveBuilder = RemoveData.MethodBuilder;
- RemoveBuilder.DefineParameter (1, ParameterAttributes.None, "value");
+ RemoveBuilder.DefineParameter (1, ParameterAttributes.None, /* was "value" */ this.Name);
if (!IsExplicitImpl){
EventBuilder = new MyEventBuilder (
fixed_parms.CopyTo (tmp, 0);
tmp [fixed_parms.Length] = new Parameter (
- Type, "value", Parameter.Modifier.NONE, null);
+ Type, /* was "value" */ this.Name, Parameter.Modifier.NONE, null);
Parameters set_formal_params = new Parameters (tmp, null, Location);
SetBuilder.DefineParameter (
i + 1, p [i].Attributes, p [i].Name);
}
+
if (Set != null)
SetBuilder.DefineParameter (
- i + 1, ParameterAttributes.None, "value");
+ i + 1, ParameterAttributes.None, /* was "value" */ this.Name);
if (i != ParameterTypes.Length) {
Parameter array_param = Parameters.ArrayParameter;
/// </summary>
public static MemberFilter method_signature_filter;
+ /// <summary>
+ /// This delegate is used to extract methods which have the
+ /// same signature as the argument except for the name
+ /// </summary>
+ public static MemberFilter method_signature_noname_filter;
+
/// <summary>
/// This delegate is used to extract inheritable methods which
/// have the same signature as the argument. By inheritable,
static MethodSignature ()
{
method_signature_filter = new MemberFilter (MemberSignatureCompare);
+ method_signature_noname_filter = new MemberFilter (MemberSignatureCompareNoName);
inheritable_method_signature_filter = new MemberFilter (
InheritableMemberSignatureCompare);
inheritable_property_signature_filter = new MemberFilter (
return true;
}
+ static bool MemberSignatureCompareNoName (MemberInfo m, object filter_criteria)
+ {
+ return MemberSignatureCompare (m, filter_criteria, false);
+ }
+
static bool MemberSignatureCompare (MemberInfo m, object filter_criteria)
+ {
+ return MemberSignatureCompare (m, filter_criteria, true);
+ }
+
+ static bool MemberSignatureCompare (MemberInfo m, object filter_criteria, bool use_name)
{
MethodSignature sig = (MethodSignature) filter_criteria;
- if (m.Name != sig.Name)
+ if (use_name && (m.Name != sig.Name))
return false;
Type ReturnType;