Author: martin
Date: 2007-09-27 02:21:04 -0400 (Thu, 27 Sep 2007)
New Revision: 86459

Modified:
   trunk/debugger/ChangeLog
   trunk/debugger/languages/mono/MonoFundamentalType.cs
   trunk/debugger/languages/mono/MonoLanguageBackend.cs
   trunk/debugger/languages/mono/MonoStringType.cs
Log:
2007-09-27  Martin Baulig  <[EMAIL PROTECTED]>

        * languages/mono/MonoFundamentalType.cs
        (MonoFundamentalType): Replace the public .ctor with a static
        Create() method.        

        * languages/mono/MonoStringType.cs
        (MonoStringType): Replace the public .ctor with a static
        Create() method.



Modified: trunk/debugger/ChangeLog
===================================================================
--- trunk/debugger/ChangeLog    2007-09-27 04:06:26 UTC (rev 86458)
+++ trunk/debugger/ChangeLog    2007-09-27 06:21:04 UTC (rev 86459)
@@ -1,3 +1,13 @@
+2007-09-27  Martin Baulig  <[EMAIL PROTECTED]>
+
+       * languages/mono/MonoFundamentalType.cs
+       (MonoFundamentalType): Replace the public .ctor with a static
+       Create() method.        
+
+       * languages/mono/MonoStringType.cs
+       (MonoStringType): Replace the public .ctor with a static
+       Create() method.
+
 2007-09-26  Wade Berrier  <[EMAIL PROTECTED]>
 
        * languages/native/Makefile.am:

Modified: trunk/debugger/languages/mono/MonoFundamentalType.cs
===================================================================
--- trunk/debugger/languages/mono/MonoFundamentalType.cs        2007-09-27 
04:06:26 UTC (rev 86458)
+++ trunk/debugger/languages/mono/MonoFundamentalType.cs        2007-09-27 
06:21:04 UTC (rev 86459)
@@ -1,31 +1,159 @@
 using System;
+using Mono.Debugger.Backends;
 
 namespace Mono.Debugger.Languages.Mono
 {
        internal class MonoFundamentalType : TargetFundamentalType
        {
                MonoSymbolFile file;
+               MonoClassInfo class_info;
                MonoClassType class_type;
+               Cecil.TypeDefinition typedef;
 
-               public MonoFundamentalType (MonoSymbolFile file, 
Cecil.TypeDefinition typedef,
-                                           MonoClassInfo class_info, string 
name, FundamentalKind kind,
-                                           int size)
+               protected MonoFundamentalType (MonoSymbolFile file, 
Cecil.TypeDefinition typedef,
+                                              string name, FundamentalKind 
kind, int size)
                        : base (file.Language, name, kind, size)
                {
                        this.file = file;
-                       this.class_type = class_info.ClassType;
+                       this.typedef = typedef;
                }
 
+               public static MonoFundamentalType Create (MonoSymbolFile corlib,
+                                                         TargetMemoryAccess 
memory,
+                                                         TargetReader 
mono_defaults,
+                                                         FundamentalKind kind)
+               {
+                       MonoFundamentalType fundamental;
+
+                       int offset;
+                       int address_size = memory.TargetInfo.TargetAddressSize;
+                       MonoMetadataInfo metadata = 
corlib.MonoLanguage.MonoMetadataInfo;
+
+                       switch (kind) {
+                       case FundamentalKind.Boolean:
+                               offset = metadata.MonoDefaultsBooleanOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Boolean"],
+                                       "bool", kind, 1);
+                               break;
+
+                       case FundamentalKind.Char:
+                               offset = metadata.MonoDefaultsCharOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Char"],
+                                       "char", kind, 2);
+                               break;
+
+                       case FundamentalKind.SByte:
+                               offset = metadata.MonoDefaultsSByteOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.SByte"],
+                                       "sbyte", kind, 1);
+                               break;
+
+                       case FundamentalKind.Byte:
+                               offset = metadata.MonoDefaultsByteOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Byte"],
+                                       "byte", kind, 1);
+                               break;
+
+                       case FundamentalKind.Int16:
+                               offset = metadata.MonoDefaultsInt16Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Int16"],
+                                       "short", kind, 2);
+                               break;
+
+                       case FundamentalKind.UInt16:
+                               offset = metadata.MonoDefaultsUInt16Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.UInt16"],
+                                       "ushort", kind, 2);
+                               break;
+
+                       case FundamentalKind.Int32:
+                               offset = metadata.MonoDefaultsInt32Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Int32"],
+                                       "int", kind, 4);
+                               break;
+
+                       case FundamentalKind.UInt32:
+                               offset = metadata.MonoDefaultsUInt32Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.UInt32"],
+                                       "uint", kind, 4);
+                               break;
+
+                       case FundamentalKind.Int64:
+                               offset = metadata.MonoDefaultsInt64Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Int64"],
+                                       "long", kind, 8);
+                               break;
+
+                       case FundamentalKind.UInt64:
+                               offset = metadata.MonoDefaultsUInt64Offset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.UInt64"],
+                                       "ulong", kind, 8);
+                               break;
+
+                       case FundamentalKind.Single:
+                               offset = metadata.MonoDefaultsSingleOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Single"],
+                                       "float", kind, 4);
+                               break;
+
+                       case FundamentalKind.Double:
+                               offset = metadata.MonoDefaultsDoubleOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.Double"],
+                                       "double", kind, 8);
+                               break;
+
+                       case FundamentalKind.IntPtr:
+                               offset = metadata.MonoDefaultsIntOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.IntPtr"],
+                                       "System.IntPtr", kind, 
memory.TargetInfo.TargetAddressSize);
+                               break;
+
+                       case FundamentalKind.UIntPtr:
+                               offset = metadata.MonoDefaultsUIntOffset;
+                               fundamental = new MonoFundamentalType (
+                                       corlib, corlib.ModuleDefinition.Types 
["System.UIntPtr"],
+                                       "System.UIntPtr", kind, 
memory.TargetInfo.TargetAddressSize);
+                               break;
+
+                       default:
+                               throw new InternalError ();
+                       }
+
+                       TargetAddress klass = mono_defaults.PeekAddress 
(offset);
+                       fundamental.create_type (memory, klass);
+                       return fundamental;
+               }
+
+               protected void create_type (TargetMemoryAccess memory, 
TargetAddress klass)
+               {
+                       class_info = file.MonoLanguage.CreateClassInfo (file, 
typedef, memory, klass);
+                       class_type = new MonoClassType (file, typedef, 
class_info);
+                       file.MonoLanguage.AddCoreType (typedef, this, 
class_type, klass);
+               }
+
                public override bool HasClassType {
                        get { return true; }
                }
 
                public override TargetClassType ClassType {
-                       get { return class_type; }
+                       get { return class_info.ClassType; }
                }
 
                internal MonoClassType MonoClassType {
-                       get { return class_type; }
+                       get { return class_info.ClassType; }
                }
        }
 }

Modified: trunk/debugger/languages/mono/MonoLanguageBackend.cs
===================================================================
--- trunk/debugger/languages/mono/MonoLanguageBackend.cs        2007-09-27 
04:06:26 UTC (rev 86458)
+++ trunk/debugger/languages/mono/MonoLanguageBackend.cs        2007-09-27 
06:21:04 UTC (rev 86459)
@@ -58,117 +58,42 @@
                        ObjectType = new MonoObjectType (corlib, object_type, 
object_size);
                        language.AddCoreType (object_type, ObjectType, 
ObjectType.MonoClassType, klass);
 
-                       mono_defaults.Offset = info.MonoDefaultsByteOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition byte_type = 
corlib.ModuleDefinition.Types ["System.Byte"];
-                       MonoClassInfo byte_info = language.CreateClassInfo 
(corlib, byte_type, memory, klass);
-                       ByteType = new MonoFundamentalType (corlib, byte_type, 
byte_info, "byte", FundamentalKind.Byte, 1);
-                       language.AddCoreType (byte_type, ByteType, 
ByteType.ClassType, klass);
-
                        mono_defaults.Offset = info.MonoDefaultsVoidOffset;
                        klass = mono_defaults.ReadAddress ();
                        Cecil.TypeDefinition void_type = 
corlib.ModuleDefinition.Types ["System.Void"];
                        VoidType = new MonoOpaqueType (corlib, void_type);
                        language.AddCoreType (void_type, VoidType, 
VoidType.ClassType, klass);
 
-                       mono_defaults.Offset = info.MonoDefaultsBooleanOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition bool_type = 
corlib.ModuleDefinition.Types ["System.Boolean"];
-                       MonoClassInfo bool_info = language.CreateClassInfo 
(corlib, bool_type, memory, klass);
-                       BooleanType = new MonoFundamentalType (corlib, 
bool_type, bool_info, "bool", FundamentalKind.Boolean, 1);
-                       language.AddCoreType (bool_type, BooleanType, 
BooleanType.ClassType, klass);
+                       StringType = MonoStringType.Create (corlib, memory, 
mono_defaults);
 
-                       mono_defaults.Offset = info.MonoDefaultsSByteOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition sbyte_type = 
corlib.ModuleDefinition.Types ["System.SByte"];
-                       MonoClassInfo sbyte_info = language.CreateClassInfo 
(corlib, sbyte_type, memory, klass);
-                       SByteType = new MonoFundamentalType (corlib, 
sbyte_type, sbyte_info, "sbyte", FundamentalKind.SByte, 1);
-                       language.AddCoreType (sbyte_type, SByteType, 
SByteType.ClassType, klass);
+                       BooleanType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Boolean);
+                       CharType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Char);
+                       SByteType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.SByte);
+                       Int16Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Int16);
+                       UInt16Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.UInt16);
+                       Int32Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Int32);
+                       UInt32Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.UInt32);
+                       Int64Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Int64);
+                       UInt64Type = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.UInt64);
+                       SingleType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Single);
+                       DoubleType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.Double);
 
-                       mono_defaults.Offset = info.MonoDefaultsInt16Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition short_type = 
corlib.ModuleDefinition.Types ["System.Int16"];
-                       MonoClassInfo short_info = language.CreateClassInfo 
(corlib, short_type, memory, klass);
-                       Int16Type = new MonoFundamentalType (corlib, 
short_type, short_info, "short", FundamentalKind.Int16, 2);
-                       language.AddCoreType (short_type, Int16Type, 
Int16Type.ClassType, klass);
+                       IntType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.IntPtr);
+                       UIntType = MonoFundamentalType.Create (
+                               corlib, memory, mono_defaults, 
FundamentalKind.UIntPtr);
 
-                       mono_defaults.Offset = info.MonoDefaultsUInt16Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition ushort_type = 
corlib.ModuleDefinition.Types ["System.UInt16"];
-                       MonoClassInfo ushort_info = language.CreateClassInfo 
(corlib, ushort_type, memory, klass);
-                       UInt16Type = new MonoFundamentalType (corlib, 
ushort_type, ushort_info, "ushort", FundamentalKind.UInt16, 2);
-                       language.AddCoreType (ushort_type, UInt16Type, 
UInt16Type.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsInt32Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition int_type = 
corlib.ModuleDefinition.Types ["System.Int32"];
-                       MonoClassInfo int_info = language.CreateClassInfo 
(corlib, int_type, memory, klass);
-                       Int32Type = new MonoFundamentalType (corlib, int_type, 
int_info, "int", FundamentalKind.Int32, 4);
-                       language.AddCoreType (int_type, Int32Type, 
Int32Type.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsUInt32Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition uint_type = 
corlib.ModuleDefinition.Types ["System.UInt32"];
-                       MonoClassInfo uint_info = language.CreateClassInfo 
(corlib, uint_type, memory, klass);
-                       UInt32Type = new MonoFundamentalType (corlib, 
uint_type, uint_info, "uint", FundamentalKind.UInt32, 4);
-                       language.AddCoreType (uint_type, UInt32Type, 
UInt32Type.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsIntOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition intptr_type = 
corlib.ModuleDefinition.Types ["System.IntPtr"];
-                       MonoClassInfo intptr_info = language.CreateClassInfo 
(corlib, intptr_type, memory, klass);
-                       IntType = new MonoFundamentalType (corlib, intptr_type, 
intptr_info, "System.IntPtr", FundamentalKind.IntPtr, 4);
-                       language.AddCoreType (intptr_type, IntType, 
IntType.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsUIntOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition uintptr_type = 
corlib.ModuleDefinition.Types ["System.UIntPtr"];
-                       MonoClassInfo uintptr_info = language.CreateClassInfo 
(corlib, uintptr_type, memory, klass);
-                       UIntType = new MonoFundamentalType (corlib, 
uintptr_type, uintptr_info, "System.UIntPtr", FundamentalKind.Object, 4);
-                       language.AddCoreType (uintptr_type, UIntType, 
UIntType.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsInt64Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition long_type = 
corlib.ModuleDefinition.Types ["System.Int64"];
-                       MonoClassInfo long_info = language.CreateClassInfo 
(corlib, long_type, memory, klass);
-                       Int64Type = new MonoFundamentalType (corlib, long_type, 
long_info, "long", FundamentalKind.Int64, 8);
-                       language.AddCoreType (long_type, Int64Type, 
Int64Type.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsUInt64Offset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition ulong_type = 
corlib.ModuleDefinition.Types ["System.UInt64"];
-                       MonoClassInfo ulong_info = language.CreateClassInfo 
(corlib, ulong_type, memory, klass);
-                       UInt64Type = new MonoFundamentalType (corlib, 
ulong_type, ulong_info, "ulong", FundamentalKind.UInt64, 8);
-                       language.AddCoreType (ulong_type, UInt64Type, 
UInt64Type.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsSingleOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition float_type = 
corlib.ModuleDefinition.Types ["System.Single"];
-                       MonoClassInfo float_info = language.CreateClassInfo 
(corlib, float_type, memory, klass);
-                       SingleType = new MonoFundamentalType (corlib, 
float_type, float_info, "float", FundamentalKind.Single, 4);
-                       language.AddCoreType (float_type, SingleType, 
SingleType.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsDoubleOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition double_type = 
corlib.ModuleDefinition.Types ["System.Double"];
-                       MonoClassInfo double_info = language.CreateClassInfo 
(corlib, double_type, memory, klass);
-                       DoubleType = new MonoFundamentalType (corlib, 
double_type, double_info, "double", FundamentalKind.Double, 8);
-                       language.AddCoreType (double_type, DoubleType, 
DoubleType.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsCharOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition char_type = 
corlib.ModuleDefinition.Types ["System.Char"];
-                       MonoClassInfo char_info = language.CreateClassInfo 
(corlib, char_type, memory, klass);
-                       CharType = new MonoFundamentalType (corlib, char_type, 
char_info, "char", FundamentalKind.Char, 2);
-                       language.AddCoreType (char_type, CharType, 
CharType.ClassType, klass);
-
-                       mono_defaults.Offset = info.MonoDefaultsStringOffset;
-                       klass = mono_defaults.ReadAddress ();
-                       Cecil.TypeDefinition string_type = 
corlib.ModuleDefinition.Types ["System.String"];
-                       MonoClassInfo string_info = language.CreateClassInfo 
(corlib, string_type, memory, klass);
-                       StringType = new MonoStringType (corlib, string_type, 
string_info, object_size, object_size + 4);
-                       language.AddCoreType (string_type, StringType, 
StringType.ClassType, klass);
-
                        mono_defaults.Offset = info.MonoDefaultsArrayOffset;
                        klass = mono_defaults.ReadAddress ();
                        Cecil.TypeDefinition array_type = 
corlib.ModuleDefinition.Types ["System.Array"];

Modified: trunk/debugger/languages/mono/MonoStringType.cs
===================================================================
--- trunk/debugger/languages/mono/MonoStringType.cs     2007-09-27 04:06:26 UTC 
(rev 86458)
+++ trunk/debugger/languages/mono/MonoStringType.cs     2007-09-27 06:21:04 UTC 
(rev 86459)
@@ -1,4 +1,5 @@
 using System;
+using Mono.Debugger.Backends;
 using Cecil = Mono.Cecil;
 
 namespace Mono.Debugger.Languages.Mono
@@ -10,14 +11,30 @@
                public readonly int ObjectSize;
                protected readonly TargetAddress CreateString;
 
-               public MonoStringType (MonoSymbolFile file, 
Cecil.TypeDefinition typedef,
-                                      MonoClassInfo class_info, int 
object_size, int size)
-                       : base (file, typedef, class_info, "string", 
FundamentalKind.String, size)
+               private MonoStringType (MonoSymbolFile file, 
Cecil.TypeDefinition typedef,
+                                       int object_size, int size)
+                       : base (file, typedef, "string", 
FundamentalKind.String, size)
                {
                        this.ObjectSize = object_size;
                        this.CreateString = 
file.MonoLanguage.MonoDebuggerInfo.CreateString;
                }
 
+               public static MonoStringType Create (MonoSymbolFile corlib, 
TargetMemoryAccess memory,
+                                                    TargetReader mono_defaults)
+               {
+                       int object_size = 2 * 
memory.TargetInfo.TargetAddressSize;
+
+                       MonoStringType type = new MonoStringType (
+                               corlib, corlib.ModuleDefinition.Types 
["System.String"],
+                               object_size, object_size + 4);
+
+                       TargetAddress klass = mono_defaults.PeekAddress (
+                               
corlib.MonoLanguage.MonoMetadataInfo.MonoDefaultsStringOffset);
+                       type.create_type (memory, klass);
+
+                       return type;
+               }
+
                public static int MaximumStringLength {
                        get {
                                return max_string_length;

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to