D/xomb-bare-bones
1
0
Fork 0
mirror of https://github.com/xomboverlord/xomb-bare-bones.git synced 2026-04-21 19:29:04 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Version 1.0.0 of the XOmB Bare Bones distribution! With Bare Bones, all you get is booting up, printing some stuff out, and then looping into infinity (and beyond). Have fun!

Browse Source
This commit is contained in:
The XOmB Overlord
2009-02-21 22:23:22 -05:00
parent 1aa91d5e2b
commit 6d924a9fd7
62 changed files with 7169 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
kernel/runtime/std/c/stdarg.d Normal file
View File

@@ -0,0 +1,34 @@
/*
* Placed in public domain.
* Written by Hauke Duden and Walter Bright
*/
/* This is for use with variable argument lists with extern(D) linkage. */
module std.c.stdarg;
private import gcc.builtins;
alias __builtin_va_list va_list;
alias __builtin_va_end va_end;
alias __builtin_va_copy va_copy;
// The va_start and va_arg template functions are magically
// handled by the compiler.
template va_start(T)
{
void va_start(out va_list ap, inout T parmn)
{
}
}
template va_arg(T)
{
T va_arg(ref va_list _argptr)
{
return T.init;
}
}

264
kernel/runtime/std/intrinsic.d Normal file
View File

@@ -0,0 +1,264 @@
// written by Walter Bright
// www.digitalmars.com
// Placed into the public domain
/* NOTE: This file has been patched from the original DMD distribution to
work with the GDC compiler.
Modified by David Friedman, May 2006
*/
/** These functions are built-in intrinsics to the compiler.
*
Intrinsic functions are functions built in to the compiler,
usually to take advantage of specific CPU features that
are inefficient to handle via external functions.
The compiler's optimizer and code generator are fully
integrated in with intrinsic functions, bringing to bear
their full power on them.
This can result in some surprising speedups.
* Macros:
* WIKI=Phobos/StdIntrinsic
*/
module std.intrinsic;
/**
* Scans the bits in v starting with bit 0, looking
* for the first set bit.
* Returns:
* The bit number of the first bit set.
* The return value is undefined if v is zero.
*/
version (GNU)
int bsf(uint v)
{
uint m = 1;
uint i;
for (i = 0; i < 32; i++,m<<=1) {
if (v&m)
return i;
}
return i; // supposed to be undefined
}
else
int bsf(uint v);
/**
* Scans the bits in v from the most significant bit
* to the least significant bit, looking
* for the first set bit.
* Returns:
* The bit number of the first bit set.
* The return value is undefined if v is zero.
* Example:
* ---
* import std.intrinsic;
*
* int main()
* {
* uint v;
* int x;
*
* v = 0x21;
* x = bsf(v);
* printf("bsf(x%x) = %d\n", v, x);
* x = bsr(v);
* printf("bsr(x%x) = %d\n", v, x);
* return 0;
* }
* ---
* Output:
* bsf(x21) = 0<br>
* bsr(x21) = 5
*/
version (GNU)
int bsr(uint v)
{
uint m = 0x80000000;
uint i;
for (i = 32; i ; i--,m>>>=1) {
if (v&m)
return i-1;
}
return i; // supposed to be undefined
}
else
int bsr(uint v);
/**
* Tests the bit.
*/
version (GNU)
int bt(uint *p, uint bitnum)
{
return (p[bitnum / (uint.sizeof*8)] & (1<<(bitnum & ((uint.sizeof*8)-1)))) ? -1 : 0 ;
}
else
int bt(uint *p, uint bitnum);
/**
* Tests and complements the bit.
*/
version (GNU)
int btc(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q ^= mask;
return result ? -1 : 0;
}
else
int btc(uint *p, uint bitnum);
/**
* Tests and resets (sets to 0) the bit.
*/
version (GNU)
int btr(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q &= ~mask;
return result ? -1 : 0;
}
else
int btr(uint *p, uint bitnum);
/**
* Tests and sets the bit.
* Params:
* p = a non-NULL pointer to an array of uints.
* index = a bit number, starting with bit 0 of p[0],
* and progressing. It addresses bits like the expression:
---
p[index / (uint.sizeof*8)] & (1 << (index & ((uint.sizeof*8) - 1)))
---
* Returns:
* A non-zero value if the bit was set, and a zero
* if it was clear.
*
* Example:
* ---
import std.intrinsic;
int main()
{
uint array[2];
array[0] = 2;
array[1] = 0x100;
printf("btc(array, 35) = %d\n", <b>btc</b>(array, 35));
printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
printf("btc(array, 35) = %d\n", <b>btc</b>(array, 35));
printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
printf("bts(array, 35) = %d\n", <b>bts</b>(array, 35));
printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
printf("btr(array, 35) = %d\n", <b>btr</b>(array, 35));
printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
printf("bt(array, 1) = %d\n", <b>bt</b>(array, 1));
printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
return 0;
}
* ---
* Output:
<pre>
btc(array, 35) = 0
array = [0]:x2, [1]:x108
btc(array, 35) = -1
array = [0]:x2, [1]:x100
bts(array, 35) = 0
array = [0]:x2, [1]:x108
btr(array, 35) = -1
array = [0]:x2, [1]:x100
bt(array, 1) = -1
array = [0]:x2, [1]:x100
</pre>
*/
version (GNU)
int bts(uint *p, uint bitnum)
{
uint * q = p + (bitnum / (uint.sizeof*8));
uint mask = 1 << (bitnum & ((uint.sizeof*8) - 1));
int result = *q & mask;
*q |= mask;
return result ? -1 : 0;
}
else
int bts(uint *p, uint bitnum);
/**
* Swaps bytes in a 4 byte uint end-to-end, i.e. byte 0 becomes
byte 3, byte 1 becomes byte 2, byte 2 becomes byte 1, byte 3
becomes byte 0.
*/
version (GNU)
uint bswap(uint v)
{
return ((v&0xFF)<<24)|((v&0xFF00)<<8)|((v&0xFF0000)>>>8)|((v&0xFF000000)>>>24);
}
else
uint bswap(uint v);
/**
* Reads I/O port at port_address.
*/
version (GNU)
ubyte inp(uint p) { return 0; }
else
ubyte inp(uint port_address);
/**
* ditto
*/
version (GNU)
ushort inpw(uint p) { return 0; }
else
ushort inpw(uint port_address);
/**
* ditto
*/
version (GNU)
uint inpl(uint p) { return 0; }
else
uint inpl(uint port_address);
/**
* Writes and returns value to I/O port at port_address.
*/
version (GNU)
ubyte outp(uint p, ubyte v) { return v; }
else
ubyte outp(uint port_address, ubyte value);
/**
* ditto
*/
version (GNU)
ushort outpw(uint p, ushort v) { return v; }
else
ushort outpw(uint port_address, ushort value);
/**
* ditto
*/
version (GNU)
uint outpl(uint p, uint v) { return v; }
else
uint outpl(uint port_address, uint value);

43
kernel/runtime/std/stdarg.d Normal file
View File

@@ -0,0 +1,43 @@
/*
* Placed in public domain.
* Written by Hauke Duden and Walter Bright
*/
/* This is for use with variable argument lists with extern(D) linkage. */
/* NOTE: This file has been patched from the original DMD distribution to
work with the GDC compiler.
Modified by David Friedman, September 2004
*/
module std.stdarg;
version (GNU) {
// va_list might be a pointer, but assuming so is not portable.
private import gcc.builtins;
alias __builtin_va_list va_list;
// va_arg is handled magically by the compiler
} else {
alias void* va_list;
}
template va_arg(T)
{
T va_arg(inout va_list _argptr)
{
/*
T arg = *cast(T*)_argptr;
_argptr = _argptr + ((T.sizeof + int.sizeof - 1) & ~(int.sizeof - 1));
return arg;
*/
T t; return t;
}
}
private import std.c.stdarg;
/* The existence of std.stdarg.va_copy isn't standard. Prevent
conflicts by using '__'. */
alias std.c.stdarg.va_copy __va_copy;

96
kernel/runtime/std/typeinfo/ti_AC.d Normal file
View File

@@ -0,0 +1,96 @@
module std.typeinfo.ti_AC;
// Object[]
class TypeInfo_AC : TypeInfo
{
hash_t getHash(void *p)
{ Object[] s = *cast(Object[]*)p;
hash_t hash = 0;
foreach (Object o; s)
{
if (o)
hash += o.toHash();
}
return hash;
}
int equals(void *p1, void *p2)
{
Object[] s1 = *cast(Object[]*)p1;
Object[] s2 = *cast(Object[]*)p2;
if (s1.length == s2.length)
{
for (size_t u = 0; u < s1.length; u++)
{ Object o1 = s1[u];
Object o2 = s2[u];
// Do not pass null's to Object.opEquals()
if (o1 is o2 ||
(!(o1 is null) && !(o2 is null) && o1.opEquals(o2)))
continue;
return 0;
}
return 1;
}
return 0;
}
int compare(void *p1, void *p2)
{
Object[] s1 = *cast(Object[]*)p1;
Object[] s2 = *cast(Object[]*)p2;
ptrdiff_t c;
c = cast(ptrdiff_t)s1.length - cast(ptrdiff_t)s2.length;
if (c == 0)
{
for (size_t u = 0; u < s1.length; u++)
{ Object o1 = s1[u];
Object o2 = s2[u];
if (o1 is o2)
continue;
// Regard null references as always being "less than"
if (o1)
{
if (!o2)
{ c = 1;
break;
}
c = o1.opCmp(o2);
if (c)
break;
}
else
{ c = -1;
break;
}
}
}
if (c < 0)
c = -1;
else if (c > 0)
c = 1;
return c;
}
size_t tsize()
{
return (Object[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(Object);
}
}

107
kernel/runtime/std/typeinfo/ti_Acdouble.d Normal file
View File

@@ -0,0 +1,107 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Acdouble;
private import std.typeinfo.ti_cdouble;
// cdouble[]
class TypeInfo_Ar : TypeInfo
{
char[] toString() { return "cdouble[]"; }
hash_t getHash(void *p)
{ cdouble[] s = *cast(cdouble[]*)p;
size_t len = s.length;
cdouble *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(uint *)str)[2];
hash += (cast(uint *)str)[3];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
cdouble[] s1 = *cast(cdouble[]*)p1;
cdouble[] s2 = *cast(cdouble[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_r._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
cdouble[] s1 = *cast(cdouble[]*)p1;
cdouble[] s2 = *cast(cdouble[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_r._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (cdouble[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(cdouble);
}
}

105
kernel/runtime/std/typeinfo/ti_Acfloat.d Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Acfloat;
private import std.typeinfo.ti_cfloat;
// cfloat[]
class TypeInfo_Aq : TypeInfo
{
char[] toString() { return "cfloat[]"; }
hash_t getHash(void *p)
{ cfloat[] s = *cast(cfloat[]*)p;
size_t len = s.length;
cfloat *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
cfloat[] s1 = *cast(cfloat[]*)p1;
cfloat[] s2 = *cast(cfloat[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_q._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
cfloat[] s1 = *cast(cfloat[]*)p1;
cfloat[] s2 = *cast(cfloat[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_q._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (cfloat[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(cfloat);
}
}

108
kernel/runtime/std/typeinfo/ti_Acreal.d Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Acreal;
private import std.typeinfo.ti_creal;
// creal[]
class TypeInfo_Ac : TypeInfo
{
char[] toString() { return "creal[]"; }
hash_t getHash(void *p)
{ creal[] s = *cast(creal[]*)p;
size_t len = s.length;
creal *str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(uint *)str)[2];
hash += (cast(uint *)str)[3];
hash += (cast(uint *)str)[4];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
creal[] s1 = *cast(creal[]*)p1;
creal[] s2 = *cast(creal[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_c._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
creal[] s1 = *cast(creal[]*)p1;
creal[] s2 = *cast(creal[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_c._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (creal[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(creal);
}
}

116
kernel/runtime/std/typeinfo/ti_Adouble.d Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Adouble;
private import std.typeinfo.ti_double;
// double[]
class TypeInfo_Ad : TypeInfo
{
char[] toString() { return "double[]"; }
hash_t getHash(void *p)
{ double[] s = *cast(double[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
double[] s1 = *cast(double[]*)p1;
double[] s2 = *cast(double[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_d._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
double[] s1 = *cast(double[]*)p1;
double[] s2 = *cast(double[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_d._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (double[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(double);
}
}
// idouble[]
class TypeInfo_Ap : TypeInfo_Ad
{
char[] toString() { return "idouble[]"; }
TypeInfo next()
{
return typeid(idouble);
}
}

115
kernel/runtime/std/typeinfo/ti_Afloat.d Normal file
View File

@@ -0,0 +1,115 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Afloat;
private import std.typeinfo.ti_float;
// float[]
class TypeInfo_Af : TypeInfo
{
char[] toString() { return "float[]"; }
hash_t getHash(void *p)
{ float[] s = *cast(float[]*)p;
size_t 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)
{
float[] s1 = *cast(float[]*)p1;
float[] s2 = *cast(float[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_f._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
float[] s1 = *cast(float[]*)p1;
float[] s2 = *cast(float[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_f._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (float[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(float);
}
}
// ifloat[]
class TypeInfo_Ao : TypeInfo_Af
{
char[] toString() { return "ifloat[]"; }
TypeInfo next()
{
return typeid(ifloat);
}
}

204
kernel/runtime/std/typeinfo/ti_Ag.d Normal file
View File

@@ -0,0 +1,204 @@
module std.typeinfo.ti_Ag;
import kernel.runtime.util;
// 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)
{
ubyte[] s1 = *cast(ubyte[]*)p1;
ubyte[] s2 = *cast(ubyte[]*)p2;
return s1.length == s2.length &&
memcmp(s1.ptr, s2.ptr, 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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
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)
{
ubyte[] s1 = *cast(ubyte[]*)p1;
ubyte[] s2 = *cast(ubyte[]*)p2;
return memcmp(s1.ptr, s2.ptr, s1.length);
}
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);
}
}

119
kernel/runtime/std/typeinfo/ti_Aint.d Normal file
View File

@@ -0,0 +1,119 @@
module std.typeinfo.ti_Aint;
import kernel.runtime.util;
// 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(ubyte*)s1.ptr, cast(ubyte*)s2.ptr, 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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(uint);
}
}
// dchar[]
class TypeInfo_Aw : TypeInfo_Ak
{
char[] toString() { return "dchar[]"; }
TypeInfo next()
{
return typeid(dchar);
}
}

111
kernel/runtime/std/typeinfo/ti_Along.d Normal file
View File

@@ -0,0 +1,111 @@
module std.typeinfo.ti_Along;
import kernel.runtime.util;
// 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(ubyte*)s1.ptr, cast(ubyte*)s2.ptr, 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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(ulong);
}
}

117
kernel/runtime/std/typeinfo/ti_Areal.d Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_Areal;
private import std.typeinfo.ti_real;
// real[]
class TypeInfo_Ae : TypeInfo
{
char[] toString() { return "real[]"; }
hash_t getHash(void *p)
{ real[] s = *cast(real[]*)p;
size_t len = s.length;
auto str = s.ptr;
hash_t hash = 0;
while (len)
{
hash *= 9;
hash += (cast(uint *)str)[0];
hash += (cast(uint *)str)[1];
hash += (cast(ushort *)str)[4];
str++;
len--;
}
return hash;
}
int equals(void *p1, void *p2)
{
real[] s1 = *cast(real[]*)p1;
real[] s2 = *cast(real[]*)p2;
size_t len = s1.length;
if (len != s2.length)
return 0;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_e._equals(s1[u], s2[u]);
if (c == 0)
return 0;
}
return 1;
}
int compare(void *p1, void *p2)
{
real[] s1 = *cast(real[]*)p1;
real[] s2 = *cast(real[]*)p2;
size_t len = s1.length;
if (s2.length < len)
len = s2.length;
for (size_t u = 0; u < len; u++)
{
int c = TypeInfo_e._compare(s1[u], s2[u]);
if (c)
return c;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
size_t tsize()
{
return (real[]).sizeof;
}
uint flags()
{
return 1;
}
TypeInfo next()
{
return typeid(real);
}
}
// ireal[]
class TypeInfo_Aj : TypeInfo_Ae
{
char[] toString() { return "ireal[]"; }
TypeInfo next()
{
return typeid(ireal);
}
}

134
kernel/runtime/std/typeinfo/ti_Ashort.d Normal file
View File

@@ -0,0 +1,134 @@
module std.typeinfo.ti_Ashort;
import kernel.runtime.util;
// 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(ubyte*)s1.ptr, cast(ubyte*)s2.ptr, 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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
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;
}
if (s1.length < s2.length)
return -1;
else if (s1.length > s2.length)
return 1;
return 0;
}
TypeInfo next()
{
return typeid(ushort);
}
}
// wchar[]
class TypeInfo_Au : TypeInfo_At
{
char[] toString() { return "wchar[]"; }
TypeInfo next()
{
return typeid(wchar);
}
}

76
kernel/runtime/std/typeinfo/ti_C.d Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright (C) 2004-2005 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
module std.typeinfo.ti_C;
// Object
class TypeInfo_C : TypeInfo
{
hash_t getHash(void *p)
{
Object o = *cast(Object*)p;
assert(o);
return o.toHash();
}
int equals(void *p1, void *p2)
{
Object o1 = *cast(Object*)p1;
Object o2 = *cast(Object*)p2;
return o1 == o2;
}
int compare(void *p1, void *p2)
{
Object o1 = *cast(Object*)p1;
Object o2 = *cast(Object*)p2;
int c = 0;
// Regard null references as always being "less than"
if (!(o1 is o2))
{
if (o1)
{ if (!o2)
c = 1;
else
c = o1.opCmp(o2);
}
else
c = -1;
}
return c;
}
size_t tsize()
{
return Object.sizeof;
}
uint flags()
{
return 1;
}
}

39
kernel/runtime/std/typeinfo/ti_byte.d Normal file
View File

@@ -0,0 +1,39 @@
// byte
module std.typeinfo.ti_byte;
class TypeInfo_g : TypeInfo
{
char[] toString() { return "byte"; }
hash_t getHash(void *p)
{
return *cast(byte *)p;
}
int equals(void *p1, void *p2)
{
return *cast(byte *)p1 == *cast(byte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(byte *)p1 - *cast(byte *)p2;
}
size_t tsize()
{
return byte.sizeof;
}
void swap(void *p1, void *p2)
{
byte t;
t = *cast(byte *)p1;
*cast(byte *)p1 = *cast(byte *)p2;
*cast(byte *)p2 = t;
}
}

67
kernel/runtime/std/typeinfo/ti_cdouble.d Normal file
View File

@@ -0,0 +1,67 @@
// cdouble
module std.typeinfo.ti_cdouble;
class TypeInfo_r : TypeInfo
{
char[] toString() { return "cdouble"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] +
(cast(uint *)p)[2] + (cast(uint *)p)[3];
}
static int _equals(cdouble f1, cdouble f2)
{
return f1 == f2;
}
static int _compare(cdouble f1, cdouble f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(cdouble *)p1, *cast(cdouble *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(cdouble *)p1, *cast(cdouble *)p2);
}
size_t tsize()
{
return cdouble.sizeof;
}
void swap(void *p1, void *p2)
{
cdouble t;
t = *cast(cdouble *)p1;
*cast(cdouble *)p1 = *cast(cdouble *)p2;
*cast(cdouble *)p2 = t;
}
void[] init()
{ static cdouble r;
return (cast(cdouble *)&r)[0 .. 1];
}
}

66
kernel/runtime/std/typeinfo/ti_cfloat.d Normal file
View File

@@ -0,0 +1,66 @@
// cfloat
module std.typeinfo.ti_cfloat;
class TypeInfo_q : TypeInfo
{
char[] toString() { return "cfloat"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1];
}
static int _equals(cfloat f1, cfloat f2)
{
return f1 == f2;
}
static int _compare(cfloat f1, cfloat f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(cfloat *)p1, *cast(cfloat *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(cfloat *)p1, *cast(cfloat *)p2);
}
size_t tsize()
{
return cfloat.sizeof;
}
void swap(void *p1, void *p2)
{
cfloat t;
t = *cast(cfloat *)p1;
*cast(cfloat *)p1 = *cast(cfloat *)p2;
*cast(cfloat *)p2 = t;
}
void[] init()
{ static cfloat r;
return (cast(cfloat *)&r)[0 .. 1];
}
}

43
kernel/runtime/std/typeinfo/ti_char.d Normal file
View File

@@ -0,0 +1,43 @@
module std.typeinfo.ti_char;
class TypeInfo_a : TypeInfo
{
char[] toString() { return "char"; }
hash_t getHash(void *p)
{
return *cast(char *)p;
}
int equals(void *p1, void *p2)
{
return *cast(char *)p1 == *cast(char *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(char *)p1 - *cast(char *)p2;
}
size_t tsize()
{
return char.sizeof;
}
void swap(void *p1, void *p2)
{
char t;
t = *cast(char *)p1;
*cast(char *)p1 = *cast(char *)p2;
*cast(char *)p2 = t;
}
void[] init()
{ static char c;
return (cast(char *)&c)[0 .. 1];
}
}

68
kernel/runtime/std/typeinfo/ti_creal.d Normal file
View File

@@ -0,0 +1,68 @@
// creal
module std.typeinfo.ti_creal;
class TypeInfo_c : TypeInfo
{
char[] toString() { return "creal"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] +
(cast(uint *)p)[2] + (cast(uint *)p)[3] +
(cast(uint *)p)[4];
}
static int _equals(creal f1, creal f2)
{
return f1 == f2;
}
static int _compare(creal f1, creal f2)
{ int result;
if (f1.re < f2.re)
result = -1;
else if (f1.re > f2.re)
result = 1;
else if (f1.im < f2.im)
result = -1;
else if (f1.im > f2.im)
result = 1;
else
result = 0;
return result;
}
int equals(void *p1, void *p2)
{
return _equals(*cast(creal *)p1, *cast(creal *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(creal *)p1, *cast(creal *)p2);
}
size_t tsize()
{
return creal.sizeof;
}
void swap(void *p1, void *p2)
{
creal t;
t = *cast(creal *)p1;
*cast(creal *)p1 = *cast(creal *)p2;
*cast(creal *)p2 = t;
}
void[] init()
{ static creal r;
return (cast(creal *)&r)[0 .. 1];
}
}

45
kernel/runtime/std/typeinfo/ti_dchar.d Normal file
View File

@@ -0,0 +1,45 @@
// dchar
module std.typeinfo.ti_dchar;
class TypeInfo_w : TypeInfo
{
char[] toString() { return "dchar"; }
hash_t getHash(void *p)
{
return *cast(dchar *)p;
}
int equals(void *p1, void *p2)
{
return *cast(dchar *)p1 == *cast(dchar *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(dchar *)p1 - *cast(dchar *)p2;
}
size_t tsize()
{
return dchar.sizeof;
}
void swap(void *p1, void *p2)
{
dchar t;
t = *cast(dchar *)p1;
*cast(dchar *)p1 = *cast(dchar *)p2;
*cast(dchar *)p2 = t;
}
void[] init()
{ static dchar c;
return (cast(dchar *)&c)[0 .. 1];
}
}

40
kernel/runtime/std/typeinfo/ti_delegate.d Normal file
View File

@@ -0,0 +1,40 @@
// delegate
module std.typeinfo.ti_delegate;
alias void delegate(int) dg;
class TypeInfo_D : TypeInfo
{
hash_t getHash(void *p)
{ long l = *cast(long *)p;
return cast(uint)(l + (l >> 32));
}
int equals(void *p1, void *p2)
{
return *cast(dg *)p1 == *cast(dg *)p2;
}
size_t tsize()
{
return dg.sizeof;
}
void swap(void *p1, void *p2)
{
dg t;
t = *cast(dg *)p1;
*cast(dg *)p1 = *cast(dg *)p2;
*cast(dg *)p2 = t;
}
uint flags()
{
return 1;
}
}

68
kernel/runtime/std/typeinfo/ti_double.d Normal file
View File

@@ -0,0 +1,68 @@
// double
module std.typeinfo.ti_double;
import kernel.runtime.util;
//private import std.math;
class TypeInfo_d : TypeInfo
{
char[] toString() { return "double"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1];
}
static int _equals(double f1, double f2)
{
return f1 == f2 ||
(isnan(f1) && isnan(f2));
}
static int _compare(double d1, double d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (isnan(d1))
{ if (isnan(d2))
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(double *)p1, *cast(double *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(double *)p1, *cast(double *)p2);
}
size_t tsize()
{
return double.sizeof;
}
void swap(void *p1, void *p2)
{
double t;
t = *cast(double *)p1;
*cast(double *)p1 = *cast(double *)p2;
*cast(double *)p2 = t;
}
void[] init()
{ static double r;
return (cast(double *)&r)[0 .. 1];
}
}

68
kernel/runtime/std/typeinfo/ti_float.d Normal file
View File

@@ -0,0 +1,68 @@
// float
module std.typeinfo.ti_float;
import kernel.runtime.util;
//private import std.math;
class TypeInfo_f : TypeInfo
{
char[] toString() { return "float"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
static int _equals(float f1, float f2)
{
return f1 == f2 ||
(isnan(f1) && isnan(f2));
}
static int _compare(float d1, float d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (isnan(d1))
{ if (isnan(d2))
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(float *)p1, *cast(float *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(float *)p1, *cast(float *)p2);
}
size_t tsize()
{
return float.sizeof;
}
void swap(void *p1, void *p2)
{
float t;
t = *cast(float *)p1;
*cast(float *)p1 = *cast(float *)p2;
*cast(float *)p2 = t;
}
void[] init()
{ static float r;
return (cast(float *)&r)[0 .. 1];
}
}

12
kernel/runtime/std/typeinfo/ti_idouble.d Normal file
View File

@@ -0,0 +1,12 @@
// idouble
module std.typeinfo.ti_idouble;
private import std.typeinfo.ti_double;
class TypeInfo_p : TypeInfo_d
{
char[] toString() { return "idouble"; }
}

12
kernel/runtime/std/typeinfo/ti_ifloat.d Normal file
View File

@@ -0,0 +1,12 @@
// ifloat
module std.typeinfo.ti_ifloat;
private import std.typeinfo.ti_float;
class TypeInfo_o : TypeInfo_f
{
char[] toString() { return "ifloat"; }
}

43
kernel/runtime/std/typeinfo/ti_int.d Normal file
View File

@@ -0,0 +1,43 @@
// int
module std.typeinfo.ti_int;
class TypeInfo_i : TypeInfo
{
char[] toString() { return "int"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
int equals(void *p1, void *p2)
{
return *cast(uint *)p1 == *cast(uint *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(int*) p1 < *cast(int*) p2)
return -1;
else if (*cast(int*) p1 > *cast(int*) p2)
return 1;
return 0;
}
size_t tsize()
{
return int.sizeof;
}
void swap(void *p1, void *p2)
{
int t;
t = *cast(int *)p1;
*cast(int *)p1 = *cast(int *)p2;
*cast(int *)p2 = t;
}
}

12
kernel/runtime/std/typeinfo/ti_ireal.d Normal file
View File

@@ -0,0 +1,12 @@
// ireal
module std.typeinfo.ti_ireal;
private import std.typeinfo.ti_real;
class TypeInfo_j : TypeInfo_e
{
char[] toString() { return "ireal"; }
}

43
kernel/runtime/std/typeinfo/ti_long.d Normal file
View File

@@ -0,0 +1,43 @@
// long
module std.typeinfo.ti_long;
class TypeInfo_l : TypeInfo
{
char[] toString() { return "long"; }
hash_t getHash(void *p)
{
return *cast(uint *)p + (cast(uint *)p)[1];
}
int equals(void *p1, void *p2)
{
return *cast(long *)p1 == *cast(long *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(long *)p1 < *cast(long *)p2)
return -1;
else if (*cast(long *)p1 > *cast(long *)p2)
return 1;
return 0;
}
size_t tsize()
{
return long.sizeof;
}
void swap(void *p1, void *p2)
{
long t;
t = *cast(long *)p1;
*cast(long *)p1 = *cast(long *)p2;
*cast(long *)p2 = t;
}
}

47
kernel/runtime/std/typeinfo/ti_ptr.d Normal file
View File

@@ -0,0 +1,47 @@
// pointer
module std.typeinfo.ti_ptr;
class TypeInfo_P : TypeInfo
{
hash_t getHash(void *p)
{
return cast(uint)*cast(void* *)p;
}
int equals(void *p1, void *p2)
{
return *cast(void* *)p1 == *cast(void* *)p2;
}
int compare(void *p1, void *p2)
{
auto c = *cast(void* *)p1 - *cast(void* *)p2;
if (c < 0)
return -1;
else if (c > 0)
return 1;
return 0;
}
size_t tsize()
{
return (void*).sizeof;
}
void swap(void *p1, void *p2)
{
void* t;
t = *cast(void* *)p1;
*cast(void* *)p1 = *cast(void* *)p2;
*cast(void* *)p2 = t;
}
uint flags()
{
return 1;
}
}

68
kernel/runtime/std/typeinfo/ti_real.d Normal file
View File

@@ -0,0 +1,68 @@
// real
module std.typeinfo.ti_real;
import kernel.runtime.util;
//private import std.math;
class TypeInfo_e : TypeInfo
{
char[] toString() { return "real"; }
hash_t getHash(void *p)
{
return (cast(uint *)p)[0] + (cast(uint *)p)[1] + (cast(ushort *)p)[4];
}
static int _equals(real f1, real f2)
{
return f1 == f2 ||
(isnan(f1) && isnan(f2));
}
static int _compare(real d1, real d2)
{
if (d1 !<>= d2) // if either are NaN
{
if (isnan(d1))
{ if (isnan(d2))
return 0;
return -1;
}
return 1;
}
return (d1 == d2) ? 0 : ((d1 < d2) ? -1 : 1);
}
int equals(void *p1, void *p2)
{
return _equals(*cast(real *)p1, *cast(real *)p2);
}
int compare(void *p1, void *p2)
{
return _compare(*cast(real *)p1, *cast(real *)p2);
}
size_t tsize()
{
return real.sizeof;
}
void swap(void *p1, void *p2)
{
real t;
t = *cast(real *)p1;
*cast(real *)p1 = *cast(real *)p2;
*cast(real *)p2 = t;
}
void[] init()
{ static real r;
return (cast(real *)&r)[0 .. 1];
}
}

39
kernel/runtime/std/typeinfo/ti_short.d Normal file
View File

@@ -0,0 +1,39 @@
// short
module std.typeinfo.ti_short;
class TypeInfo_s : TypeInfo
{
char[] toString() { return "short"; }
hash_t getHash(void *p)
{
return *cast(short *)p;
}
int equals(void *p1, void *p2)
{
return *cast(short *)p1 == *cast(short *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(short *)p1 - *cast(short *)p2;
}
size_t tsize()
{
return short.sizeof;
}
void swap(void *p1, void *p2)
{
short t;
t = *cast(short *)p1;
*cast(short *)p1 = *cast(short *)p2;
*cast(short *)p2 = t;
}
}

43
kernel/runtime/std/typeinfo/ti_ubyte.d Normal file
View File

@@ -0,0 +1,43 @@
// ubyte
module std.typeinfo.ti_ubyte;
class TypeInfo_h : TypeInfo
{
char[] toString() { return "ubyte"; }
hash_t getHash(void *p)
{
return *cast(ubyte *)p;
}
int equals(void *p1, void *p2)
{
return *cast(ubyte *)p1 == *cast(ubyte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(ubyte *)p1 - *cast(ubyte *)p2;
}
size_t tsize()
{
return ubyte.sizeof;
}
void swap(void *p1, void *p2)
{
ubyte t;
t = *cast(ubyte *)p1;
*cast(ubyte *)p1 = *cast(ubyte *)p2;
*cast(ubyte *)p2 = t;
}
}
class TypeInfo_b : TypeInfo_h
{
char[] toString() { return "bool"; }
}

43
kernel/runtime/std/typeinfo/ti_uint.d Normal file
View File

@@ -0,0 +1,43 @@
// uint
module std.typeinfo.ti_uint;
class TypeInfo_k : TypeInfo
{
char[] toString() { return "uint"; }
hash_t getHash(void *p)
{
return *cast(uint *)p;
}
int equals(void *p1, void *p2)
{
return *cast(uint *)p1 == *cast(uint *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(uint*) p1 < *cast(uint*) p2)
return -1;
else if (*cast(uint*) p1 > *cast(uint*) p2)
return 1;
return 0;
}
size_t tsize()
{
return uint.sizeof;
}
void swap(void *p1, void *p2)
{
int t;
t = *cast(uint *)p1;
*cast(uint *)p1 = *cast(uint *)p2;
*cast(uint *)p2 = t;
}
}

43
kernel/runtime/std/typeinfo/ti_ulong.d Normal file
View File

@@ -0,0 +1,43 @@
// ulong
module std.typeinfo.ti_ulong;
class TypeInfo_m : TypeInfo
{
char[] toString() { return "ulong"; }
hash_t getHash(void *p)
{
return *cast(uint *)p + (cast(uint *)p)[1];
}
int equals(void *p1, void *p2)
{
return *cast(ulong *)p1 == *cast(ulong *)p2;
}
int compare(void *p1, void *p2)
{
if (*cast(ulong *)p1 < *cast(ulong *)p2)
return -1;
else if (*cast(ulong *)p1 > *cast(ulong *)p2)
return 1;
return 0;
}
size_t tsize()
{
return ulong.sizeof;
}
void swap(void *p1, void *p2)
{
ulong t;
t = *cast(ulong *)p1;
*cast(ulong *)p1 = *cast(ulong *)p2;
*cast(ulong *)p2 = t;
}
}

39
kernel/runtime/std/typeinfo/ti_ushort.d Normal file
View File

@@ -0,0 +1,39 @@
// ushort
module std.typeinfo.ti_ushort;
class TypeInfo_t : TypeInfo
{
char[] toString() { return "ushort"; }
hash_t getHash(void *p)
{
return *cast(ushort *)p;
}
int equals(void *p1, void *p2)
{
return *cast(ushort *)p1 == *cast(ushort *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(ushort *)p1 - *cast(ushort *)p2;
}
size_t tsize()
{
return ushort.sizeof;
}
void swap(void *p1, void *p2)
{
ushort t;
t = *cast(ushort *)p1;
*cast(ushort *)p1 = *cast(ushort *)p2;
*cast(ushort *)p2 = t;
}
}

44
kernel/runtime/std/typeinfo/ti_void.d Normal file
View File

@@ -0,0 +1,44 @@
// void
module std.typeinfo.ti_void;
class TypeInfo_v : TypeInfo
{
char[] toString() { return "void"; }
hash_t getHash(void *p)
{
assert(0);
}
int equals(void *p1, void *p2)
{
return *cast(byte *)p1 == *cast(byte *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(byte *)p1 - *cast(byte *)p2;
}
size_t tsize()
{
return void.sizeof;
}
void swap(void *p1, void *p2)
{
byte t;
t = *cast(byte *)p1;
*cast(byte *)p1 = *cast(byte *)p2;
*cast(byte *)p2 = t;
}
uint flags()
{
return 1;
}
}

44
kernel/runtime/std/typeinfo/ti_wchar.d Normal file
View File

@@ -0,0 +1,44 @@
module std.typeinfo.ti_wchar;
class TypeInfo_u : TypeInfo
{
char[] toString() { return "wchar"; }
hash_t getHash(void *p)
{
return *cast(wchar *)p;
}
int equals(void *p1, void *p2)
{
return *cast(wchar *)p1 == *cast(wchar *)p2;
}
int compare(void *p1, void *p2)
{
return *cast(wchar *)p1 - *cast(wchar *)p2;
}
size_t tsize()
{
return wchar.sizeof;
}
void swap(void *p1, void *p2)
{
wchar t;
t = *cast(wchar *)p1;
*cast(wchar *)p1 = *cast(wchar *)p2;
*cast(wchar *)p2 = t;
}
void[] init()
{ static wchar c;
return (cast(wchar *)&c)[0 .. 1];
}
}