static public Type field_offset_attribute_type;
static public Type security_attr_type;
static public Type required_attr_type;
+ static public Type guid_attr_type;
+ static public Type assembly_culture_attribute_type;
///
/// .NET 2.0
#if NET_2_0
static internal Type compiler_generated_attr_type;
static internal Type fixed_buffer_attr_type;
+ static internal Type default_charset_type;
#endif
//
static public MethodInfo string_concat_object_dot_dot_dot;
static public MethodInfo string_isinterneted_string;
static public MethodInfo system_type_get_type_from_handle;
- static public MethodInfo object_getcurrent_void;
static public MethodInfo bool_movenext_void;
static public MethodInfo ienumerable_getenumerator_void;
static public MethodInfo void_reset_void;
static public MethodInfo int_array_get_lower_bound_int;
static public MethodInfo int_array_get_upper_bound_int;
static public MethodInfo void_array_copyto_array_int;
+ static public PropertyInfo ienumerator_getcurrent;
//
// The attribute constructors.
static public ConstructorInfo default_member_ctor;
static public ConstructorInfo decimal_constant_attribute_ctor;
static internal ConstructorInfo struct_layout_attribute_ctor;
-
+ static public ConstructorInfo field_offset_attribute_ctor;
+
///
/// A new in C# 2.0
///
// </remarks>
static Module [] modules;
- // <remarks>
- // This is the type_cache from the assemblies to avoid
- // hitting System.Reflection on every lookup.
- // </summary>
- static Hashtable types;
-
- // <remarks>
- // This is used to hotld the corresponding TypeContainer objects
- // since we need this in FindMembers
- // </remarks>
- static Hashtable typecontainers;
-
- // <remarks>
- // Keeps track of those types that are defined by the
- // user's program
- // </remarks>
- static ArrayList user_types;
-
static PtrHashtable builder_to_declspace;
static PtrHashtable builder_to_member_cache;
// <remarks>
static Hashtable method_params;
+ // <remarks>
+ // A hash table from override methods to their base virtual method.
+ // <remarks>
+ static Hashtable method_overrides;
+
// <remarks>
// Keeps track of methods
// </remarks>
// Contains all public types from referenced assemblies.
// This member is used only if CLS Compliance verification is required.
// </remarks>
- public static Hashtable all_imported_types;
+ public static Hashtable AllClsTopLevelTypes;
static Hashtable fieldbuilders_to_fields;
static Hashtable fields;
// Lets get everything clean so that we can collect before generating code
assemblies = null;
modules = null;
- types = null;
- typecontainers = null;
- user_types = null;
builder_to_declspace = null;
builder_to_member_cache = null;
builder_to_ifaces = null;
builder_to_method = null;
fields = null;
- builder_to_constant = null;
fieldbuilders_to_fields = null;
events = null;
priv_fields_events = null;
- properties = null;
type_hash = null;
TypeHandle.CleanUp ();
{
assemblies = new Assembly [0];
modules = null;
- user_types = new ArrayList ();
-
- types = new Hashtable ();
- typecontainers = new Hashtable ();
builder_to_declspace = new PtrHashtable ();
builder_to_member_cache = new PtrHashtable ();
builder_to_method = new PtrHashtable ();
method_arguments = new PtrHashtable ();
method_params = new PtrHashtable ();
+ method_overrides = new PtrHashtable ();
indexer_arguments = new PtrHashtable ();
builder_to_ifaces = new PtrHashtable ();
type_hash = new DoubleHash ();
}
- public static void HandleDuplicate (string name, Type t)
+ public static void AddUserType (string name, DeclSpace ds)
{
- Type prev = (Type) types [name];
- TypeContainer tc = builder_to_declspace [prev] as TypeContainer;
-
- if (tc != null){
- //
- // This probably never happens, as we catch this before
- //
- Report.Error (-17, "The type `" + name + "' has already been defined.");
- return;
- }
-
- tc = builder_to_declspace [t] as TypeContainer;
- if (tc != null){
- Report.Warning (
- 1595, "The type `" + name + "' is defined in an existing assembly;"+
- " Using the new definition from: " + tc.Location);
- } else {
- Report.Warning (
- 1595, "The type `" + name + "' is defined in an existing assembly;");
- }
-
- Report.Warning (1595, "Previously defined in: " + prev.Assembly.FullName);
-
- types.Remove (name);
- types.Add (name, t);
- }
-
- public static void AddUserType (string name, TypeBuilder t)
- {
- try {
- types.Add (name, t);
- } catch {
- HandleDuplicate (name, t);
- }
-
- user_types.Add (t);
+ builder_to_declspace.Add (ds.TypeBuilder, ds);
}
//
{
if (ifaces != null)
builder_to_ifaces [tb] = ifaces;
- }
-
- public static void AddUserType (string name, TypeBuilder t, TypeContainer tc)
- {
- builder_to_declspace.Add (t, tc);
- typecontainers.Add (name, tc);
- AddUserType (name, t);
- }
-
- public static void AddDelegateType (string name, TypeBuilder t, Delegate del)
- {
- try {
- types.Add (name, t);
- } catch {
- HandleDuplicate (name, t);
- }
-
- builder_to_declspace.Add (t, del);
- }
-
- public static void AddEnumType (string name, TypeBuilder t, Enum en)
- {
- try {
- types.Add (name, t);
- } catch {
- HandleDuplicate (name, t);
- }
- builder_to_declspace.Add (t, en);
- }
+ }
public static void AddMethod (MethodBase builder, IMethodData method)
{
return builder_to_declspace [t] as Delegate;
}
- public static Enum LookupEnum (Type t)
- {
- return builder_to_declspace [t] as Enum;
- }
-
public static Class LookupClass (Type t)
{
return (Class) builder_to_declspace [t];
{
object ret = null;
if (!type_hash.Lookup (t, name, out ret)) {
- string lookup = t.ToString () + "+" + name;
- ret = t.Module.GetType (lookup);
+ ret = t.GetNestedType (name,
+ BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
type_hash.Insert (t, name, ret);
}
return (Type) ret;
}
-
- //
- // Low-level lookup, cache-less
- //
- public static Type LookupTypeReflection (string name)
+
+ public static Type LookupTypeReflection (string name, Location loc)
{
- Type t;
+ Type found_type = null;
- foreach (Assembly a in assemblies){
- t = a.GetType (name);
+ foreach (Assembly a in assemblies) {
+ Type t = a.GetType (name);
if (t == null)
continue;
- do {
- TypeAttributes ta = t.Attributes & TypeAttributes.VisibilityMask;
- if (ta == TypeAttributes.NotPublic ||
- ta == TypeAttributes.NestedPrivate ||
- ta == TypeAttributes.NestedAssembly ||
- ta == TypeAttributes.NestedFamANDAssem){
-
- //
- // In .NET pointers turn out to be private, even if their
- // element type is not
- //
- if (t.IsPointer){
- t = t.GetElementType ();
- continue;
- } else
- t = null;
- } else {
- return t;
+ if (t.IsPointer)
+ throw new InternalErrorException ("Use GetPointerType() to get a pointer");
+
+ TypeAttributes ta = t.Attributes & TypeAttributes.VisibilityMask;
+ if (ta != TypeAttributes.NotPublic && ta != TypeAttributes.NestedPrivate &&
+ ta != TypeAttributes.NestedAssembly && ta != TypeAttributes.NestedFamANDAssem) {
+ if (found_type == null) {
+ found_type = t;
+ continue;
}
- } while (t != null);
+
+ Report.SymbolRelatedToPreviousError (found_type);
+ Report.SymbolRelatedToPreviousError (t);
+ Report.Error (433, loc, "The imported type `{0}' is defined multiple times", name);
+ return found_type;
+ }
}
foreach (Module mb in modules) {
- t = mb.GetType (name);
- if (t != null)
- return t;
+ Type t = mb.GetType (name);
+ if (t == null)
+ continue;
+
+ if (found_type == null) {
+ found_type = t;
+ continue;
+ }
+
+ Report.SymbolRelatedToPreviousError (t);
+ Report.SymbolRelatedToPreviousError (found_type);
+ Report.Warning (436, 2, loc, "Ignoring imported type `{0}' since the current assembly already has a declaration with the same name",
+ TypeManager.CSharpName (t));
+ return t;
}
-
- return null;
+
+ return found_type;
}
/// <summary>
Assembly a = assemblies [i];
string [] namespaces = (string []) assembly_get_namespaces.Invoke (a, null);
foreach (string ns in namespaces){
- if (ns == "")
+ if (ns.Length == 0)
continue;
Namespace.LookupNamespace (ns, true);
}
/// </summary>
public static void LoadAllImportedTypes ()
{
- all_imported_types = new Hashtable ();
+ AllClsTopLevelTypes = new Hashtable (1500);
foreach (Assembly a in assemblies) {
foreach (Type t in a.GetExportedTypes ()) {
- all_imported_types [t.FullName] = t;
+ AllClsTopLevelTypes [t.FullName.ToLower (System.Globalization.CultureInfo.InvariantCulture)] = null;
}
}
}
/// </summary>
static public string GetFullNameSignature (MemberInfo mi)
{
- // Unfortunately, there's no dynamic dispatch on the arguments of a function.
return (mi is MethodBase)
- ? GetFullNameSignature (mi as MethodBase)
- : mi.DeclaringType.FullName.Replace ('+', '.') + '.' + mi.Name;
- }
-
- static public string GetFullNameSignature (MethodBase mb)
- {
- string name = mb.Name;
- if (name == ".ctor")
- name = mb.DeclaringType.Name;
-
- if (mb.IsSpecialName) {
- if (name.StartsWith ("get_") || name.StartsWith ("set_")) {
- name = name.Remove (0, 4);
- }
-
- if (name == "Item")
- name = "this";
- }
-
- return mb.DeclaringType.FullName.Replace ('+', '.') + '.' + name;
+ ? CSharpSignature (mi as MethodBase)
+ : CSharpName (mi.DeclaringType) + '.' + mi.Name;
}
/// <summary>
- /// Returns the signature of the property and indexer
+ /// When we need to report accessors as well
/// </summary>
- static public string CSharpSignature (PropertyBuilder pb, bool is_indexer)
+ static public string CSharpSignature (MethodBase mb)
{
- if (!is_indexer) {
- return GetFullNameSignature (pb);
- }
-
- MethodBase mb = pb.GetSetMethod (true) != null ? pb.GetSetMethod (true) : pb.GetGetMethod (true);
- string signature = GetFullNameSignature (mb);
- string arg = GetParameterData (mb).ParameterDesc (0);
- return String.Format ("{0}.this[{1}]", signature.Substring (0, signature.LastIndexOf ('.')), arg);
+ return CSharpSignature (mb, false);
}
/// <summary>
/// Returns the signature of the method
/// </summary>
- static public string CSharpSignature (MethodBase mb)
+ static public string CSharpSignature (MethodBase mb, bool show_accessor)
{
- StringBuilder sig = new StringBuilder ("(");
+ StringBuilder sig = new StringBuilder (CSharpName (mb.DeclaringType));
+ sig.Append ('.');
ParameterData iparams = GetParameterData (mb);
+ string parameters = iparams.GetSignatureForError ();
+ string accessor = "";
// Is property
- if (mb.IsSpecialName && iparams.Count == 0 && !mb.IsConstructor)
- return GetFullNameSignature (mb);
-
- for (int i = 0; i < iparams.Count; i++) {
- if (i > 0) {
- sig.Append (", ");
+ if (mb.IsSpecialName) {
+ Operator.OpType ot = Operator.GetOperatorType (mb.Name);
+ if (ot != Operator.OpType.TOP) {
+ sig.Append ("operator ");
+ sig.Append (Operator.GetName (ot));
+ sig.Append (parameters);
+ return sig.ToString ();
+ }
+
+ if (mb.Name.StartsWith ("get_") || mb.Name.StartsWith ("set_")) {
+ accessor = mb.Name.Substring (0, 3);
}
- sig.Append (iparams.ParameterDesc (i));
}
- sig.Append (")");
// Is indexer
- if (mb.IsSpecialName && iparams.Count == 1 && !mb.IsConstructor) {
- sig.Replace ('(', '[');
- sig.Replace (')', ']');
+ if (mb.IsSpecialName && !mb.IsConstructor) {
+ if (iparams.Count > 1) {
+ sig.Append ("this[");
+ if (show_accessor) {
+ sig.Append (parameters.Substring (1, parameters.Length - 2));
+ }
+ else {
+ int before_ret_val = parameters.LastIndexOf (',');
+ sig.Append (parameters.Substring (1, before_ret_val - 1));
+ }
+ sig.Append (']');
+ } else {
+ sig.Append (mb.Name.Substring (4));
+ }
+ } else {
+ if (mb.Name == ".ctor")
+ sig.Append (mb.DeclaringType.Name);
+ else
+ sig.Append (mb.Name);
+
+ sig.Append (parameters);
}
- return GetFullNameSignature (mb) + sig.ToString ();
+ if (show_accessor && accessor.Length > 0) {
+ sig.Append ('.');
+ sig.Append (accessor);
+ }
+
+ return sig.ToString ();
+ }
+
+ static public string CSharpSignature (EventInfo ei)
+ {
+ return CSharpName (ei.DeclaringType) + '.' + ei.Name;
}
/// <summary>
/// Looks up a type, and aborts if it is not found. This is used
/// by types required by the compiler
/// </summary>
- static Type CoreLookupType (string name)
+ static Type CoreLookupType (string ns_name, string name)
{
- Type t = null;
- if (types.Contains (name))
- t = (Type) types [name];
- else
- t = LookupTypeReflection (name);
-
+ Namespace ns = Namespace.LookupNamespace (ns_name, true);
+ FullNamedExpression fne = ns.Lookup (RootContext.Tree.Types, name, Location.Null);
+ Type t = fne == null ? null : fne.Type;
if (t == null)
Report.Error (518, "The predefined type `" + name + "' is not defined or imported");
-
- types [name] = t;
return t;
}
return GetMethod (t, name, args, true);
}
+ /// <summary>
+ /// Returns the PropertyInfo for a property named `name' defined
+ /// in type `t'
+ /// </summary>
+ static PropertyInfo GetProperty (Type t, string name)
+ {
+ MemberList list = FindMembers (t, MemberTypes.Property, BindingFlags.Public |
+ BindingFlags.Instance, Type.FilterName, name);
+ if (list.Count == 0) {
+ Report.Error (-19, "Can not find the core property `" + name + "'");
+ return null;
+ }
+
+ PropertyInfo pi = list [0] as PropertyInfo;
+ if (pi == null) {
+ Report.Error (-19, "Can not find the core function `" + name + "'");
+ return null;
+ }
+
+ return pi;
+ }
/// <summary>
/// Returns the ConstructorInfo for "args"
public static void InitEnumUnderlyingTypes ()
{
- int32_type = CoreLookupType ("System.Int32");
- int64_type = CoreLookupType ("System.Int64");
- uint32_type = CoreLookupType ("System.UInt32");
- uint64_type = CoreLookupType ("System.UInt64");
- byte_type = CoreLookupType ("System.Byte");
- sbyte_type = CoreLookupType ("System.SByte");
- short_type = CoreLookupType ("System.Int16");
- ushort_type = CoreLookupType ("System.UInt16");
+ int32_type = CoreLookupType ("System", "Int32");
+ int64_type = CoreLookupType ("System", "Int64");
+ uint32_type = CoreLookupType ("System", "UInt32");
+ uint64_type = CoreLookupType ("System", "UInt64");
+ byte_type = CoreLookupType ("System", "Byte");
+ sbyte_type = CoreLookupType ("System", "SByte");
+ short_type = CoreLookupType ("System", "Int16");
+ ushort_type = CoreLookupType ("System", "UInt16");
}
/// <remarks>
/// </remarks>
public static void InitCoreTypes ()
{
- object_type = CoreLookupType ("System.Object");
- value_type = CoreLookupType ("System.ValueType");
+ object_type = CoreLookupType ("System", "Object");
+ value_type = CoreLookupType ("System", "ValueType");
InitEnumUnderlyingTypes ();
- char_type = CoreLookupType ("System.Char");
- string_type = CoreLookupType ("System.String");
- float_type = CoreLookupType ("System.Single");
- double_type = CoreLookupType ("System.Double");
- char_ptr_type = CoreLookupType ("System.Char*");
- decimal_type = CoreLookupType ("System.Decimal");
- bool_type = CoreLookupType ("System.Boolean");
- enum_type = CoreLookupType ("System.Enum");
-
- multicast_delegate_type = CoreLookupType ("System.MulticastDelegate");
- delegate_type = CoreLookupType ("System.Delegate");
-
- array_type = CoreLookupType ("System.Array");
- void_type = CoreLookupType ("System.Void");
- type_type = CoreLookupType ("System.Type");
-
- runtime_field_handle_type = CoreLookupType ("System.RuntimeFieldHandle");
- runtime_argument_handle_type = CoreLookupType ("System.RuntimeArgumentHandle");
- runtime_helpers_type = CoreLookupType ("System.Runtime.CompilerServices.RuntimeHelpers");
- default_member_type = CoreLookupType ("System.Reflection.DefaultMemberAttribute");
- runtime_handle_type = CoreLookupType ("System.RuntimeTypeHandle");
- asynccallback_type = CoreLookupType ("System.AsyncCallback");
- iasyncresult_type = CoreLookupType ("System.IAsyncResult");
- ienumerator_type = CoreLookupType ("System.Collections.IEnumerator");
- ienumerable_type = CoreLookupType ("System.Collections.IEnumerable");
- idisposable_type = CoreLookupType ("System.IDisposable");
- icloneable_type = CoreLookupType ("System.ICloneable");
- iconvertible_type = CoreLookupType ("System.IConvertible");
- monitor_type = CoreLookupType ("System.Threading.Monitor");
- intptr_type = CoreLookupType ("System.IntPtr");
-
- attribute_type = CoreLookupType ("System.Attribute");
- attribute_usage_type = CoreLookupType ("System.AttributeUsageAttribute");
- dllimport_type = CoreLookupType ("System.Runtime.InteropServices.DllImportAttribute");
- methodimpl_attr_type = CoreLookupType ("System.Runtime.CompilerServices.MethodImplAttribute");
- marshal_as_attr_type = CoreLookupType ("System.Runtime.InteropServices.MarshalAsAttribute");
- param_array_type = CoreLookupType ("System.ParamArrayAttribute");
- in_attribute_type = CoreLookupType ("System.Runtime.InteropServices.InAttribute");
- out_attribute_type = CoreLookupType ("System.Runtime.InteropServices.OutAttribute");
- typed_reference_type = CoreLookupType ("System.TypedReference");
- arg_iterator_type = CoreLookupType ("System.ArgIterator");
- mbr_type = CoreLookupType ("System.MarshalByRefObject");
- decimal_constant_attribute_type = CoreLookupType ("System.Runtime.CompilerServices.DecimalConstantAttribute");
-
- unverifiable_code_type= CoreLookupType ("System.Security.UnverifiableCodeAttribute");
-
- void_ptr_type = CoreLookupType ("System.Void*");
-
- indexer_name_type = CoreLookupType ("System.Runtime.CompilerServices.IndexerNameAttribute");
-
- exception_type = CoreLookupType ("System.Exception");
- invalid_operation_exception_type = CoreLookupType ("System.InvalidOperationException");
- not_supported_exception_type = CoreLookupType ("System.NotSupportedException");
+ char_type = CoreLookupType ("System", "Char");
+ string_type = CoreLookupType ("System", "String");
+ float_type = CoreLookupType ("System", "Single");
+ double_type = CoreLookupType ("System", "Double");
+ char_ptr_type = GetPointerType (char_type);
+ decimal_type = CoreLookupType ("System", "Decimal");
+ bool_type = CoreLookupType ("System", "Boolean");
+ enum_type = CoreLookupType ("System", "Enum");
+
+ multicast_delegate_type = CoreLookupType ("System", "MulticastDelegate");
+ delegate_type = CoreLookupType ("System", "Delegate");
+
+ array_type = CoreLookupType ("System", "Array");
+ void_type = CoreLookupType ("System", "Void");
+ type_type = CoreLookupType ("System", "Type");
+
+ runtime_field_handle_type = CoreLookupType ("System", "RuntimeFieldHandle");
+ runtime_argument_handle_type = CoreLookupType ("System", "RuntimeArgumentHandle");
+ runtime_helpers_type = CoreLookupType ("System.Runtime.CompilerServices", "RuntimeHelpers");
+ default_member_type = CoreLookupType ("System.Reflection", "DefaultMemberAttribute");
+ runtime_handle_type = CoreLookupType ("System", "RuntimeTypeHandle");
+ asynccallback_type = CoreLookupType ("System", "AsyncCallback");
+ iasyncresult_type = CoreLookupType ("System", "IAsyncResult");
+ ienumerator_type = CoreLookupType ("System.Collections", "IEnumerator");
+ ienumerable_type = CoreLookupType ("System.Collections", "IEnumerable");
+ idisposable_type = CoreLookupType ("System", "IDisposable");
+ icloneable_type = CoreLookupType ("System", "ICloneable");
+ iconvertible_type = CoreLookupType ("System", "IConvertible");
+ monitor_type = CoreLookupType ("System.Threading", "Monitor");
+ intptr_type = CoreLookupType ("System", "IntPtr");
+
+ attribute_type = CoreLookupType ("System", "Attribute");
+ attribute_usage_type = CoreLookupType ("System", "AttributeUsageAttribute");
+ dllimport_type = CoreLookupType ("System.Runtime.InteropServices", "DllImportAttribute");
+ methodimpl_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "MethodImplAttribute");
+ marshal_as_attr_type = CoreLookupType ("System.Runtime.InteropServices", "MarshalAsAttribute");
+ param_array_type = CoreLookupType ("System", "ParamArrayAttribute");
+ in_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "InAttribute");
+ out_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "OutAttribute");
+ typed_reference_type = CoreLookupType ("System", "TypedReference");
+ arg_iterator_type = CoreLookupType ("System", "ArgIterator");
+ mbr_type = CoreLookupType ("System", "MarshalByRefObject");
+ decimal_constant_attribute_type = CoreLookupType ("System.Runtime.CompilerServices", "DecimalConstantAttribute");
+
+ unverifiable_code_type= CoreLookupType ("System.Security", "UnverifiableCodeAttribute");
+
+ void_ptr_type = GetPointerType (void_type);
+
+ indexer_name_type = CoreLookupType ("System.Runtime.CompilerServices", "IndexerNameAttribute");
+
+ exception_type = CoreLookupType ("System", "Exception");
+ invalid_operation_exception_type = CoreLookupType ("System", "InvalidOperationException");
+ not_supported_exception_type = CoreLookupType ("System", "NotSupportedException");
//
// Attribute types
//
- obsolete_attribute_type = CoreLookupType ("System.ObsoleteAttribute");
- conditional_attribute_type = CoreLookupType ("System.Diagnostics.ConditionalAttribute");
- cls_compliant_attribute_type = CoreLookupType ("System.CLSCompliantAttribute");
- struct_layout_attribute_type = CoreLookupType ("System.Runtime.InteropServices.StructLayoutAttribute");
- field_offset_attribute_type = CoreLookupType ("System.Runtime.InteropServices.FieldOffsetAttribute");
- security_attr_type = CoreLookupType ("System.Security.Permissions.SecurityAttribute");
- required_attr_type = CoreLookupType ("System.Runtime.CompilerServices.RequiredAttributeAttribute");
+ obsolete_attribute_type = CoreLookupType ("System", "ObsoleteAttribute");
+ conditional_attribute_type = CoreLookupType ("System.Diagnostics", "ConditionalAttribute");
+ cls_compliant_attribute_type = CoreLookupType ("System", "CLSCompliantAttribute");
+ struct_layout_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "StructLayoutAttribute");
+ field_offset_attribute_type = CoreLookupType ("System.Runtime.InteropServices", "FieldOffsetAttribute");
+ security_attr_type = CoreLookupType ("System.Security.Permissions", "SecurityAttribute");
+ required_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "RequiredAttributeAttribute");
+ guid_attr_type = CoreLookupType ("System.Runtime.InteropServices", "GuidAttribute");
+ assembly_culture_attribute_type = CoreLookupType ("System.Reflection", "AssemblyCultureAttribute");
//
// .NET 2.0
//
#if NET_2_0
- compiler_generated_attr_type = CoreLookupType ("System.Runtime.CompilerServices.CompilerGeneratedAttribute");
- fixed_buffer_attr_type = CoreLookupType ("System.Runtime.CompilerServices.FixedBufferAttribute");
+ compiler_generated_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "CompilerGeneratedAttribute");
+ fixed_buffer_attr_type = CoreLookupType ("System.Runtime.CompilerServices", "FixedBufferAttribute");
+ default_charset_type = CoreLookupType ("System.Runtime.InteropServices", "DefaultCharSetAttribute");
#endif
//
// When compiling corlib, store the "real" types here.
// Void arguments
//
Type [] void_arg = { };
- object_getcurrent_void = GetMethod (
- ienumerator_type, "get_Current", void_arg);
+ ienumerator_getcurrent = GetProperty (
+ ienumerator_type, "Current");
bool_movenext_void = GetMethod (
ienumerator_type, "MoveNext", void_arg);
void_reset_void = GetMethod (
decimal_constant_attribute_ctor = GetConstructor (decimal_constant_attribute_type, new Type []
{ byte_type, byte_type, uint32_type, uint32_type, uint32_type } );
+ field_offset_attribute_ctor = GetConstructor (field_offset_attribute_type, new Type []
+ { int32_type });
//
// .NET 2.0 types
public static bool IsEnumType (Type t)
{
- if (t.IsSubclassOf (TypeManager.enum_type))
+ if (builder_to_declspace [t] is Enum)
return true;
- else
- return false;
+
+ return t.IsEnum;
}
+
public static bool IsBuiltinOrEnum (Type t)
{
if (IsBuiltinType (t))
return false;
}
+ static Stack unmanaged_enclosing_types = new Stack (4);
+
//
// Whether a type is unmanaged. This is used by the unsafe code (25.2)
//
public static bool IsUnmanagedType (Type t)
{
+ // Avoid infloops in the case of: unsafe struct Foo { Foo *x; }
+ if (unmanaged_enclosing_types.Contains (t))
+ return true;
+
// builtins that are not unmanaged types
if (t == TypeManager.object_type || t == TypeManager.string_type)
return false;
if (IsBuiltinOrEnum (t))
return true;
+ // Someone did the work of checking if the ElementType of t is unmanaged. Let's not repeat it.
if (t.IsPointer)
return true;
+ // Arrays are disallowed, even if we mark them with [MarshalAs(UnmanagedType.ByValArray, ...)]
+ if (t.IsArray)
+ return false;
+
if (!IsValueType (t))
return false;
+ unmanaged_enclosing_types.Push (t);
+
+ bool retval = true;
+
if (t is TypeBuilder){
TypeContainer tc = LookupTypeContainer (t);
+ if (tc.Fields != null){
+ foreach (Field f in tc.Fields){
+ // Avoid using f.FieldBuilder: f.Define () may not yet have been invoked.
+ if ((f.ModFlags & Modifiers.STATIC) != 0)
+ continue;
+ if (f.MemberType == null)
+ continue;
+ if (!IsUnmanagedType (f.MemberType)){
+ Report.SymbolRelatedToPreviousError (f.Location, CSharpName (t) + "." + f.Name);
+ retval = false;
+ }
+ }
+ }
+ } else {
+ FieldInfo [] fields = t.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
- if (tc.Fields == null)
- return true;
- foreach (Field f in tc.Fields){
- // Avoid using f.FieldBuilder: f.Define () may not yet have been invoked.
- if ((f.ModFlags & Modifiers.STATIC) != 0)
- continue;
- if (!IsUnmanagedType (f.MemberType))
- return false;
+ foreach (FieldInfo f in fields){
+ if (!IsUnmanagedType (f.FieldType)){
+ Report.SymbolRelatedToPreviousError (f);
+ retval = false;
+ }
}
- return true;
}
-
- FieldInfo [] fields = t.GetFields (BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
- foreach (FieldInfo f in fields)
- if (!IsUnmanagedType (f.FieldType))
- return false;
+ unmanaged_enclosing_types.Pop ();
- return true;
+ return retval;
}
public static bool IsValueType (Type t)
{
return t.IsArray || t.IsPointer || t.IsByRef;
}
-
- /// <summary>
- /// Returns the User Defined Types
- /// </summary>
- public static ArrayList UserTypes {
- get {
- return user_types;
- }
- }
-
- public static Hashtable TypeContainers {
- get {
- return typecontainers;
- }
- }
-
- static Hashtable builder_to_constant;
-
- public static void RegisterConstant (FieldBuilder fb, Const c)
- {
- if (builder_to_constant == null)
- builder_to_constant = new PtrHashtable ();
-
- if (builder_to_constant.Contains (fb))
- return;
-
- builder_to_constant.Add (fb, c);
- }
-
- public static Const LookupConstant (FieldBuilder fb)
- {
- if (builder_to_constant == null)
- return null;
-
- return (Const) builder_to_constant [fb];
- }
/// <summary>
/// Gigantic work around for missing features in System.Reflection.Emit follows.
return (ParameterData) pd;
}
+ static public void RegisterOverride (MethodBase override_method, MethodBase base_method)
+ {
+ if (method_overrides.Contains (override_method)) {
+ if (method_overrides [override_method] != base_method)
+ throw new InternalErrorException ("Override mismatch: " + override_method);
+ return;
+ }
+ method_overrides [override_method] = base_method;
+ }
+
+ static public bool IsOverride (MethodBase m)
+ {
+ return m.IsVirtual &&
+ (m.Attributes & MethodAttributes.NewSlot) == 0 &&
+ (m is MethodBuilder || method_overrides.Contains (m));
+ }
+
/// <summary>
/// Returns the argument types for a method based on its methodbase
///
}
}
- // <remarks>
- // This is a workaround the fact that GetValue is not
- // supported for dynamic types
- // </remarks>
- static public bool RegisterFieldValue (FieldBuilder fb, object value)
+ public static void RegisterConstant (FieldInfo fb, IConstant ic)
{
- if (fields.Contains (fb))
- return false;
-
- fields.Add (fb, value);
-
- return true;
+ fields.Add (fb, ic);
}
- static public object GetValue (FieldBuilder fb)
+ public static IConstant GetConstant (FieldInfo fb)
{
- return fields [fb];
+ if (fb == null)
+ return null;
+
+ return (IConstant)fields [fb];
}
static public bool RegisterFieldBase (FieldBuilder fb, FieldBase f)
return (MemberInfo) priv_fields_events [ei];
}
- static Hashtable properties;
-
- static public bool RegisterProperty (PropertyBuilder pb, MethodBase get, MethodBase set)
- {
- if (properties == null)
- properties = new Hashtable ();
-
- if (properties.Contains (pb))
- return false;
-
- properties.Add (pb, new Pair (get, set));
-
- return true;
- }
-
static public bool RegisterIndexer (PropertyBuilder pb, MethodBase get,
MethodBase set, Type[] args)
{
- if (!RegisterProperty (pb, get,set))
- return false;
-
indexer_arguments.Add (pb, args);
return true;
t == TypeManager.int64_type ||
t == TypeManager.uint64_type)
return t;
- throw new Exception ("Unhandled typecode in enum " + " from " + t.AssemblyQualifiedName);
}
TypeCode tc = Type.GetTypeCode (t);
if (IsUnmanagedType (t))
return true;
- // We need this explicit check here to make it work when compiling corlib.
- if (!RootContext.StdLib && (t == TypeManager.decimal_type))
- return true;
+ Report.Error (208, loc, "Cannot take the address of, get the size of, or declare a pointer to a managed type `{0}'",
+ CSharpName (t));
- Report.Error (
- 208, loc,
- "Cannot take the address or size of a variable of a managed type ('" +
- CSharpName (t) + "')");
return false;
}
new Type [] { typeof (Type), typeof (bool)},
null);
if (declare_local_method == null){
- Report.Warning (-24, new Location (-1),
+ Report.Warning (-30, new Location (-1),
"This version of the runtime does not support making pinned local variables. " +
"This code may cause errors on a runtime with a moving GC");
return ig.DeclareLocal (t);
if (invocation_type == null)
return false;
- Debug.Assert (IsNestedFamilyAccessible (invocation_type, m.DeclaringType));
-
- if (is_static)
+ if (is_static && qualifier_type == null)
+ // It resolved from a simple name, so it should be visible.
return true;
-
+
// A nested class has access to all the protected members visible to its parent.
- if (qualifier_type != null
- && TypeManager.IsNestedChildOf (invocation_type, qualifier_type))
+ if (qualifier_type != null && TypeManager.IsNestedChildOf (invocation_type, qualifier_type))
return true;
- if (invocation_type == m.DeclaringType
- || invocation_type.IsSubclassOf (m.DeclaringType)) {
+ if (invocation_type == m.DeclaringType || invocation_type.IsSubclassOf (m.DeclaringType)) {
// Although a derived class can access protected members of its base class
// it cannot do so through an instance of the base class (CS1540).
// => Ancestry should be: declaring_type ->* invocation_type ->* qualified_type
- if (qualifier_type == null
- || qualifier_type == invocation_type
- || qualifier_type.IsSubclassOf (invocation_type))
+ if (is_static ||
+ qualifier_type == null ||
+ qualifier_type == invocation_type ||
+ qualifier_type.IsSubclassOf (invocation_type))
return true;
}
if (almost_match != null)
almost_match.Add (m);
+
return false;
}
MethodAttributes ma = mb.Attributes & MethodAttributes.MemberAccessMask;
if (ma == MethodAttributes.Private)
- return private_ok || (invocation_type == m.DeclaringType) ||
+ return private_ok || invocation_type == m.DeclaringType ||
IsNestedChildOf (invocation_type, m.DeclaringType);
-
- // Assembly succeeds if we're in the same assembly.
- if (ma == MethodAttributes.Assembly)
- return (invocation_assembly == mb.DeclaringType.Assembly);
-
- // FamAndAssem requires that we not only derive, but we are on the same assembly.
- if (ma == MethodAttributes.FamANDAssem){
- if (invocation_assembly != mb.DeclaringType.Assembly)
+
+ if (invocation_assembly == mb.DeclaringType.Assembly) {
+ if (ma == MethodAttributes.Assembly || ma == MethodAttributes.FamORAssem)
+ return true;
+ } else {
+ if (ma == MethodAttributes.Assembly || ma == MethodAttributes.FamANDAssem)
return false;
}
-
- // Family and FamANDAssem require that we derive.
- if ((ma == MethodAttributes.Family) || (ma == MethodAttributes.FamANDAssem))
+
+ if (ma == MethodAttributes.Family ||
+ ma == MethodAttributes.FamANDAssem ||
+ ma == MethodAttributes.FamORAssem)
return CheckValidFamilyAccess (mb.IsStatic, m);
// Public.
if (fa == FieldAttributes.Private)
return private_ok || (invocation_type == m.DeclaringType) ||
IsNestedChildOf (invocation_type, m.DeclaringType);
-
- // Assembly succeeds if we're in the same assembly.
- if (fa == FieldAttributes.Assembly)
- return (invocation_assembly == fi.DeclaringType.Assembly);
-
- // FamAndAssem requires that we not only derive, but we are on the same assembly.
- if (fa == FieldAttributes.FamANDAssem){
- if (invocation_assembly != fi.DeclaringType.Assembly)
+
+ if (invocation_assembly == fi.DeclaringType.Assembly) {
+ if (fa == FieldAttributes.Assembly || fa == FieldAttributes.FamORAssem)
+ return true;
+ } else {
+ if (fa == FieldAttributes.Assembly || fa == FieldAttributes.FamANDAssem)
return false;
}
-
- // Family and FamANDAssem require that we derive.
- if ((fa == FieldAttributes.Family) || (fa == FieldAttributes.FamANDAssem))
+
+ if (fa == FieldAttributes.Family ||
+ fa == FieldAttributes.FamANDAssem ||
+ fa == FieldAttributes.FamORAssem)
return CheckValidFamilyAccess (fi.IsStatic, m);
// Public.
Type current_type = queried_type;
bool searching = (original_bf & BindingFlags.DeclaredOnly) == 0;
bool skip_iface_check = true, used_cache = false;
- bool always_ok_flag = false;
+ bool always_ok_flag = invocation_type != null && IsNestedChildOf (invocation_type, queried_type);
closure.invocation_type = invocation_type;
closure.invocation_assembly = invocation_type != null ? invocation_type.Assembly : null;
closure.qualifier_type = qualifier_type;
closure.almost_match = almost_match;
-
- //
- // If we are a nested class, we always have access to our container
- // type names
- //
- if (invocation_type != null){
- string invocation_name = invocation_type.FullName;
- if (invocation_name.IndexOf ('+') != -1){
- string container = queried_type.FullName + "+";
- int container_length = container.Length;
-
- if (invocation_name.Length > container_length){
- string shared = invocation_name.Substring (0, container_length);
-
- if (shared == container)
- always_ok_flag = true;
- }
- }
- }
// This is from the first time we find a method
// in most cases, we do not actually find a method in the base class
projects / mono.git / blobdiff