[svn r63] Forgot lphobos/typeinfo2

lphobos/typeinfo2/ti_Ag.d

@@ -0,0 +1,211 @@
+module typeinfo2.ti_Ag;
+
+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;
+}
+
+extern(C) int memcmp(void*,void*,size_t);
+
+// byte[]
+
+class TypeInfo_Ag : TypeInfo
+{
+    char[] toString() { return "byte[]"; }
+
+    hash_t getHash(void *p)
+    {	byte[] s = *cast(byte[]*)p;
+	size_t len = s.length;
+	byte *str = s.ptr;
+	hash_t hash = 0;
+
+	while (1)
+	{
+	    switch (len)
+	    {
+		case 0:
+		    return hash;
+
+		case 1:
+		    hash *= 9;
+		    hash += *cast(ubyte *)str;
+		    return hash;
+
+		case 2:
+		    hash *= 9;
+		    hash += *cast(ushort *)str;
+		    return hash;
+
+		case 3:
+		    hash *= 9;
+		    hash += (*cast(ushort *)str << 8) +
+			    (cast(ubyte *)str)[2];
+		    return hash;
+
+		default:
+		    hash *= 9;
+		    hash += *cast(uint *)str;
+		    str += 4;
+		    len -= 4;
+		    break;
+	    }
+	}
+
+	return hash;
+    }
+
+    int equals(void *p1, void *p2)
+    {
+	byte[] s1 = *cast(byte[]*)p1;
+	byte[] s2 = *cast(byte[]*)p2;
+
+	return s1.length == s2.length &&
+	       memcmp(cast(byte *)s1, cast(byte *)s2, s1.length) == 0;
+    }
+
+    int compare(void *p1, void *p2)
+    {
+	byte[] s1 = *cast(byte[]*)p1;
+	byte[] s2 = *cast(byte[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    int result = s1[u] - s2[u];
+	    if (result)
+		return result;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    size_t tsize()
+    {
+	return (byte[]).sizeof;
+    }
+
+    uint flags()
+    {
+	return 1;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(byte);
+    }
+}
+
+
+// ubyte[]
+
+class TypeInfo_Ah : TypeInfo_Ag
+{
+    char[] toString() { return "ubyte[]"; }
+
+    int compare(void *p1, void *p2)
+    {
+	char[] s1 = *cast(char[]*)p1;
+	char[] s2 = *cast(char[]*)p2;
+
+	return string_cmp(s1, s2);
+    }
+
+    TypeInfo next()
+    {
+	return typeid(ubyte);
+    }
+}
+
+// void[]
+
+class TypeInfo_Av : TypeInfo_Ah
+{
+    char[] toString() { return "void[]"; }
+
+    TypeInfo next()
+    {
+	return typeid(void);
+    }
+}
+
+// bool[]
+
+class TypeInfo_Ab : TypeInfo_Ah
+{
+    char[] toString() { return "bool[]"; }
+
+    TypeInfo next()
+    {
+	return typeid(bool);
+    }
+}
+
+// char[]
+
+class TypeInfo_Aa : TypeInfo_Ag
+{
+    char[] toString() { return "char[]"; }
+
+    hash_t getHash(void *p)
+    {	char[] s = *cast(char[]*)p;
+	hash_t hash = 0;
+
+version (all)
+{
+	foreach (char c; s)
+	    hash = hash * 11 + c;
+}
+else
+{
+	size_t len = s.length;
+	char *str = s;
+
+	while (1)
+	{
+	    switch (len)
+	    {
+		case 0:
+		    return hash;
+
+		case 1:
+		    hash *= 9;
+		    hash += *cast(ubyte *)str;
+		    return hash;
+
+		case 2:
+		    hash *= 9;
+		    hash += *cast(ushort *)str;
+		    return hash;
+
+		case 3:
+		    hash *= 9;
+		    hash += (*cast(ushort *)str << 8) +
+			    (cast(ubyte *)str)[2];
+		    return hash;
+
+		default:
+		    hash *= 9;
+		    hash += *cast(uint *)str;
+		    str += 4;
+		    len -= 4;
+		    break;
+	    }
+	}
+}
+	return hash;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(char);
+    }
+}
+
+

lphobos/typeinfo2/ti_Aint.d

@@ -0,0 +1,110 @@
+module typeinfo2.ti_Aint;
+
+extern(C) int memcmp(void*,void*,size_t);
+
+// int[]
+
+class TypeInfo_Ai : TypeInfo
+{
+    char[] toString() { return "int[]"; }
+
+    hash_t getHash(void *p)
+    {	int[] s = *cast(int[]*)p;
+	auto len = s.length;
+	auto str = s.ptr;
+	hash_t hash = 0;
+
+	while (len)
+	{
+	    hash *= 9;
+	    hash += *cast(uint *)str;
+	    str++;
+	    len--;
+	}
+
+	return hash;
+    }
+
+    int equals(void *p1, void *p2)
+    {
+	int[] s1 = *cast(int[]*)p1;
+	int[] s2 = *cast(int[]*)p2;
+
+	return s1.length == s2.length &&
+	       memcmp(cast(void *)s1, cast(void *)s2, s1.length * int.sizeof) == 0;
+    }
+
+    int compare(void *p1, void *p2)
+    {
+	int[] s1 = *cast(int[]*)p1;
+	int[] s2 = *cast(int[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    int result = s1[u] - s2[u];
+	    if (result)
+		return result;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    size_t tsize()
+    {
+	return (int[]).sizeof;
+    }
+
+    uint flags()
+    {
+	return 1;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(int);
+    }
+}
+
+// uint[]
+
+class TypeInfo_Ak : TypeInfo_Ai
+{
+    char[] toString() { return "uint[]"; }
+
+    int compare(void *p1, void *p2)
+    {
+	uint[] s1 = *cast(uint[]*)p1;
+	uint[] s2 = *cast(uint[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    int result = s1[u] - s2[u];
+	    if (result)
+		return result;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(uint);
+    }
+}
+
+// dchar[]
+
+class TypeInfo_Aw : TypeInfo_Ak
+{
+    char[] toString() { return "dchar[]"; }
+
+    TypeInfo next()
+    {
+	return typeid(dchar);
+    }
+}
+

lphobos/typeinfo2/ti_Along.d

@@ -0,0 +1,102 @@
+module typeinfo2.ti_Along;
+
+extern(C) int memcmp(void*,void*,size_t);
+
+// long[]
+
+class TypeInfo_Al : TypeInfo
+{
+    char[] toString() { return "long[]"; }
+
+    hash_t getHash(void *p)
+    {	long[] s = *cast(long[]*)p;
+	size_t len = s.length;
+	auto str = s.ptr;
+	hash_t hash = 0;
+
+	while (len)
+	{
+	    hash *= 9;
+	    hash += *cast(uint *)str + *(cast(uint *)str + 1);
+	    str++;
+	    len--;
+	}
+
+	return hash;
+    }
+
+    int equals(void *p1, void *p2)
+    {
+	long[] s1 = *cast(long[]*)p1;
+	long[] s2 = *cast(long[]*)p2;
+
+	return s1.length == s2.length &&
+	       memcmp(cast(void *)s1, cast(void *)s2, s1.length * long.sizeof) == 0;
+    }
+
+    int compare(void *p1, void *p2)
+    {
+	long[] s1 = *cast(long[]*)p1;
+	long[] s2 = *cast(long[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    if (s1[u] < s2[u])
+		return -1;
+	    else if (s1[u] > s2[u])
+		return 1;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    size_t tsize()
+    {
+	return (long[]).sizeof;
+    }
+
+    uint flags()
+    {
+	return 1;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(long);
+    }
+}
+
+
+// ulong[]
+
+class TypeInfo_Am : TypeInfo_Al
+{
+    char[] toString() { return "ulong[]"; }
+
+    int compare(void *p1, void *p2)
+    {
+	ulong[] s1 = *cast(ulong[]*)p1;
+	ulong[] s2 = *cast(ulong[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    if (s1[u] < s2[u])
+		return -1;
+	    else if (s1[u] > s2[u])
+		return 1;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(ulong);
+    }
+}
+
+

lphobos/typeinfo2/ti_Ashort.d

@@ -0,0 +1,125 @@
+module typeinfo2.ti_Ashort;
+
+extern(C) int memcmp(void*,void*,size_t);
+
+// short[]
+
+class TypeInfo_As : TypeInfo
+{
+    char[] toString() { return "short[]"; }
+
+    hash_t getHash(void *p)
+    {	short[] s = *cast(short[]*)p;
+	size_t len = s.length;
+	short *str = s.ptr;
+	hash_t hash = 0;
+
+	while (1)
+	{
+	    switch (len)
+	    {
+		case 0:
+		    return hash;
+
+		case 1:
+		    hash *= 9;
+		    hash += *cast(ushort *)str;
+		    return hash;
+
+		default:
+		    hash *= 9;
+		    hash += *cast(uint *)str;
+		    str += 2;
+		    len -= 2;
+		    break;
+	    }
+	}
+
+	return hash;
+    }
+
+    int equals(void *p1, void *p2)
+    {
+	short[] s1 = *cast(short[]*)p1;
+	short[] s2 = *cast(short[]*)p2;
+
+	return s1.length == s2.length &&
+	       memcmp(cast(void *)s1, cast(void *)s2, s1.length * short.sizeof) == 0;
+    }
+
+    int compare(void *p1, void *p2)
+    {
+	short[] s1 = *cast(short[]*)p1;
+	short[] s2 = *cast(short[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    int result = s1[u] - s2[u];
+	    if (result)
+		return result;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    size_t tsize()
+    {
+	return (short[]).sizeof;
+    }
+
+    uint flags()
+    {
+	return 1;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(short);
+    }
+}
+
+
+// ushort[]
+
+class TypeInfo_At : TypeInfo_As
+{
+    char[] toString() { return "ushort[]"; }
+
+    int compare(void *p1, void *p2)
+    {
+	ushort[] s1 = *cast(ushort[]*)p1;
+	ushort[] s2 = *cast(ushort[]*)p2;
+	size_t len = s1.length;
+
+	if (s2.length < len)
+	    len = s2.length;
+	for (size_t u = 0; u < len; u++)
+	{
+	    int result = s1[u] - s2[u];
+	    if (result)
+		return result;
+	}
+	return cast(int)s1.length - cast(int)s2.length;
+    }
+
+    TypeInfo next()
+    {
+	return typeid(ushort);
+    }
+}
+
+// wchar[]
+
+class TypeInfo_Au : TypeInfo_At
+{
+    char[] toString() { return "wchar[]"; }
+
+    TypeInfo next()
+    {
+	return typeid(wchar);
+    }
+}
+
+