projects/ldc: lphobos/internal/objectimpl.d comparison

comparison lphobos/internal/objectimpl.d @ 52:0c77619e803b trunk

[svn r56] Initial support for TypeInfo. Enums not work. Several other bugfixes.

author	lindquist
date	Tue, 23 Oct 2007 05:55:12 +0200
parents	0b9b286b67b6
children	28e99b04a132

comparison

equal deleted inserted replaced

-:61bc1b4ad3c4
+:0c77619e803b
 module object;
 //import std.outofmemory;
+/**
+* An unsigned integral type large enough to span the memory space. Use for
+* array indices and pointer offsets for maximal portability to
+* architectures that have different memory address ranges. This is
+* analogous to C's size_t.
+*/
+alias typeof(int.sizeof) size_t;
+/**
+* A signed integral type large enough to span the memory space. Use for
+* pointer differences and for size_t differences for maximal portability to
+* architectures that have different memory address ranges. This is
+* analogous to C's ptrdiff_t.
+*/
+alias typeof(cast(void*)0 - cast(void*)0) ptrdiff_t;
+alias size_t hash_t;
 extern (C)
 {   /// C's printf function.
 int printf(char *, ...);
+void trace_term();
 int memcmp(void *, void *, size_t);
 void* memcpy(void *, void *, size_t);
 void* calloc(size_t, size_t);
 void* realloc(void*, size_t);
 }
 /// Standard boolean type.
 alias bool bit;
-version (LLVM64)
+alias char[] string;
-{
+alias wchar[] wstring;
-/**
+alias dchar[] dstring;
-* An unsigned integral type large enough to span the memory space. Use for
-* array indices and pointer offsets for maximal portability to
-* architectures that have different memory address ranges. This is
-* analogous to C's size_t.
-*/
-alias ulong size_t;
-/**
-* A signed integral type large enough to span the memory space. Use for
-* pointer differences and for size_t differences for maximal portability to
-* architectures that have different memory address ranges. This is
-* analogous to C's ptrdiff_t.
-*/
-alias long ptrdiff_t;
-alias ulong hash_t;
-}
-else
-{
-alias uint size_t;
-alias int ptrdiff_t;
-alias uint hash_t;
-}
 /+
 /* *************************
 * Internal struct pointed to by the hidden .monitor member.
 */
 struct Monitor
 {
 void delegate(Object)[] delegates;
 /* More stuff goes here defined by internal/monitor.c */
 }
 +/
 /******************
 * All D class objects inherit from Object.
 */
 * Convert Object to a human readable string.
 */
 char[] toString()
 {
 //return this.classinfo.name;
-return "Object.toString: classinfo not yet implemented";
+return "object.Object (no classinfo yet)";
 }
 /**
 * Compute hash function for Object.
 */
 hash_t toHash()
 {
 // BUG: this prevents a compacting GC from working, needs to be fixed
-return cast(uint)cast(void *)this;
+return cast(hash_t)cast(void *)this;
 }
 /**
 * Compare with another Object obj.
 * Returns:
 int opCmp(Object o)
 {
 // BUG: this prevents a compacting GC from working, needs to be fixed
 //return cast(int)cast(void *)this - cast(int)cast(void *)o;
-assert(0, "need opCmp for class <no classinfo yet>");
 //throw new Error("need opCmp for class " ~ this.classinfo.name);
+throw new Error("need opCmp for class unknown object.Object (no classinfo yet)");
 }
 /**
 * Returns !=0 if this object does have the same contents as obj.
 */
 * This is only for use by library developers, as it will need to be
 * redone if weak pointers are added or a moving gc is developed.
 */
 final void notifyRegister(void delegate(Object) dg)
 {
+/+
 //printf("notifyRegister(dg = %llx, o = %p)\n", dg, this);
-/+synchronized (this)
+synchronized (this)
 {
 Monitor* m = cast(Monitor*)(cast(void**)this)[1];
 foreach (inout x; m.delegates)
 {
 if (!x || x == dg)
 _d_OutOfMemory();
 m.delegates = (cast(void delegate(Object)*)p)[0 .. len];
 m.delegates[startlen .. len] = null;
 }
 m.delegates[startlen] = dg;
-}+/
+}
++/
 }
 /* **
 * Remove delegate dg from the notify list.
 * This is only for use by library developers, as it will need to be
 * redone if weak pointers are added or a moving gc is developed.
 */
 final void notifyUnRegister(void delegate(Object) dg)
 {
-/+synchronized (this)
+/+
+synchronized (this)
 {
 Monitor* m = cast(Monitor*)(cast(void**)this)[1];
 foreach (inout x; m.delegates)
 {
 if (x == dg)
 x = null;
 }
-}+/
+}
++/
 }
 /******
 * Create instance of class specified by classname.
 * The class must either have no constructors or have
 * a default constructor.
 * Returns:
 *  null if failed
 */
-/+static Object factory(char[] classname)
+static Object factory(char[] classname)
 {
+/+
 auto ci = ClassInfo.find(classname);
 if (ci)
 {
 return ci.create();
 }
++/
 return null;
-}+/
+}
 }
 /+
 extern (C) void _d_notify_release(Object o)
 {
 }
 }
 private import std.string;
++/
 /**
 * Array of pairs giving the offset and type information for each
 * member in an aggregate.
 */
 struct OffsetTypeInfo
 {
 size_t offset;  /// Offset of member from start of object
 TypeInfo ti;    /// TypeInfo for this member
+}
+private int string_cmp(char[] s1, char[] s2)
+{
+auto len = s1.length;
+if (s2.length < len)
+len = s2.length;
+int result = memcmp(s1.ptr, s2.ptr, len);
+if (result == 0)
+result = cast(int)(cast(ptrdiff_t)s1.length - cast(ptrdiff_t)s2.length);
+return result;
 }
 /**
 * Runtime type information about a type.
 * Can be retrieved for any type using a
 if (this is o)
 return 0;
 TypeInfo ti = cast(TypeInfo)o;
 if (ti is null)
 return 1;
-return std.string.cmp(this.toString(), ti.toString());
+return string_cmp(this.toString(), ti.toString());
 }
 int opEquals(Object o)
 {
 /* TypeInfo instances are singletons, but duplicates can exist
 uint flags() { return 0; }
 /// Get type information on the contents of the type; null if not available
 OffsetTypeInfo[] offTi() { return null; }
 }
+/+
 class TypeInfo_Typedef : TypeInfo
 {
 char[] toString() { return name; }
 void swap(void *p1, void *p2)
 {
 assert(0);
 }
 }
+class TypeInfo_Const : TypeInfo
+{
+char[] toString() { return "const " ~ base.toString(); }
+int opEquals(Object o) { return base.opEquals(o); }
+hash_t getHash(void *p) { return base.getHash(p); }
+int equals(void *p1, void *p2) { return base.equals(p1, p2); }
+int compare(void *p1, void *p2) { return base.compare(p1, p2); }
+size_t tsize() { return base.tsize(); }
+void swap(void *p1, void *p2) { return base.swap(p1, p2); }
+TypeInfo next() { return base.next(); }
+uint flags() { return base.flags(); }
+void[] init() { return base.init(); }
+TypeInfo base;
+}
+class TypeInfo_Invariant : TypeInfo_Const
+{
+char[] toString() { return "invariant " ~ base.toString(); }
+}
 +/
 /**
 * All recoverable exceptions should be derived from class Exception.
 */
 this(char[] msg)
 {
 this.msg = msg;
 }
-void print()
-{
-auto str = toString();
-printf("%.*s\n", str.length, str.ptr);
-}
 char[] toString() { return msg; }
 }
 /**
 * All irrecoverable exceptions should be derived from class Error.
 this.next = next;
 }
 }
 //extern (C) int nullext = 0;

Mercurial > projects > ldc

comparison lphobos/internal/objectimpl.d @ 52:0c77619e803b trunk