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