mirror of
https://github.com/xomboverlord/ldc.git
synced 2026-01-11 18:33:14 +01:00
Added druntime (this should be removed once it works).
This commit is contained in:
Robert Clipsham
@@ -21,7 +21,6 @@ syntax: regexp
|
||||
^tests/dstress/
|
||||
^tests/reference/
|
||||
^tango/
|
||||
^druntime/
|
||||
^import/
|
||||
^bin/ldc2?$
|
||||
^bin/ldc2?\.conf$
|
||||
|
||||
262
druntime/import/core/bitmanip.di
Normal file
262
druntime/import/core/bitmanip.di
Normal file
@@ -0,0 +1,262 @@
|
||||
/**
|
||||
* This module contains a collection of bit-level operations.
|
||||
*
|
||||
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
|
||||
* License: BSD Style, see LICENSE
|
||||
* Authors: Walter Bright, Don Clugston, Sean Kelly
|
||||
*/
|
||||
module core.bitmanip;
|
||||
|
||||
|
||||
version( DDoc )
|
||||
{
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
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 bitmanip;
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
int bsr( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Tests the bit.
|
||||
*/
|
||||
int bt( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and complements the bit.
|
||||
*/
|
||||
int btc( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and resets (sets to 0) the bit.
|
||||
*/
|
||||
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 bitmanip;
|
||||
|
||||
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>
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
uint bswap( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Reads I/O port at port_address.
|
||||
*/
|
||||
ubyte inp( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort inpw( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint inpl( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* Writes and returns value to I/O port at port_address.
|
||||
*/
|
||||
ubyte outp( uint port_address, ubyte value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort outpw( uint port_address, ushort value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint outpl( uint port_address, uint value );
|
||||
}
|
||||
else
|
||||
{
|
||||
public import std.intrinsic;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the number of set bits in a 32-bit integer.
|
||||
*/
|
||||
int popcnt( uint x )
|
||||
{
|
||||
// Avoid branches, and the potential for cache misses which
|
||||
// could be incurred with a table lookup.
|
||||
|
||||
// We need to mask alternate bits to prevent the
|
||||
// sum from overflowing.
|
||||
// add neighbouring bits. Each bit is 0 or 1.
|
||||
x = x - ((x>>1) & 0x5555_5555);
|
||||
// now each two bits of x is a number 00,01 or 10.
|
||||
// now add neighbouring pairs
|
||||
x = ((x&0xCCCC_CCCC)>>2) + (x&0x3333_3333);
|
||||
// now each nibble holds 0000-0100. Adding them won't
|
||||
// overflow any more, so we don't need to mask any more
|
||||
|
||||
// Now add the nibbles, then the bytes, then the words
|
||||
// We still need to mask to prevent double-counting.
|
||||
// Note that if we used a rotate instead of a shift, we
|
||||
// wouldn't need the masks, and could just divide the sum
|
||||
// by 8 to account for the double-counting.
|
||||
// On some CPUs, it may be faster to perform a multiply.
|
||||
|
||||
x += (x>>4);
|
||||
x &= 0x0F0F_0F0F;
|
||||
x += (x>>8);
|
||||
x &= 0x00FF_00FF;
|
||||
x += (x>>16);
|
||||
x &= 0xFFFF;
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reverses the order of bits in a 32-bit integer.
|
||||
*/
|
||||
uint bitswap( uint x )
|
||||
{
|
||||
|
||||
version( D_InlineAsm_X86 )
|
||||
{
|
||||
asm
|
||||
{
|
||||
// Author: Tiago Gasiba.
|
||||
mov EDX, EAX;
|
||||
shr EAX, 1;
|
||||
and EDX, 0x5555_5555;
|
||||
and EAX, 0x5555_5555;
|
||||
shl EDX, 1;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 2;
|
||||
and EDX, 0x3333_3333;
|
||||
and EAX, 0x3333_3333;
|
||||
shl EDX, 2;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 4;
|
||||
and EDX, 0x0f0f_0f0f;
|
||||
and EAX, 0x0f0f_0f0f;
|
||||
shl EDX, 4;
|
||||
or EAX, EDX;
|
||||
bswap EAX;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// swap odd and even bits
|
||||
x = ((x >> 1) & 0x5555_5555) | ((x & 0x5555_5555) << 1);
|
||||
// swap consecutive pairs
|
||||
x = ((x >> 2) & 0x3333_3333) | ((x & 0x3333_3333) << 2);
|
||||
// swap nibbles
|
||||
x = ((x >> 4) & 0x0F0F_0F0F) | ((x & 0x0F0F_0F0F) << 4);
|
||||
// swap bytes
|
||||
x = ((x >> 8) & 0x00FF_00FF) | ((x & 0x00FF_00FF) << 8);
|
||||
// swap 2-byte long pairs
|
||||
x = ( x >> 16 ) | ( x << 16);
|
||||
return x;
|
||||
|
||||
}
|
||||
}
|
||||
107
druntime/import/core/stdc/complex.d
Normal file
107
druntime/import/core/stdc/complex.d
Normal file
@@ -0,0 +1,107 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.complex;
|
||||
|
||||
extern (C):
|
||||
|
||||
alias creal complex;
|
||||
alias ireal imaginary;
|
||||
|
||||
cdouble cacos(cdouble z);
|
||||
cfloat cacosf(cfloat z);
|
||||
creal cacosl(creal z);
|
||||
|
||||
cdouble casin(cdouble z);
|
||||
cfloat casinf(cfloat z);
|
||||
creal casinl(creal z);
|
||||
|
||||
cdouble catan(cdouble z);
|
||||
cfloat catanf(cfloat z);
|
||||
creal catanl(creal z);
|
||||
|
||||
cdouble ccos(cdouble z);
|
||||
cfloat ccosf(cfloat z);
|
||||
creal ccosl(creal z);
|
||||
|
||||
cdouble csin(cdouble z);
|
||||
cfloat csinf(cfloat z);
|
||||
creal csinl(creal z);
|
||||
|
||||
cdouble ctan(cdouble z);
|
||||
cfloat ctanf(cfloat z);
|
||||
creal ctanl(creal z);
|
||||
|
||||
cdouble cacosh(cdouble z);
|
||||
cfloat cacoshf(cfloat z);
|
||||
creal cacoshl(creal z);
|
||||
|
||||
cdouble casinh(cdouble z);
|
||||
cfloat casinhf(cfloat z);
|
||||
creal casinhl(creal z);
|
||||
|
||||
cdouble catanh(cdouble z);
|
||||
cfloat catanhf(cfloat z);
|
||||
creal catanhl(creal z);
|
||||
|
||||
cdouble ccosh(cdouble z);
|
||||
cfloat ccoshf(cfloat z);
|
||||
creal ccoshl(creal z);
|
||||
|
||||
cdouble csinh(cdouble z);
|
||||
cfloat csinhf(cfloat z);
|
||||
creal csinhl(creal z);
|
||||
|
||||
cdouble ctanh(cdouble z);
|
||||
cfloat ctanhf(cfloat z);
|
||||
creal ctanhl(creal z);
|
||||
|
||||
cdouble cexp(cdouble z);
|
||||
cfloat cexpf(cfloat z);
|
||||
creal cexpl(creal z);
|
||||
|
||||
cdouble clog(cdouble z);
|
||||
cfloat clogf(cfloat z);
|
||||
creal clogl(creal z);
|
||||
|
||||
double cabs(cdouble z);
|
||||
float cabsf(cfloat z);
|
||||
real cabsl(creal z);
|
||||
|
||||
cdouble cpow(cdouble x, cdouble y);
|
||||
cfloat cpowf(cfloat x, cfloat y);
|
||||
creal cpowl(creal x, creal y);
|
||||
|
||||
cdouble csqrt(cdouble z);
|
||||
cfloat csqrtf(cfloat z);
|
||||
creal csqrtl(creal z);
|
||||
|
||||
double carg(cdouble z);
|
||||
float cargf(cfloat z);
|
||||
real cargl(creal z);
|
||||
|
||||
double cimag(cdouble z);
|
||||
float cimagf(cfloat z);
|
||||
real cimagl(creal z);
|
||||
|
||||
cdouble conj(cdouble z);
|
||||
cfloat conjf(cfloat z);
|
||||
creal conjl(creal z);
|
||||
|
||||
cdouble cproj(cdouble z);
|
||||
cfloat cprojf(cfloat z);
|
||||
creal cprojl(creal z);
|
||||
|
||||
// double creal(cdouble z);
|
||||
float crealf(cfloat z);
|
||||
real creall(creal z);
|
||||
35
druntime/import/core/stdc/config.d
Normal file
35
druntime/import/core/stdc/config.d
Normal file
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
alias int c_long;
|
||||
alias uint c_ulong;
|
||||
}
|
||||
else
|
||||
{
|
||||
static if( (void*).sizeof > int.sizeof )
|
||||
{
|
||||
alias long c_long;
|
||||
alias ulong c_ulong;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias int c_long;
|
||||
alias uint c_ulong;
|
||||
}
|
||||
}
|
||||
31
druntime/import/core/stdc/ctype.d
Normal file
31
druntime/import/core/stdc/ctype.d
Normal file
@@ -0,0 +1,31 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.ctype;
|
||||
|
||||
extern (C):
|
||||
|
||||
int isalnum(int c);
|
||||
int isalpha(int c);
|
||||
int isblank(int c);
|
||||
int iscntrl(int c);
|
||||
int isdigit(int c);
|
||||
int isgraph(int c);
|
||||
int islower(int c);
|
||||
int isprint(int c);
|
||||
int ispunct(int c);
|
||||
int isspace(int c);
|
||||
int isupper(int c);
|
||||
int isxdigit(int c);
|
||||
int tolower(int c);
|
||||
int toupper(int c);
|
||||
377
druntime/import/core/stdc/errno.d
Normal file
377
druntime/import/core/stdc/errno.d
Normal file
@@ -0,0 +1,377 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.errno;
|
||||
|
||||
extern (C) int getErrno(); // for internal use
|
||||
extern (C) int setErrno(int); // for internal use
|
||||
|
||||
alias getErrno errno;
|
||||
alias setErrno errno;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
enum EPERM = 1; // Operation not permitted
|
||||
enum ENOENT = 2; // No such file or directory
|
||||
enum ESRCH = 3; // No such process
|
||||
enum EINTR = 4; // Interrupted system call
|
||||
enum EIO = 5; // I/O error
|
||||
enum ENXIO = 6; // No such device or address
|
||||
enum E2BIG = 7; // Argument list too long
|
||||
enum ENOEXEC = 8; // Exec format error
|
||||
enum EBADF = 9; // Bad file number
|
||||
enum ECHILD = 10; // No child processes
|
||||
enum EAGAIN = 11; // Try again
|
||||
enum ENOMEM = 12; // Out of memory
|
||||
enum EACCES = 13; // Permission denied
|
||||
enum EFAULT = 14; // Bad address
|
||||
enum EBUSY = 16; // Device or resource busy
|
||||
enum EEXIST = 17; // File exists
|
||||
enum EXDEV = 18; // Cross-device link
|
||||
enum ENODEV = 19; // No such device
|
||||
enum ENOTDIR = 20; // Not a directory
|
||||
enum EISDIR = 21; // Is a directory
|
||||
enum EINVAL = 22; // Invalid argument
|
||||
enum ENFILE = 23; // File table overflow
|
||||
enum EMFILE = 24; // Too many open files
|
||||
enum ENOTTY = 25; // Not a typewriter
|
||||
enum EFBIG = 27; // File too large
|
||||
enum ENOSPC = 28; // No space left on device
|
||||
enum ESPIPE = 29; // Illegal seek
|
||||
enum EROFS = 30; // Read-only file system
|
||||
enum EMLINK = 31; // Too many links
|
||||
enum EPIPE = 32; // Broken pipe
|
||||
enum EDOM = 33; // Math argument out of domain of func
|
||||
enum ERANGE = 34; // Math result not representable
|
||||
enum EDEADLK = 36; // Resource deadlock would occur
|
||||
enum ENAMETOOLONG = 38; // File name too long
|
||||
enum ENOLCK = 39; // No record locks available
|
||||
enum ENOSYS = 40; // Function not implemented
|
||||
enum ENOTEMPTY = 41; // Directory not empty
|
||||
enum EILSEQ = 42; // Illegal byte sequence
|
||||
enum EDEADLOCK = EDEADLK;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
enum EPERM = 1; // Operation not permitted
|
||||
enum ENOENT = 2; // No such file or directory
|
||||
enum ESRCH = 3; // No such process
|
||||
enum EINTR = 4; // Interrupted system call
|
||||
enum EIO = 5; // I/O error
|
||||
enum ENXIO = 6; // No such device or address
|
||||
enum E2BIG = 7; // Argument list too long
|
||||
enum ENOEXEC = 8; // Exec format error
|
||||
enum EBADF = 9; // Bad file number
|
||||
enum ECHILD = 10; // No child processes
|
||||
enum EAGAIN = 11; // Try again
|
||||
enum ENOMEM = 12; // Out of memory
|
||||
enum EACCES = 13; // Permission denied
|
||||
enum EFAULT = 14; // Bad address
|
||||
enum ENOTBLK = 15; // Block device required
|
||||
enum EBUSY = 16; // Device or resource busy
|
||||
enum EEXIST = 17; // File exists
|
||||
enum EXDEV = 18; // Cross-device link
|
||||
enum ENODEV = 19; // No such device
|
||||
enum ENOTDIR = 20; // Not a directory
|
||||
enum EISDIR = 21; // Is a directory
|
||||
enum EINVAL = 22; // Invalid argument
|
||||
enum ENFILE = 23; // File table overflow
|
||||
enum EMFILE = 24; // Too many open files
|
||||
enum ENOTTY = 25; // Not a typewriter
|
||||
enum ETXTBSY = 26; // Text file busy
|
||||
enum EFBIG = 27; // File too large
|
||||
enum ENOSPC = 28; // No space left on device
|
||||
enum ESPIPE = 29; // Illegal seek
|
||||
enum EROFS = 30; // Read-only file system
|
||||
enum EMLINK = 31; // Too many links
|
||||
enum EPIPE = 32; // Broken pipe
|
||||
enum EDOM = 33; // Math argument out of domain of func
|
||||
enum ERANGE = 34; // Math result not representable
|
||||
enum EDEADLK = 35; // Resource deadlock would occur
|
||||
enum ENAMETOOLONG = 36; // File name too long
|
||||
enum ENOLCK = 37; // No record locks available
|
||||
enum ENOSYS = 38; // Function not implemented
|
||||
enum ENOTEMPTY = 39; // Directory not empty
|
||||
enum ELOOP = 40; // Too many symbolic links encountered
|
||||
enum EWOULDBLOCK = EAGAIN; // Operation would block
|
||||
enum ENOMSG = 42; // No message of desired type
|
||||
enum EIDRM = 43; // Identifier removed
|
||||
enum ECHRNG = 44; // Channel number out of range
|
||||
enum EL2NSYNC = 45; // Level 2 not synchronized
|
||||
enum EL3HLT = 46; // Level 3 halted
|
||||
enum EL3RST = 47; // Level 3 reset
|
||||
enum ELNRNG = 48; // Link number out of range
|
||||
enum EUNATCH = 49; // Protocol driver not attached
|
||||
enum ENOCSI = 50; // No CSI structure available
|
||||
enum EL2HLT = 51; // Level 2 halted
|
||||
enum EBADE = 52; // Invalid exchange
|
||||
enum EBADR = 53; // Invalid request descriptor
|
||||
enum EXFULL = 54; // Exchange full
|
||||
enum ENOANO = 55; // No anode
|
||||
enum EBADRQC = 56; // Invalid request code
|
||||
enum EBADSLT = 57; // Invalid slot
|
||||
enum EDEADLOCK = EDEADLK;
|
||||
enum EBFONT = 59; // Bad font file format
|
||||
enum ENOSTR = 60; // Device not a stream
|
||||
enum ENODATA = 61; // No data available
|
||||
enum ETIME = 62; // Timer expired
|
||||
enum ENOSR = 63; // Out of streams resources
|
||||
enum ENONET = 64; // Machine is not on the network
|
||||
enum ENOPKG = 65; // Package not installed
|
||||
enum EREMOTE = 66; // Object is remote
|
||||
enum ENOLINK = 67; // Link has been severed
|
||||
enum EADV = 68; // Advertise error
|
||||
enum ESRMNT = 69; // Srmount error
|
||||
enum ECOMM = 70; // Communication error on send
|
||||
enum EPROTO = 71; // Protocol error
|
||||
enum EMULTIHOP = 72; // Multihop attempted
|
||||
enum EDOTDOT = 73; // RFS specific error
|
||||
enum EBADMSG = 74; // Not a data message
|
||||
enum EOVERFLOW = 75; // Value too large for defined data type
|
||||
enum ENOTUNIQ = 76; // Name not unique on network
|
||||
enum EBADFD = 77; // File descriptor in bad state
|
||||
enum EREMCHG = 78; // Remote address changed
|
||||
enum ELIBACC = 79; // Can not access a needed shared library
|
||||
enum ELIBBAD = 80; // Accessing a corrupted shared library
|
||||
enum ELIBSCN = 81; // .lib section in a.out corrupted
|
||||
enum ELIBMAX = 82; // Attempting to link in too many shared libraries
|
||||
enum ELIBEXEC = 83; // Cannot exec a shared library directly
|
||||
enum EILSEQ = 84; // Illegal byte sequence
|
||||
enum ERESTART = 85; // Interrupted system call should be restarted
|
||||
enum ESTRPIPE = 86; // Streams pipe error
|
||||
enum EUSERS = 87; // Too many users
|
||||
enum ENOTSOCK = 88; // Socket operation on non-socket
|
||||
enum EDESTADDRREQ = 89; // Destination address required
|
||||
enum EMSGSIZE = 90; // Message too long
|
||||
enum EPROTOTYPE = 91; // Protocol wrong type for socket
|
||||
enum ENOPROTOOPT = 92; // Protocol not available
|
||||
enum EPROTONOSUPPORT = 93; // Protocol not supported
|
||||
enum ESOCKTNOSUPPORT = 94; // Socket type not supported
|
||||
enum EOPNOTSUPP = 95; // Operation not supported on transport endpoint
|
||||
enum EPFNOSUPPORT = 96; // Protocol family not supported
|
||||
enum EAFNOSUPPORT = 97; // Address family not supported by protocol
|
||||
enum EADDRINUSE = 98; // Address already in use
|
||||
enum EADDRNOTAVAIL = 99; // Cannot assign requested address
|
||||
enum ENETDOWN = 100; // Network is down
|
||||
enum ENETUNREACH = 101; // Network is unreachable
|
||||
enum ENETRESET = 102; // Network dropped connection because of reset
|
||||
enum ECONNABORTED = 103; // Software caused connection abort
|
||||
enum ECONNRESET = 104; // Connection reset by peer
|
||||
enum ENOBUFS = 105; // No buffer space available
|
||||
enum EISCONN = 106; // Transport endpoint is already connected
|
||||
enum ENOTCONN = 107; // Transport endpoint is not connected
|
||||
enum ESHUTDOWN = 108; // Cannot send after transport endpoint shutdown
|
||||
enum ETOOMANYREFS = 109; // Too many references: cannot splice
|
||||
enum ETIMEDOUT = 110; // Connection timed out
|
||||
enum ECONNREFUSED = 111; // Connection refused
|
||||
enum EHOSTDOWN = 112; // Host is down
|
||||
enum EHOSTUNREACH = 113; // No route to host
|
||||
enum EALREADY = 114; // Operation already in progress
|
||||
enum EINPROGRESS = 115; // Operation now in progress
|
||||
enum ESTALE = 116; // Stale NFS file handle
|
||||
enum EUCLEAN = 117; // Structure needs cleaning
|
||||
enum ENOTNAM = 118; // Not a XENIX named type file
|
||||
enum ENAVAIL = 119; // No XENIX semaphores available
|
||||
enum EISNAM = 120; // Is a named type file
|
||||
enum EREMOTEIO = 121; // Remote I/O error
|
||||
enum EDQUOT = 122; // Quota exceeded
|
||||
enum ENOMEDIUM = 123; // No medium found
|
||||
enum EMEDIUMTYPE = 124; // Wrong medium type
|
||||
enum ECANCELED = 125; // Operation Canceled
|
||||
enum ENOKEY = 126; // Required key not available
|
||||
enum EKEYEXPIRED = 127; // Key has expired
|
||||
enum EKEYREVOKED = 128; // Key has been revoked
|
||||
enum EKEYREJECTED = 129; // Key was rejected by service
|
||||
enum EOWNERDEAD = 130; // Owner died
|
||||
enum ENOTRECOVERABLE = 131; // State not recoverable
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum EPERM = 1; // Operation not permitted
|
||||
enum ENOENT = 2; // No such file or directory
|
||||
enum ESRCH = 3; // No such process
|
||||
enum EINTR = 4; // Interrupted system call
|
||||
enum EIO = 5; // Input/output error
|
||||
enum ENXIO = 6; // Device not configured
|
||||
enum E2BIG = 7; // Argument list too long
|
||||
enum ENOEXEC = 8; // Exec format error
|
||||
enum EBADF = 9; // Bad file descriptor
|
||||
enum ECHILD = 10; // No child processes
|
||||
enum EDEADLK = 11; // Resource deadlock avoided
|
||||
enum ENOMEM = 12; // Cannot allocate memory
|
||||
enum EACCES = 13; // Permission denied
|
||||
enum EFAULT = 14; // Bad address
|
||||
enum EBUSY = 16; // Device busy
|
||||
enum EEXIST = 17; // File exists
|
||||
enum EXDEV = 18; // Cross-device link
|
||||
enum ENODEV = 19; // Operation not supported by device
|
||||
enum ENOTDIR = 20; // Not a directory
|
||||
enum EISDIR = 21; // Is a directory
|
||||
enum EINVAL = 22; // Invalid argument
|
||||
enum ENFILE = 23; // Too many open files in system
|
||||
enum EMFILE = 24; // Too many open files
|
||||
enum ENOTTY = 25; // Inappropriate ioctl for device
|
||||
enum ETXTBSY = 26; // Text file busy
|
||||
enum EFBIG = 27; // File too large
|
||||
enum ENOSPC = 28; // No space left on device
|
||||
enum ESPIPE = 29; // Illegal seek
|
||||
enum EROFS = 30; // Read-only file system
|
||||
enum EMLINK = 31; // Too many links
|
||||
enum EPIPE = 32; // Broken pipe
|
||||
enum EDOM = 33; // Numerical argument out of domain
|
||||
enum ERANGE = 34; // Result too large
|
||||
enum EAGAIN = 35; // Resource temporarily unavailable
|
||||
enum EWOULDBLOCK = EAGAIN; // Operation would block
|
||||
enum EINPROGRESS = 36; // Operation now in progress
|
||||
enum EALREADY = 37; // Operation already in progress
|
||||
enum ENOTSOCK = 38; // Socket operation on non-socket
|
||||
enum EDESTADDRREQ = 39; // Destination address required
|
||||
enum EMSGSIZE = 40; // Message too long
|
||||
enum EPROTOTYPE = 41; // Protocol wrong type for socket
|
||||
enum ENOPROTOOPT = 42; // Protocol not available
|
||||
enum EPROTONOSUPPORT = 43; // Protocol not supported
|
||||
enum ENOTSUP = 45; // Operation not supported
|
||||
enum EOPNOTSUPP = ENOTSUP; // Operation not supported on socket
|
||||
enum EAFNOSUPPORT = 47; // Address family not supported by protocol family
|
||||
enum EADDRINUSE = 48; // Address already in use
|
||||
enum EADDRNOTAVAIL = 49; // Can't assign requested address
|
||||
enum ENETDOWN = 50; // Network is down
|
||||
enum ENETUNREACH = 51; // Network is unreachable
|
||||
enum ENETRESET = 52; // Network dropped connection on reset
|
||||
enum ECONNABORTED = 53; // Software caused connection abort
|
||||
enum ECONNRESET = 54; // Connection reset by peer
|
||||
enum ENOBUFS = 55; // No buffer space available
|
||||
enum EISCONN = 56; // Socket is already connected
|
||||
enum ENOTCONN = 57; // Socket is not connected
|
||||
enum ETIMEDOUT = 60; // Operation timed out
|
||||
enum ECONNREFUSED = 61; // Connection refused
|
||||
enum ELOOP = 62; // Too many levels of symbolic links
|
||||
enum ENAMETOOLONG = 63; // File name too long
|
||||
enum EHOSTUNREACH = 65; // No route to host
|
||||
enum ENOTEMPTY = 66; // Directory not empty
|
||||
enum EDQUOT = 69; // Disc quota exceeded
|
||||
enum ESTALE = 70; // Stale NFS file handle
|
||||
enum ENOLCK = 77; // No locks available
|
||||
enum ENOSYS = 78; // Function not implemented
|
||||
enum EOVERFLOW = 84; // Value too large to be stored in data type
|
||||
enum ECANCELED = 89; // Operation canceled
|
||||
enum EIDRM = 90; // Identifier removed
|
||||
enum ENOMSG = 91; // No message of desired type
|
||||
enum EILSEQ = 92; // Illegal byte sequence
|
||||
enum EBADMSG = 94; // Bad message
|
||||
enum EMULTIHOP = 95; // Reserved
|
||||
enum ENODATA = 96; // No message available on STREAM
|
||||
enum ENOLINK = 97; // Reserved
|
||||
enum ENOSR = 98; // No STREAM resources
|
||||
enum ENOSTR = 99; // Not a STREAM
|
||||
enum EPROTO = 100; // Protocol error
|
||||
enum ETIME = 101; // STREAM ioctl timeout
|
||||
enum ELAST = 101; // Must be equal largest errno
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum EPERM = 1; // Operation not permitted
|
||||
enum ENOENT = 2; // No such file or directory
|
||||
enum ESRCH = 3; // No such process
|
||||
enum EINTR = 4; // Interrupted system call
|
||||
enum EIO = 5; // Input/output error
|
||||
enum ENXIO = 6; // Device not configured
|
||||
enum E2BIG = 7; // Argument list too long
|
||||
enum ENOEXEC = 8; // Exec format error
|
||||
enum EBADF = 9; // Bad file descriptor
|
||||
enum ECHILD = 10; // No child processes
|
||||
enum EDEADLK = 11; // Resource deadlock avoided
|
||||
enum ENOMEM = 12; // Cannot allocate memory
|
||||
enum EACCES = 13; // Permission denied
|
||||
enum EFAULT = 14; // Bad address
|
||||
enum ENOTBLK = 15; // Block device required
|
||||
enum EBUSY = 16; // Device busy
|
||||
enum EEXIST = 17; // File exists
|
||||
enum EXDEV = 18; // Cross-device link
|
||||
enum ENODEV = 19; // Operation not supported by device
|
||||
enum ENOTDIR = 20; // Not a directory
|
||||
enum EISDIR = 21; // Is a directory
|
||||
enum EINVAL = 22; // Invalid argument
|
||||
enum ENFILE = 23; // Too many open files in system
|
||||
enum EMFILE = 24; // Too many open files
|
||||
enum ENOTTY = 25; // Inappropriate ioctl for device
|
||||
enum ETXTBSY = 26; // Text file busy
|
||||
enum EFBIG = 27; // File too large
|
||||
enum ENOSPC = 28; // No space left on device
|
||||
enum ESPIPE = 29; // Illegal seek
|
||||
enum EROFS = 30; // Read-only file system
|
||||
enum EMLINK = 31; // Too many links
|
||||
enum EPIPE = 32; // Broken pipe
|
||||
enum EDOM = 33; // Numerical argument out of domain
|
||||
enum ERANGE = 34; // Result too large
|
||||
enum EAGAIN = 35; // Resource temporarily unavailable
|
||||
enum EWOULDBLOCK = EAGAIN; // Operation would block
|
||||
enum EINPROGRESS = 36; // Operation now in progress
|
||||
enum EALREADY = 37; // Operation already in progress
|
||||
enum ENOTSOCK = 38; // Socket operation on non-socket
|
||||
enum EDESTADDRREQ = 39; // Destination address required
|
||||
enum EMSGSIZE = 40; // Message too long
|
||||
enum EPROTOTYPE = 41; // Protocol wrong type for socket
|
||||
enum ENOPROTOOPT = 42; // Protocol not available
|
||||
enum EPROTONOSUPPORT = 43; // Protocol not supported
|
||||
enum ENOTSUP = 45; // Operation not supported
|
||||
enum EOPNOTSUPP = ENOTSUP; // Operation not supported on socket
|
||||
enum EAFNOSUPPORT = 47; // Address family not supported by protocol family
|
||||
enum EADDRINUSE = 48; // Address already in use
|
||||
enum EADDRNOTAVAIL = 49; // Can't assign requested address
|
||||
enum ENETDOWN = 50; // Network is down
|
||||
enum ENETUNREACH = 51; // Network is unreachable
|
||||
enum ENETRESET = 52; // Network dropped connection on reset
|
||||
enum ECONNABORTED = 53; // Software caused connection abort
|
||||
enum ECONNRESET = 54; // Connection reset by peer
|
||||
enum ENOBUFS = 55; // No buffer space available
|
||||
enum EISCONN = 56; // Socket is already connected
|
||||
enum ENOTCONN = 57; // Socket is not connected
|
||||
enum ESHUTDOWN = 58; // Can't send after socket shutdown
|
||||
enum ETOOMANYREFS = 59; // Too many refrences; can't splice
|
||||
enum ETIMEDOUT = 60; // Operation timed out
|
||||
enum ECONNREFUSED = 61; // Connection refused
|
||||
enum ELOOP = 62; // Too many levels of symbolic links
|
||||
enum ENAMETOOLONG = 63; // File name too long
|
||||
enum EHOSTUNREACH = 65; // No route to host
|
||||
enum ENOTEMPTY = 66; // Directory not empty
|
||||
enum EPROCLIM = 67; // Too many processes
|
||||
enum EUSERS = 68; // Too many users
|
||||
enum EDQUOT = 69; // Disc quota exceeded
|
||||
enum ESTALE = 70; // Stale NFS file handle
|
||||
enum EREMOTE = 71; // Too many levels of remote in path
|
||||
enum EBADRPC = 72; // RPC struct is bad
|
||||
enum ERPCMISMATCH = 73; // RPC version wrong
|
||||
enum EPROGUNAVAIL = 74; // RPC prog. not avail
|
||||
enum EPROGMISMATCH = 75; // Program version wrong
|
||||
enum EPROCUNAVAIL = 76; // Bad procedure for program
|
||||
enum ENOLCK = 77; // No locks available
|
||||
enum ENOSYS = 78; // Function not implemented
|
||||
enum EFTYPE = 79; // Inappropriate file type or format
|
||||
enum EAUTH = 80; // Authentication error
|
||||
enum ENEEDAUTH = 81; // Need authenticator
|
||||
enum EIDRM = 82; // Itendifier removed
|
||||
enum ENOMSG = 83; // No message of desired type
|
||||
enum EOVERFLOW = 84; // Value too large to be stored in data type
|
||||
enum ECANCELED = 85; // Operation canceled
|
||||
enum EILSEQ = 86; // Illegal byte sequence
|
||||
enum ENOATTR = 87; // Attribute not found
|
||||
enum EDOOFUS = 88; // Programming error
|
||||
enum EBADMSG = 89; // Bad message
|
||||
enum EMULTIHOP = 90; // Multihop attempted
|
||||
enum ENOLINK = 91; // Link has been severed
|
||||
enum EPROTO = 92; // Protocol error
|
||||
enum ELAST = 92; // Must be equal largest errno
|
||||
}
|
||||
142
druntime/import/core/stdc/fenv.d
Normal file
142
druntime/import/core/stdc/fenv.d
Normal file
@@ -0,0 +1,142 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.fenv;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
struct fenv_t
|
||||
{
|
||||
ushort status;
|
||||
ushort control;
|
||||
ushort round;
|
||||
ushort[2] reserved;
|
||||
}
|
||||
|
||||
alias int fexcept_t;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
struct fenv_t
|
||||
{
|
||||
ushort __control_word;
|
||||
ushort __unused1;
|
||||
ushort __status_word;
|
||||
ushort __unused2;
|
||||
ushort __tags;
|
||||
ushort __unused3;
|
||||
uint __eip;
|
||||
ushort __cs_selector;
|
||||
ushort __opcode;
|
||||
uint __data_offset;
|
||||
ushort __data_selector;
|
||||
ushort __unused5;
|
||||
}
|
||||
|
||||
alias int fexcept_t;
|
||||
}
|
||||
else version ( OSX )
|
||||
{
|
||||
version ( BigEndian )
|
||||
{
|
||||
alias uint fenv_t;
|
||||
alias uint fexcept_t;
|
||||
}
|
||||
version ( LittleEndian )
|
||||
{
|
||||
struct fenv_t
|
||||
{
|
||||
ushort __control;
|
||||
ushort __status;
|
||||
uint __mxcsr;
|
||||
byte[8] __reserved;
|
||||
}
|
||||
|
||||
alias ushort fexcept_t;
|
||||
}
|
||||
}
|
||||
else version ( freebsd )
|
||||
{
|
||||
struct fenv_t
|
||||
{
|
||||
ushort __control;
|
||||
ushort __mxcsr_hi;
|
||||
ushort __status;
|
||||
ushort __mxcsr_lo;
|
||||
uint __tag;
|
||||
byte[16] __other;
|
||||
}
|
||||
|
||||
alias ushort fexcept_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FE_INVALID = 1,
|
||||
FE_DENORMAL = 2, // non-standard
|
||||
FE_DIVBYZERO = 4,
|
||||
FE_OVERFLOW = 8,
|
||||
FE_UNDERFLOW = 0x10,
|
||||
FE_INEXACT = 0x20,
|
||||
FE_ALL_EXCEPT = 0x3F,
|
||||
FE_TONEAREST = 0,
|
||||
FE_UPWARD = 0x800,
|
||||
FE_DOWNWARD = 0x400,
|
||||
FE_TOWARDZERO = 0xC00,
|
||||
}
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
private extern fenv_t _FE_DFL_ENV;
|
||||
fenv_t* FE_DFL_ENV = &_FE_DFL_ENV;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
fenv_t* FE_DFL_ENV = cast(fenv_t*)(-1);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
private extern fenv_t _FE_DFL_ENV;
|
||||
fenv_t* FE_DFL_ENV = &_FE_DFL_ENV;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
private extern fenv_t __fe_dfl_env;
|
||||
fenv_t* FE_DFL_ENV = &__fe_dfl_env;
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
void feraiseexcept(int excepts);
|
||||
void feclearexcept(int excepts);
|
||||
|
||||
int fetestexcept(int excepts);
|
||||
int feholdexcept(fenv_t* envp);
|
||||
|
||||
void fegetexceptflag(fexcept_t* flagp, int excepts);
|
||||
void fesetexceptflag(in fexcept_t* flagp, int excepts);
|
||||
|
||||
int fegetround();
|
||||
int fesetround(int round);
|
||||
|
||||
void fegetenv(fenv_t* envp);
|
||||
void fesetenv(in fenv_t* envp);
|
||||
void feupdateenv(in fenv_t* envp);
|
||||
57
druntime/import/core/stdc/float_.d
Normal file
57
druntime/import/core/stdc/float_.d
Normal file
@@ -0,0 +1,57 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.float_;
|
||||
|
||||
extern (C):
|
||||
|
||||
enum FLT_ROUNDS = 1;
|
||||
enum FLT_EVAL_METHOD = 2;
|
||||
enum FLT_RADIX = 2;
|
||||
|
||||
enum DECIMAL_DIG = real.dig;
|
||||
enum FLT_DIG = float.dig;
|
||||
enum DBL_DIG = double.dig;
|
||||
enum LDBL_DIG = real.dig;
|
||||
|
||||
enum FLT_MANT_DIG = float.mant_dig;
|
||||
enum DBL_MANT_DIG = double.mant_dig;
|
||||
enum LDBL_MANT_DIG = real.mant_dig;
|
||||
|
||||
enum FLT_MIN = float.min;
|
||||
enum DBL_MIN = double.min;
|
||||
enum LDBL_MIN = real.min;
|
||||
|
||||
enum FLT_MAX = float.max;
|
||||
enum DBL_MAX = double.max;
|
||||
enum LDBL_MAX = real.max;
|
||||
|
||||
enum FLT_EPSILON = float.epsilon;
|
||||
enum DBL_EPSILON = double.epsilon;
|
||||
enum LDBL_EPSILON = real.epsilon;
|
||||
|
||||
enum FLT_MIN_EXP = float.min_exp;
|
||||
enum DBL_MIN_EXP = double.min_exp;
|
||||
enum LDBL_MIN_EXP = real.min_exp;
|
||||
|
||||
enum FLT_MAX_EXP = float.max_exp;
|
||||
enum DBL_MAX_EXP = double.max_exp;
|
||||
enum LDBL_MAX_EXP = real.max_exp;
|
||||
|
||||
enum FLT_MIN_10_EXP = float.min_10_exp;
|
||||
enum DBL_MIN_10_EXP = double.min_10_exp;
|
||||
enum LDBL_MIN_10_EXP = real.min_10_exp;
|
||||
|
||||
enum FLT_MAX_10_EXP = float.max_10_exp;
|
||||
enum DBL_MAX_10_EXP = double.max_10_exp;
|
||||
enum LDBL_MAX_10_EXP = real.max_10_exp;
|
||||
256
druntime/import/core/stdc/inttypes.d
Normal file
256
druntime/import/core/stdc/inttypes.d
Normal file
@@ -0,0 +1,256 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.inttypes;
|
||||
|
||||
public import core.stdc.stddef; // for wchar_t
|
||||
public import core.stdc.stdint; // required by spec
|
||||
|
||||
extern (C):
|
||||
|
||||
struct imaxdiv_t
|
||||
{
|
||||
intmax_t quot,
|
||||
rem;
|
||||
}
|
||||
|
||||
private alias immutable(char)* _cstr;
|
||||
|
||||
enum _cstr PRId8 = "hhd";
|
||||
enum _cstr PRId16 = "hd";
|
||||
enum _cstr PRId32 = "ld";
|
||||
enum _cstr PRId64 = "lld";
|
||||
|
||||
enum _cstr PRIdLEAST8 = "hhd";
|
||||
enum _cstr PRIdLEAST16 = "hd";
|
||||
enum _cstr PRIdLEAST32 = "ld";
|
||||
enum _cstr PRIdLEAST64 = "lld";
|
||||
|
||||
enum _cstr PRIdFAST8 = "hhd";
|
||||
enum _cstr PRIdFAST16 = "d";
|
||||
enum _cstr PRIdFAST32 = "ld";
|
||||
enum _cstr PRIdFAST64 = "lld";
|
||||
|
||||
enum _cstr PRIi8 = "hhi";
|
||||
enum _cstr PRIi16 = "hi";
|
||||
enum _cstr PRIi32 = "li";
|
||||
enum _cstr PRIi64 = "lli";
|
||||
|
||||
enum _cstr PRIiLEAST8 = "hhi";
|
||||
enum _cstr PRIiLEAST16 = "hi";
|
||||
enum _cstr PRIiLEAST32 = "li";
|
||||
enum _cstr PRIiLEAST64 = "lli";
|
||||
|
||||
enum _cstr PRIiFAST8 = "hhi";
|
||||
enum _cstr PRIiFAST16 = "i";
|
||||
enum _cstr PRIiFAST32 = "li";
|
||||
enum _cstr PRIiFAST64 = "lli";
|
||||
|
||||
enum _cstr PRIo8 = "hho";
|
||||
enum _cstr PRIo16 = "ho";
|
||||
enum _cstr PRIo32 = "lo";
|
||||
enum _cstr PRIo64 = "llo";
|
||||
|
||||
enum _cstr PRIoLEAST8 = "hho";
|
||||
enum _cstr PRIoLEAST16 = "ho";
|
||||
enum _cstr PRIoLEAST32 = "lo";
|
||||
enum _cstr PRIoLEAST64 = "llo";
|
||||
|
||||
enum _cstr PRIoFAST8 = "hho";
|
||||
enum _cstr PRIoFAST16 = "o";
|
||||
enum _cstr PRIoFAST32 = "lo";
|
||||
enum _cstr PRIoFAST64 = "llo";
|
||||
|
||||
enum _cstr PRIu8 = "hhu";
|
||||
enum _cstr PRIu16 = "hu";
|
||||
enum _cstr PRIu32 = "lu";
|
||||
enum _cstr PRIu64 = "llu";
|
||||
|
||||
enum _cstr PRIuLEAST8 = "hhu";
|
||||
enum _cstr PRIuLEAST16 = "hu";
|
||||
enum _cstr PRIuLEAST32 = "lu";
|
||||
enum _cstr PRIuLEAST64 = "llu";
|
||||
|
||||
enum _cstr PRIuFAST8 = "hhu";
|
||||
enum _cstr PRIuFAST16 = "u";
|
||||
enum _cstr PRIuFAST32 = "lu";
|
||||
enum _cstr PRIuFAST64 = "llu";
|
||||
|
||||
enum _cstr PRIx8 = "hhx";
|
||||
enum _cstr PRIx16 = "hx";
|
||||
enum _cstr PRIx32 = "lx";
|
||||
enum _cstr PRIx64 = "llx";
|
||||
|
||||
enum _cstr PRIxLEAST8 = "hhx";
|
||||
enum _cstr PRIxLEAST16 = "hx";
|
||||
enum _cstr PRIxLEAST32 = "lx";
|
||||
enum _cstr PRIxLEAST64 = "llx";
|
||||
|
||||
enum _cstr PRIxFAST8 = "hhx";
|
||||
enum _cstr PRIxFAST16 = "x";
|
||||
enum _cstr PRIxFAST32 = "lx";
|
||||
enum _cstr PRIxFAST64 = "llx";
|
||||
|
||||
enum _cstr PRIX8 = "hhX";
|
||||
enum _cstr PRIX16 = "hX";
|
||||
enum _cstr PRIX32 = "lX";
|
||||
enum _cstr PRIX64 = "llX";
|
||||
|
||||
enum _cstr PRIXLEAST8 = "hhX";
|
||||
enum _cstr PRIXLEAST16 = "hX";
|
||||
enum _cstr PRIXLEAST32 = "lX";
|
||||
enum _cstr PRIXLEAST64 = "llX";
|
||||
|
||||
enum _cstr PRIXFAST8 = "hhX";
|
||||
enum _cstr PRIXFAST16 = "X";
|
||||
enum _cstr PRIXFAST32 = "lX";
|
||||
enum _cstr PRIXFAST64 = "llX";
|
||||
|
||||
enum _cstr SCNd8 = "hhd";
|
||||
enum _cstr SCNd16 = "hd";
|
||||
enum _cstr SCNd32 = "ld";
|
||||
enum _cstr SCNd64 = "lld";
|
||||
|
||||
enum _cstr SCNdLEAST8 = "hhd";
|
||||
enum _cstr SCNdLEAST16 = "hd";
|
||||
enum _cstr SCNdLEAST32 = "ld";
|
||||
enum _cstr SCNdLEAST64 = "lld";
|
||||
|
||||
enum _cstr SCNdFAST8 = "hhd";
|
||||
enum _cstr SCNdFAST16 = "d";
|
||||
enum _cstr SCNdFAST32 = "ld";
|
||||
enum _cstr SCNdFAST64 = "lld";
|
||||
|
||||
enum _cstr SCNi8 = "hhd";
|
||||
enum _cstr SCNi16 = "hi";
|
||||
enum _cstr SCNi32 = "li";
|
||||
enum _cstr SCNi64 = "lli";
|
||||
|
||||
enum _cstr SCNiLEAST8 = "hhd";
|
||||
enum _cstr SCNiLEAST16 = "hi";
|
||||
enum _cstr SCNiLEAST32 = "li";
|
||||
enum _cstr SCNiLEAST64 = "lli";
|
||||
|
||||
enum _cstr SCNiFAST8 = "hhd";
|
||||
enum _cstr SCNiFAST16 = "i";
|
||||
enum _cstr SCNiFAST32 = "li";
|
||||
enum _cstr SCNiFAST64 = "lli";
|
||||
|
||||
enum _cstr SCNo8 = "hhd";
|
||||
enum _cstr SCNo16 = "ho";
|
||||
enum _cstr SCNo32 = "lo";
|
||||
enum _cstr SCNo64 = "llo";
|
||||
|
||||
enum _cstr SCNoLEAST8 = "hhd";
|
||||
enum _cstr SCNoLEAST16 = "ho";
|
||||
enum _cstr SCNoLEAST32 = "lo";
|
||||
enum _cstr SCNoLEAST64 = "llo";
|
||||
|
||||
enum _cstr SCNoFAST8 = "hhd";
|
||||
enum _cstr SCNoFAST16 = "o";
|
||||
enum _cstr SCNoFAST32 = "lo";
|
||||
enum _cstr SCNoFAST64 = "llo";
|
||||
|
||||
enum _cstr SCNu8 = "hhd";
|
||||
enum _cstr SCNu16 = "hu";
|
||||
enum _cstr SCNu32 = "lu";
|
||||
enum _cstr SCNu64 = "llu";
|
||||
|
||||
enum _cstr SCNuLEAST8 = "hhd";
|
||||
enum _cstr SCNuLEAST16 = "hu";
|
||||
enum _cstr SCNuLEAST32 = "lu";
|
||||
enum _cstr SCNuLEAST64 = "llu";
|
||||
|
||||
enum _cstr SCNuFAST8 = "hhd";
|
||||
enum _cstr SCNuFAST16 = "u";
|
||||
enum _cstr SCNuFAST32 = "lu";
|
||||
enum _cstr SCNuFAST64 = "llu";
|
||||
|
||||
enum _cstr SCNx8 = "hhd";
|
||||
enum _cstr SCNx16 = "hx";
|
||||
enum _cstr SCNx32 = "lx";
|
||||
enum _cstr SCNx64 = "llx";
|
||||
|
||||
enum _cstr SCNxLEAST8 = "hhd";
|
||||
enum _cstr SCNxLEAST16 = "hx";
|
||||
enum _cstr SCNxLEAST32 = "lx";
|
||||
enum _cstr SCNxLEAST64 = "llx";
|
||||
|
||||
enum _cstr SCNxFAST8 = "hhd";
|
||||
enum _cstr SCNxFAST16 = "x";
|
||||
enum _cstr SCNxFAST32 = "lx";
|
||||
enum _cstr SCNxFAST64 = "llx";
|
||||
|
||||
version( X86_64 )
|
||||
{
|
||||
enum _cstr PRIdMAX = PRId64;
|
||||
enum _cstr PRIiMAX = PRIi64;
|
||||
enum _cstr PRIoMAX = PRIo64;
|
||||
enum _cstr PRIuMAX = PRIu64;
|
||||
enum _cstr PRIxMAX = PRIx64;
|
||||
enum _cstr PRIXMAX = PRIX64;
|
||||
|
||||
enum _cstr SCNdMAX = SCNd64;
|
||||
enum _cstr SCNiMAX = SCNi64;
|
||||
enum _cstr SCNoMAX = SCNo64;
|
||||
enum _cstr SCNuMAX = SCNu64;
|
||||
enum _cstr SCNxMAX = SCNx64;
|
||||
|
||||
enum _cstr PRIdPTR = PRId64;
|
||||
enum _cstr PRIiPTR = PRIi64;
|
||||
enum _cstr PRIoPTR = PRIo64;
|
||||
enum _cstr PRIuPTR = PRIu64;
|
||||
enum _cstr PRIxPTR = PRIx64;
|
||||
enum _cstr PRIXPTR = PRIX64;
|
||||
|
||||
enum _cstr SCNdPTR = SCNd64;
|
||||
enum _cstr SCNiPTR = SCNi64;
|
||||
enum _cstr SCNoPTR = SCNo64;
|
||||
enum _cstr SCNuPTR = SCNu64;
|
||||
enum _cstr SCNxPTR = SCNx64;
|
||||
}
|
||||
else
|
||||
{
|
||||
enum _cstr PRIdMAX = PRId32;
|
||||
enum _cstr PRIiMAX = PRIi32;
|
||||
enum _cstr PRIoMAX = PRIo32;
|
||||
enum _cstr PRIuMAX = PRIu32;
|
||||
enum _cstr PRIxMAX = PRIx32;
|
||||
enum _cstr PRIXMAX = PRIX32;
|
||||
|
||||
enum _cstr SCNdMAX = SCNd32;
|
||||
enum _cstr SCNiMAX = SCNi32;
|
||||
enum _cstr SCNoMAX = SCNo32;
|
||||
enum _cstr SCNuMAX = SCNu32;
|
||||
enum _cstr SCNxMAX = SCNx32;
|
||||
|
||||
enum _cstr PRIdPTR = PRId32;
|
||||
enum _cstr PRIiPTR = PRIi32;
|
||||
enum _cstr PRIoPTR = PRIo32;
|
||||
enum _cstr PRIuPTR = PRIu32;
|
||||
enum _cstr PRIxPTR = PRIx32;
|
||||
enum _cstr PRIXPTR = PRIX32;
|
||||
|
||||
enum _cstr SCNdPTR = SCNd32;
|
||||
enum _cstr SCNiPTR = SCNi32;
|
||||
enum _cstr SCNoPTR = SCNo32;
|
||||
enum _cstr SCNuPTR = SCNu32;
|
||||
enum _cstr SCNxPTR = SCNx32;
|
||||
}
|
||||
|
||||
intmax_t imaxabs(intmax_t j);
|
||||
imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
|
||||
intmax_t strtoimax(in char* nptr, char** endptr, int base);
|
||||
uintmax_t strtoumax(in char* nptr, char** endptr, int base);
|
||||
intmax_t wcstoimax(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
uintmax_t wcstoumax(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
38
druntime/import/core/stdc/limits.d
Normal file
38
druntime/import/core/stdc/limits.d
Normal file
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.limits;
|
||||
|
||||
private import core.stdc.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
enum CHAR_BIT = 8;
|
||||
enum SCHAR_MIN = byte.min;
|
||||
enum SCHAR_MAX = byte.max;
|
||||
enum UCHAR_MAX = ubyte.min;
|
||||
enum CHAR_MIN = char.max;
|
||||
enum CHAR_MAX = char.max;
|
||||
enum MB_LEN_MAX = 2;
|
||||
enum SHRT_MIN = short.min;
|
||||
enum SHRT_MAX = short.max;
|
||||
enum USHRT_MAX = ushort.max;
|
||||
enum INT_MIN = int.min;
|
||||
enum INT_MAX = int.max;
|
||||
enum UINT_MAX = uint.max;
|
||||
enum LONG_MIN = c_long.min;
|
||||
enum LONG_MAX = c_long.max;
|
||||
enum ULONG_MAX = c_ulong.max;
|
||||
enum LLONG_MIN = long.min;
|
||||
enum LLONG_MAX = long.max;
|
||||
enum ULLONG_MAX = ulong.max;
|
||||
60
druntime/import/core/stdc/locale.d
Normal file
60
druntime/import/core/stdc/locale.d
Normal file
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.locale;
|
||||
|
||||
extern (C):
|
||||
|
||||
struct lconv
|
||||
{
|
||||
char* decimal_point;
|
||||
char* thousands_sep;
|
||||
char* grouping;
|
||||
char* int_curr_symbol;
|
||||
char* currency_symbol;
|
||||
char* mon_decimal_point;
|
||||
char* mon_thousands_sep;
|
||||
char* mon_grouping;
|
||||
char* positive_sign;
|
||||
char* negative_sign;
|
||||
byte int_frac_digits;
|
||||
byte frac_digits;
|
||||
byte p_cs_precedes;
|
||||
byte p_sep_by_space;
|
||||
byte n_cs_precedes;
|
||||
byte n_sep_by_space;
|
||||
byte p_sign_posn;
|
||||
byte n_sign_posn;
|
||||
byte int_p_cs_precedes;
|
||||
byte int_p_sep_by_space;
|
||||
byte int_n_cs_precedes;
|
||||
byte int_n_sep_by_space;
|
||||
byte int_p_sign_posn;
|
||||
byte int_n_sign_posn;
|
||||
}
|
||||
|
||||
enum LC_CTYPE = 0;
|
||||
enum LC_NUMERIC = 1;
|
||||
enum LC_TIME = 2;
|
||||
enum LC_COLLATE = 3;
|
||||
enum LC_MONETARY = 4;
|
||||
enum LC_ALL = 6;
|
||||
enum LC_PAPER = 7; // non-standard
|
||||
enum LC_NAME = 8; // non-standard
|
||||
enum LC_ADDRESS = 9; // non-standard
|
||||
enum LC_TELEPHONE = 10; // non-standard
|
||||
enum LC_MEASUREMENT = 11; // non-standard
|
||||
enum LC_IDENTIFICATION = 12; // non-standard
|
||||
|
||||
char* setlocale(int category, in char* locale);
|
||||
lconv* localeconv();
|
||||
933
druntime/import/core/stdc/math.d
Normal file
933
druntime/import/core/stdc/math.d
Normal file
@@ -0,0 +1,933 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.math;
|
||||
|
||||
private import core.stdc.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
alias float float_t;
|
||||
alias double double_t;
|
||||
|
||||
enum double HUGE_VAL = double.infinity;
|
||||
enum double HUGE_VALF = float.infinity;
|
||||
enum double HUGE_VALL = real.infinity;
|
||||
|
||||
enum float INFINITY = float.infinity;
|
||||
enum float NAN = float.nan;
|
||||
|
||||
enum int FP_ILOGB0 = int.min;
|
||||
enum int FP_ILOGBNAN = int.min;
|
||||
|
||||
enum int MATH_ERRNO = 1;
|
||||
enum int MATH_ERREXCEPT = 2;
|
||||
enum int math_errhandling = MATH_ERRNO | MATH_ERREXCEPT;
|
||||
|
||||
version( none )
|
||||
{
|
||||
//
|
||||
// these functions are all macros in C
|
||||
//
|
||||
|
||||
//int fpclassify(real-floating x);
|
||||
int fpclassify(float x);
|
||||
int fpclassify(double x);
|
||||
int fpclassify(real x);
|
||||
|
||||
//int isfinite(real-floating x);
|
||||
int isfinite(float x);
|
||||
int isfinite(double x);
|
||||
int isfinite(real x);
|
||||
|
||||
//int isinf(real-floating x);
|
||||
int isinf(float x);
|
||||
int isinf(double x);
|
||||
int isinf(real x);
|
||||
|
||||
//int isnan(real-floating x);
|
||||
int isnan(float x);
|
||||
int isnan(double x);
|
||||
int isnan(real x);
|
||||
|
||||
//int isnormal(real-floating x);
|
||||
int isnormal(float x);
|
||||
int isnormal(double x);
|
||||
int isnormal(real x);
|
||||
|
||||
//int signbit(real-floating x);
|
||||
int signbit(float x);
|
||||
int signbit(double x);
|
||||
int signbit(real x);
|
||||
|
||||
//int isgreater(real-floating x, real-floating y);
|
||||
int isgreater(float x, float y);
|
||||
int isgreater(double x, double y);
|
||||
int isgreater(real x, real y);
|
||||
|
||||
//int isgreaterequal(real-floating x, real-floating y);
|
||||
int isgreaterequal(float x, float y);
|
||||
int isgreaterequal(double x, double y);
|
||||
int isgreaterequal(real x, real y);
|
||||
|
||||
//int isless(real-floating x, real-floating y);
|
||||
int isless(float x, float y);
|
||||
int isless(double x, double y);
|
||||
int isless(real x, real y);
|
||||
|
||||
//int islessequal(real-floating x, real-floating y);
|
||||
int islessequal(float x, float y);
|
||||
int islessequal(double x, double y);
|
||||
int islessequal(real x, real y);
|
||||
|
||||
//int islessgreater(real-floating x, real-floating y);
|
||||
int islessgreater(float x, float y);
|
||||
int islessgreater(double x, double y);
|
||||
int islessgreater(real x, real y);
|
||||
|
||||
//int isunordered(real-floating x, real-floating y);
|
||||
int isunordered(float x, float y);
|
||||
int isunordered(double x, double y);
|
||||
int isunordered(real x, real y);
|
||||
}
|
||||
|
||||
version( DigitalMars ) version( Windows )
|
||||
version = DigitalMarsWin32;
|
||||
|
||||
version( DigitalMarsWin32 )
|
||||
{
|
||||
enum
|
||||
{
|
||||
FP_NANS = 0,
|
||||
FP_NANQ = 1,
|
||||
FP_INFINITE = 2,
|
||||
FP_NORMAL = 3,
|
||||
FP_SUBNORMAL = 4,
|
||||
FP_ZERO = 5,
|
||||
FP_NAN = FP_NANQ,
|
||||
FP_EMPTY = 6,
|
||||
FP_UNSUPPORTED = 7,
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FP_FAST_FMA = 0,
|
||||
FP_FAST_FMAF = 0,
|
||||
FP_FAST_FMAL = 0,
|
||||
}
|
||||
|
||||
uint __fpclassify_f(float x);
|
||||
uint __fpclassify_d(double x);
|
||||
uint __fpclassify_ld(real x);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
//int fpclassify(real-floating x);
|
||||
int fpclassify(float x) { return __fpclassify_f(x); }
|
||||
int fpclassify(double x) { return __fpclassify_d(x); }
|
||||
int fpclassify(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __fpclassify_d(x)
|
||||
: __fpclassify_ld(x);
|
||||
}
|
||||
|
||||
//int isfinite(real-floating x);
|
||||
int isfinite(float x) { return fpclassify(x) >= FP_NORMAL; }
|
||||
int isfinite(double x) { return fpclassify(x) >= FP_NORMAL; }
|
||||
int isfinite(real x) { return fpclassify(x) >= FP_NORMAL; }
|
||||
|
||||
//int isinf(real-floating x);
|
||||
int isinf(float x) { return fpclassify(x) == FP_INFINITE; }
|
||||
int isinf(double x) { return fpclassify(x) == FP_INFINITE; }
|
||||
int isinf(real x) { return fpclassify(x) == FP_INFINITE; }
|
||||
|
||||
//int isnan(real-floating x);
|
||||
int isnan(float x) { return fpclassify(x) <= FP_NANQ; }
|
||||
int isnan(double x) { return fpclassify(x) <= FP_NANQ; }
|
||||
int isnan(real x) { return fpclassify(x) <= FP_NANQ; }
|
||||
|
||||
//int isnormal(real-floating x);
|
||||
int isnormal(float x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(double x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(real x) { return fpclassify(x) == FP_NORMAL; }
|
||||
|
||||
//int signbit(real-floating x);
|
||||
int signbit(float x) { return (cast(short*)&(x))[1] & 0x8000; }
|
||||
int signbit(double x) { return (cast(short*)&(x))[3] & 0x8000; }
|
||||
int signbit(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? (cast(short*)&(x))[3] & 0x8000
|
||||
: (cast(short*)&(x))[4] & 0x8000;
|
||||
}
|
||||
}
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
FP_NAN,
|
||||
FP_INFINITE,
|
||||
FP_ZERO,
|
||||
FP_SUBNORMAL,
|
||||
FP_NORMAL,
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FP_FAST_FMA = 0,
|
||||
FP_FAST_FMAF = 0,
|
||||
FP_FAST_FMAL = 0,
|
||||
}
|
||||
|
||||
int __fpclassifyf(float x);
|
||||
int __fpclassify(double x);
|
||||
int __fpclassifyl(real x);
|
||||
|
||||
int __finitef(float x);
|
||||
int __finite(double x);
|
||||
int __finitel(real x);
|
||||
|
||||
int __isinff(float x);
|
||||
int __isinf(double x);
|
||||
int __isinfl(real x);
|
||||
|
||||
int __isnanf(float x);
|
||||
int __isnan(double x);
|
||||
int __isnanl(real x);
|
||||
|
||||
int __signbitf(float x);
|
||||
int __signbit(double x);
|
||||
int __signbitl(real x);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
//int fpclassify(real-floating x);
|
||||
int fpclassify(float x) { return __fpclassifyf(x); }
|
||||
int fpclassify(double x) { return __fpclassify(x); }
|
||||
int fpclassify(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __fpclassify(x)
|
||||
: __fpclassifyl(x);
|
||||
}
|
||||
|
||||
//int isfinite(real-floating x);
|
||||
int isfinite(float x) { return __finitef(x); }
|
||||
int isfinite(double x) { return __finite(x); }
|
||||
int isfinite(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __finite(x)
|
||||
: __finitel(x);
|
||||
}
|
||||
|
||||
//int isinf(real-floating x);
|
||||
int isinf(float x) { return __isinff(x); }
|
||||
int isinf(double x) { return __isinf(x); }
|
||||
int isinf(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __isinf(x)
|
||||
: __isinfl(x);
|
||||
}
|
||||
|
||||
//int isnan(real-floating x);
|
||||
int isnan(float x) { return __isnanf(x); }
|
||||
int isnan(double x) { return __isnan(x); }
|
||||
int isnan(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __isnan(x)
|
||||
: __isnanl(x);
|
||||
}
|
||||
|
||||
//int isnormal(real-floating x);
|
||||
int isnormal(float x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(double x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(real x) { return fpclassify(x) == FP_NORMAL; }
|
||||
|
||||
//int signbit(real-floating x);
|
||||
int signbit(float x) { return __signbitf(x); }
|
||||
int signbit(double x) { return __signbit(x); }
|
||||
int signbit(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __signbit(x)
|
||||
: __signbitl(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
FP_NAN = 1,
|
||||
FP_INFINITE = 2,
|
||||
FP_ZERO = 3,
|
||||
FP_NORMAL = 4,
|
||||
FP_SUBNORMAL = 5,
|
||||
FP_SUPERNORMAL = 6,
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FP_FAST_FMA = 0,
|
||||
FP_FAST_FMAF = 0,
|
||||
FP_FAST_FMAL = 0,
|
||||
}
|
||||
|
||||
int __fpclassifyf(float x);
|
||||
int __fpclassifyd(double x);
|
||||
int __fpclassify(real x);
|
||||
|
||||
int __isfinitef(float x);
|
||||
int __isfinited(double x);
|
||||
int __isfinite(real x);
|
||||
|
||||
int __isinff(float x);
|
||||
int __isinfd(double x);
|
||||
int __isinf(real x);
|
||||
|
||||
int __isnanf(float x);
|
||||
int __isnand(double x);
|
||||
int __isnan(real x);
|
||||
|
||||
int __signbitf(float x);
|
||||
int __signbitd(double x);
|
||||
int __signbitl(real x);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
//int fpclassify(real-floating x);
|
||||
int fpclassify(float x) { return __fpclassifyf(x); }
|
||||
int fpclassify(double x) { return __fpclassifyd(x); }
|
||||
int fpclassify(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __fpclassifyd(x)
|
||||
: __fpclassify(x);
|
||||
}
|
||||
|
||||
//int isfinite(real-floating x);
|
||||
int isfinite(float x) { return __isfinitef(x); }
|
||||
int isfinite(double x) { return __isfinited(x); }
|
||||
int isfinite(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __isfinited(x)
|
||||
: __isfinite(x);
|
||||
}
|
||||
|
||||
//int isinf(real-floating x);
|
||||
int isinf(float x) { return __isinff(x); }
|
||||
int isinf(double x) { return __isinfd(x); }
|
||||
int isinf(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __isinfd(x)
|
||||
: __isinf(x);
|
||||
}
|
||||
|
||||
//int isnan(real-floating x);
|
||||
int isnan(float x) { return __isnanf(x); }
|
||||
int isnan(double x) { return __isnand(x); }
|
||||
int isnan(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __isnand(x)
|
||||
: __isnan(x);
|
||||
}
|
||||
|
||||
//int isnormal(real-floating x);
|
||||
int isnormal(float x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(double x) { return fpclassify(x) == FP_NORMAL; }
|
||||
int isnormal(real x) { return fpclassify(x) == FP_NORMAL; }
|
||||
|
||||
//int signbit(real-floating x);
|
||||
int signbit(float x) { return __signbitf(x); }
|
||||
int signbit(double x) { return __signbitd(x); }
|
||||
int signbit(real x)
|
||||
{
|
||||
return (real.sizeof == double.sizeof)
|
||||
? __signbitd(x)
|
||||
: __signbitl(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
FP_INFINITE = 0x01,
|
||||
FP_NAN = 0x02,
|
||||
FP_NORMAL = 0x04,
|
||||
FP_SUBNORMAL = 0x08,
|
||||
FP_ZERO = 0x10,
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FP_FAST_FMA = 0,
|
||||
FP_FAST_FMAF = 0,
|
||||
FP_FAST_FMAL = 0,
|
||||
}
|
||||
|
||||
int __fpclassifyd(double);
|
||||
int __fpclassifyf(float);
|
||||
int __fpclassifyl(real);
|
||||
int __isfinitef(float);
|
||||
int __isfinite(double);
|
||||
int __isfinitel(real);
|
||||
int __isinff(float);
|
||||
int __isinfl(real);
|
||||
int __isnanl(real);
|
||||
int __isnormalf(float);
|
||||
int __isnormal(double);
|
||||
int __isnormall(real);
|
||||
int __signbit(double);
|
||||
int __signbitf(float);
|
||||
int __signbitl(real);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
//int fpclassify(real-floating x);
|
||||
int fpclassify(float x) { return __fpclassifyf(x); }
|
||||
int fpclassify(double x) { return __fpclassifyd(x); }
|
||||
int fpclassify(real x) { return __fpclassifyl(x); }
|
||||
|
||||
//int isfinite(real-floating x);
|
||||
int isfinite(float x) { return __isfinitef(x); }
|
||||
int isfinite(double x) { return __isfinite(x); }
|
||||
int isfinite(real x) { return __isfinitel(x); }
|
||||
|
||||
//int isinf(real-floating x);
|
||||
int isinf(float x) { return __isinff(x); }
|
||||
int isinf(double x) { return __isinfl(x); }
|
||||
int isinf(real x) { return __isinfl(x); }
|
||||
|
||||
//int isnan(real-floating x);
|
||||
int isnan(float x) { return __isnanl(x); }
|
||||
int isnan(double x) { return __isnanl(x); }
|
||||
int isnan(real x) { return __isnanl(x); }
|
||||
|
||||
//int isnormal(real-floating x);
|
||||
int isnormal(float x) { return __isnormalf(x); }
|
||||
int isnormal(double x) { return __isnormal(x); }
|
||||
int isnormal(real x) { return __isnormall(x); }
|
||||
|
||||
//int signbit(real-floating x);
|
||||
int signbit(float x) { return __signbitf(x); }
|
||||
int signbit(double x) { return __signbit(x); }
|
||||
int signbit(real x) { return __signbit(x); }
|
||||
}
|
||||
}
|
||||
|
||||
extern (D)
|
||||
{
|
||||
//int isgreater(real-floating x, real-floating y);
|
||||
int isgreater(float x, float y) { return !(x !> y); }
|
||||
int isgreater(double x, double y) { return !(x !> y); }
|
||||
int isgreater(real x, real y) { return !(x !> y); }
|
||||
|
||||
//int isgreaterequal(real-floating x, real-floating y);
|
||||
int isgreaterequal(float x, float y) { return !(x !>= y); }
|
||||
int isgreaterequal(double x, double y) { return !(x !>= y); }
|
||||
int isgreaterequal(real x, real y) { return !(x !>= y); }
|
||||
|
||||
//int isless(real-floating x, real-floating y);
|
||||
int isless(float x, float y) { return !(x !< y); }
|
||||
int isless(double x, double y) { return !(x !< y); }
|
||||
int isless(real x, real y) { return !(x !< y); }
|
||||
|
||||
//int islessequal(real-floating x, real-floating y);
|
||||
int islessequal(float x, float y) { return !(x !<= y); }
|
||||
int islessequal(double x, double y) { return !(x !<= y); }
|
||||
int islessequal(real x, real y) { return !(x !<= y); }
|
||||
|
||||
//int islessgreater(real-floating x, real-floating y);
|
||||
int islessgreater(float x, float y) { return !(x !<> y); }
|
||||
int islessgreater(double x, double y) { return !(x !<> y); }
|
||||
int islessgreater(real x, real y) { return !(x !<> y); }
|
||||
|
||||
//int isunordered(real-floating x, real-floating y);
|
||||
int isunordered(float x, float y) { return (x !<>= y); }
|
||||
int isunordered(double x, double y) { return (x !<>= y); }
|
||||
int isunordered(real x, real y) { return (x !<>= y); }
|
||||
}
|
||||
|
||||
// NOTE: freebsd < 8-CURRENT doesn't appear to support *l, but we can
|
||||
// approximate.
|
||||
version( freebsd )
|
||||
{
|
||||
double acos(double x);
|
||||
float acosf(float x);
|
||||
real acosl(real x) { return acos(x); }
|
||||
|
||||
double asin(double x);
|
||||
float asinf(float x);
|
||||
real asinl(real x) { return asin(x); }
|
||||
|
||||
double atan(double x);
|
||||
float atanf(float x);
|
||||
real atanl(real x) { return atan(x); }
|
||||
|
||||
double atan2(double y, double x);
|
||||
float atan2f(float y, float x);
|
||||
real atan2l(real y, real x) { return atan2(y, x); }
|
||||
|
||||
double cos(double x);
|
||||
float cosf(float x);
|
||||
real cosl(real x) { return cos(x); }
|
||||
|
||||
double sin(double x);
|
||||
float sinf(float x);
|
||||
real sinl(real x) { return sin(x); }
|
||||
|
||||
double tan(double x);
|
||||
float tanf(float x);
|
||||
real tanl(real x) { return tan(x); }
|
||||
|
||||
double acosh(double x);
|
||||
float acoshf(float x);
|
||||
real acoshl(real x) { return acosh(x); }
|
||||
|
||||
double asinh(double x);
|
||||
float asinhf(float x);
|
||||
real asinhl(real x) { return asinh(x); }
|
||||
|
||||
double atanh(double x);
|
||||
float atanhf(float x);
|
||||
real atanhl(real x) { return atanh(x); }
|
||||
|
||||
double cosh(double x);
|
||||
float coshf(float x);
|
||||
real coshl(real x) { return cosh(x); }
|
||||
|
||||
double sinh(double x);
|
||||
float sinhf(float x);
|
||||
real sinhl(real x) { return sinh(x); }
|
||||
|
||||
double tanh(double x);
|
||||
float tanhf(float x);
|
||||
real tanhl(real x) { return tanh(x); }
|
||||
|
||||
double exp(double x);
|
||||
float expf(float x);
|
||||
real expl(real x) { return exp(x); }
|
||||
|
||||
double exp2(double x);
|
||||
float exp2f(float x);
|
||||
real exp2l(real x) { return exp2(x); }
|
||||
|
||||
double expm1(double x);
|
||||
float expm1f(float x);
|
||||
real expm1l(real x) { return expm1(x); }
|
||||
|
||||
double frexp(double value, int* exp);
|
||||
float frexpf(float value, int* exp);
|
||||
real frexpl(real value, int* exp) { return frexp(value, exp); }
|
||||
|
||||
int ilogb(double x);
|
||||
int ilogbf(float x);
|
||||
int ilogbl(real x) { return ilogb(x); }
|
||||
|
||||
double ldexp(double x, int exp);
|
||||
float ldexpf(float x, int exp);
|
||||
real ldexpl(real x, int exp) { return ldexp(x, exp); }
|
||||
|
||||
double log(double x);
|
||||
float logf(float x);
|
||||
real logl(real x) { return log(x); }
|
||||
|
||||
double log10(double x);
|
||||
float log10f(float x);
|
||||
real log10l(real x) { return log10(x); }
|
||||
|
||||
double log1p(double x);
|
||||
float log1pf(float x);
|
||||
real log1pl(real x) { return log1p(x); }
|
||||
|
||||
private enum real ONE_LN2 = 1 / 0x1.62e42fefa39ef358p-1L;
|
||||
double log2(double x) { return log(x) * ONE_LN2; }
|
||||
float log2f(float x) { return logf(x) * ONE_LN2; }
|
||||
real log2l(real x) { return logl(x) * ONE_LN2; }
|
||||
|
||||
double logb(double x);
|
||||
float logbf(float x);
|
||||
real logbl(real x) { return logb(x); }
|
||||
|
||||
double modf(double value, double* iptr);
|
||||
float modff(float value, float* iptr);
|
||||
//real modfl(real value, real *iptr); // nontrivial conversion
|
||||
|
||||
double scalbn(double x, int n);
|
||||
float scalbnf(float x, int n);
|
||||
real scalbnl(real x, int n) { return scalbn(x, n); }
|
||||
|
||||
double scalbln(double x, c_long n);
|
||||
float scalblnf(float x, c_long n);
|
||||
real scalblnl(real x, c_long n) { return scalbln(x, n); }
|
||||
|
||||
|
||||
double cbrt(double x);
|
||||
float cbrtf(float x);
|
||||
real cbrtl(real x) { return cbrt(x); }
|
||||
|
||||
double fabs(double x);
|
||||
float fabsf(float x);
|
||||
real fabsl(real x) { return fabs(x); }
|
||||
|
||||
double hypot(double x, double y);
|
||||
float hypotf(float x, float y);
|
||||
real hypotl(real x, real y) { return hypot(x, y); }
|
||||
|
||||
double pow(double x, double y);
|
||||
float powf(float x, float y);
|
||||
real powl(real x, real y) { return pow(x, y); }
|
||||
|
||||
double sqrt(double x);
|
||||
float sqrtf(float x);
|
||||
real sqrtl(real x) { return sqrt(x); }
|
||||
|
||||
double erf(double x);
|
||||
float erff(float x);
|
||||
real erfl(real x) { return erf(x); }
|
||||
|
||||
double erfc(double x);
|
||||
float erfcf(float x);
|
||||
real erfcl(real x) { return erfc(x); }
|
||||
|
||||
double lgamma(double x);
|
||||
float lgammaf(float x);
|
||||
real lgammal(real x) { return lgamma(x); }
|
||||
|
||||
double tgamma(double x);
|
||||
float tgammaf(float x);
|
||||
real tgammal(real x) { return tgamma(x); }
|
||||
|
||||
double ceil(double x);
|
||||
float ceilf(float x);
|
||||
real ceill(real x) { return ceil(x); }
|
||||
|
||||
double floor(double x);
|
||||
float floorf(float x);
|
||||
real floorl(real x) { return floor(x); }
|
||||
|
||||
double nearbyint(double x);
|
||||
float nearbyintf(float x);
|
||||
real nearbyintl(real x) { return nearbyint(x); }
|
||||
|
||||
double rint(double x);
|
||||
float rintf(float x);
|
||||
real rintl(real x) { return rint(x); }
|
||||
|
||||
c_long lrint(double x);
|
||||
c_long lrintf(float x);
|
||||
c_long lrintl(real x) { return lrint(x); }
|
||||
|
||||
long llrint(double x);
|
||||
long llrintf(float x);
|
||||
long llrintl(real x) { return llrint(x); }
|
||||
|
||||
double round(double x);
|
||||
float roundf(float x);
|
||||
real roundl(real x) { return round(x); }
|
||||
|
||||
c_long lround(double x);
|
||||
c_long lroundf(float x);
|
||||
c_long lroundl(real x) { return lround(x); }
|
||||
|
||||
long llround(double x);
|
||||
long llroundf(float x);
|
||||
long llroundl(real x) { return llround(x); }
|
||||
|
||||
double trunc(double x);
|
||||
float truncf(float x);
|
||||
real truncl(real x) { return trunc(x); }
|
||||
|
||||
double fmod(double x, double y);
|
||||
float fmodf(float x, float y);
|
||||
real fmodl(real x, real y) { return fmod(x, y); }
|
||||
|
||||
double remainder(double x, double y);
|
||||
float remainderf(float x, float y);
|
||||
real remainderl(real x, real y) { return remainder(x, y); }
|
||||
|
||||
double remquo(double x, double y, int* quo);
|
||||
float remquof(float x, float y, int* quo);
|
||||
real remquol(real x, real y, int* quo) { return remquo(x, y, quo); }
|
||||
|
||||
double copysign(double x, double y);
|
||||
float copysignf(float x, float y);
|
||||
real copysignl(real x, real y) { return copysign(x, y); }
|
||||
|
||||
// double nan(char* tagp);
|
||||
// float nanf(char* tagp);
|
||||
// real nanl(char* tagp);
|
||||
|
||||
double nextafter(double x, double y);
|
||||
float nextafterf(float x, float y);
|
||||
real nextafterl(real x, real y) { return nextafter(x, y); }
|
||||
|
||||
double nexttoward(double x, real y);
|
||||
float nexttowardf(float x, real y);
|
||||
real nexttowardl(real x, real y) { return nexttoward(x, y); }
|
||||
|
||||
double fdim(double x, double y);
|
||||
float fdimf(float x, float y);
|
||||
real fdiml(real x, real y) { return fdim(x, y); }
|
||||
|
||||
double fmax(double x, double y);
|
||||
float fmaxf(float x, float y);
|
||||
real fmaxl(real x, real y) { return fmax(x, y); }
|
||||
|
||||
double fmin(double x, double y);
|
||||
float fminf(float x, float y);
|
||||
real fminl(real x, real y) { return fmin(x, y); }
|
||||
|
||||
double fma(double x, double y, double z);
|
||||
float fmaf(float x, float y, float z);
|
||||
real fmal(real x, real y, real z) { return fma(x, y, z); }
|
||||
}
|
||||
else
|
||||
{
|
||||
double acos(double x);
|
||||
float acosf(float x);
|
||||
real acosl(real x);
|
||||
|
||||
double asin(double x);
|
||||
float asinf(float x);
|
||||
real asinl(real x);
|
||||
|
||||
double atan(double x);
|
||||
float atanf(float x);
|
||||
real atanl(real x);
|
||||
|
||||
double atan2(double y, double x);
|
||||
float atan2f(float y, float x);
|
||||
real atan2l(real y, real x);
|
||||
|
||||
double cos(double x);
|
||||
float cosf(float x);
|
||||
real cosl(real x);
|
||||
|
||||
double sin(double x);
|
||||
float sinf(float x);
|
||||
real sinl(real x);
|
||||
|
||||
double tan(double x);
|
||||
float tanf(float x);
|
||||
real tanl(real x);
|
||||
|
||||
double acosh(double x);
|
||||
float acoshf(float x);
|
||||
real acoshl(real x);
|
||||
|
||||
double asinh(double x);
|
||||
float asinhf(float x);
|
||||
real asinhl(real x);
|
||||
|
||||
double atanh(double x);
|
||||
float atanhf(float x);
|
||||
real atanhl(real x);
|
||||
|
||||
double cosh(double x);
|
||||
float coshf(float x);
|
||||
real coshl(real x);
|
||||
|
||||
double sinh(double x);
|
||||
float sinhf(float x);
|
||||
real sinhl(real x);
|
||||
|
||||
double tanh(double x);
|
||||
float tanhf(float x);
|
||||
real tanhl(real x);
|
||||
|
||||
double exp(double x);
|
||||
float expf(float x);
|
||||
real expl(real x);
|
||||
|
||||
double exp2(double x);
|
||||
float exp2f(float x);
|
||||
real exp2l(real x);
|
||||
|
||||
double expm1(double x);
|
||||
float expm1f(float x);
|
||||
real expm1l(real x);
|
||||
|
||||
double frexp(double value, int* exp);
|
||||
float frexpf(float value, int* exp);
|
||||
real frexpl(real value, int* exp);
|
||||
|
||||
int ilogb(double x);
|
||||
int ilogbf(float x);
|
||||
int ilogbl(real x);
|
||||
|
||||
double ldexp(double x, int exp);
|
||||
float ldexpf(float x, int exp);
|
||||
real ldexpl(real x, int exp);
|
||||
|
||||
double log(double x);
|
||||
float logf(float x);
|
||||
real logl(real x);
|
||||
|
||||
double log10(double x);
|
||||
float log10f(float x);
|
||||
real log10l(real x);
|
||||
|
||||
double log1p(double x);
|
||||
float log1pf(float x);
|
||||
real log1pl(real x);
|
||||
|
||||
double log2(double x);
|
||||
float log2f(float x);
|
||||
real log2l(real x);
|
||||
|
||||
double logb(double x);
|
||||
float logbf(float x);
|
||||
real logbl(real x);
|
||||
|
||||
double modf(double value, double* iptr);
|
||||
float modff(float value, float* iptr);
|
||||
real modfl(real value, real *iptr);
|
||||
|
||||
double scalbn(double x, int n);
|
||||
float scalbnf(float x, int n);
|
||||
real scalbnl(real x, int n);
|
||||
|
||||
double scalbln(double x, c_long n);
|
||||
float scalblnf(float x, c_long n);
|
||||
real scalblnl(real x, c_long n);
|
||||
|
||||
double cbrt(double x);
|
||||
float cbrtf(float x);
|
||||
real cbrtl(real x);
|
||||
|
||||
double fabs(double x);
|
||||
float fabsf(float x);
|
||||
real fabsl(real x);
|
||||
|
||||
double hypot(double x, double y);
|
||||
float hypotf(float x, float y);
|
||||
real hypotl(real x, real y);
|
||||
|
||||
double pow(double x, double y);
|
||||
float powf(float x, float y);
|
||||
real powl(real x, real y);
|
||||
|
||||
double sqrt(double x);
|
||||
float sqrtf(float x);
|
||||
real sqrtl(real x);
|
||||
|
||||
double erf(double x);
|
||||
float erff(float x);
|
||||
real erfl(real x);
|
||||
|
||||
double erfc(double x);
|
||||
float erfcf(float x);
|
||||
real erfcl(real x);
|
||||
|
||||
double lgamma(double x);
|
||||
float lgammaf(float x);
|
||||
real lgammal(real x);
|
||||
|
||||
double tgamma(double x);
|
||||
float tgammaf(float x);
|
||||
real tgammal(real x);
|
||||
|
||||
double ceil(double x);
|
||||
float ceilf(float x);
|
||||
real ceill(real x);
|
||||
|
||||
double floor(double x);
|
||||
float floorf(float x);
|
||||
real floorl(real x);
|
||||
|
||||
double nearbyint(double x);
|
||||
float nearbyintf(float x);
|
||||
real nearbyintl(real x);
|
||||
|
||||
double rint(double x);
|
||||
float rintf(float x);
|
||||
real rintl(real x);
|
||||
|
||||
c_long lrint(double x);
|
||||
c_long lrintf(float x);
|
||||
c_long lrintl(real x);
|
||||
|
||||
long llrint(double x);
|
||||
long llrintf(float x);
|
||||
long llrintl(real x);
|
||||
|
||||
double round(double x);
|
||||
float roundf(float x);
|
||||
real roundl(real x);
|
||||
|
||||
c_long lround(double x);
|
||||
c_long lroundf(float x);
|
||||
c_long lroundl(real x);
|
||||
|
||||
long llround(double x);
|
||||
long llroundf(float x);
|
||||
long llroundl(real x);
|
||||
|
||||
double trunc(double x);
|
||||
float truncf(float x);
|
||||
real truncl(real x);
|
||||
|
||||
double fmod(double x, double y);
|
||||
float fmodf(float x, float y);
|
||||
real fmodl(real x, real y);
|
||||
|
||||
double remainder(double x, double y);
|
||||
float remainderf(float x, float y);
|
||||
real remainderl(real x, real y);
|
||||
|
||||
double remquo(double x, double y, int* quo);
|
||||
float remquof(float x, float y, int* quo);
|
||||
real remquol(real x, real y, int* quo);
|
||||
|
||||
double copysign(double x, double y);
|
||||
float copysignf(float x, float y);
|
||||
real copysignl(real x, real y);
|
||||
|
||||
double nan(char* tagp);
|
||||
float nanf(char* tagp);
|
||||
real nanl(char* tagp);
|
||||
|
||||
double nextafter(double x, double y);
|
||||
float nextafterf(float x, float y);
|
||||
real nextafterl(real x, real y);
|
||||
|
||||
double nexttoward(double x, real y);
|
||||
float nexttowardf(float x, real y);
|
||||
real nexttowardl(real x, real y);
|
||||
|
||||
double fdim(double x, double y);
|
||||
float fdimf(float x, float y);
|
||||
real fdiml(real x, real y);
|
||||
|
||||
double fmax(double x, double y);
|
||||
float fmaxf(float x, float y);
|
||||
real fmaxl(real x, real y);
|
||||
|
||||
double fmin(double x, double y);
|
||||
float fminf(float x, float y);
|
||||
real fminl(real x, real y);
|
||||
|
||||
double fma(double x, double y, double z);
|
||||
float fmaf(float x, float y, float z);
|
||||
real fmal(real x, real y, real z);
|
||||
}
|
||||
53
druntime/import/core/stdc/signal.d
Normal file
53
druntime/import/core/stdc/signal.d
Normal file
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.signal;
|
||||
|
||||
extern (C):
|
||||
|
||||
// this should be volatile
|
||||
alias int sig_atomic_t;
|
||||
|
||||
private alias void function(int) sigfn_t;
|
||||
|
||||
version( Posix )
|
||||
{
|
||||
enum SIG_ERR = cast(sigfn_t) -1;
|
||||
enum SIG_DFL = cast(sigfn_t) 0;
|
||||
enum SIG_IGN = cast(sigfn_t) 1;
|
||||
|
||||
// standard C signals
|
||||
enum SIGABRT = 6; // Abnormal termination
|
||||
enum SIGFPE = 8; // Floating-point error
|
||||
enum SIGILL = 4; // Illegal hardware instruction
|
||||
enum SIGINT = 2; // Terminal interrupt character
|
||||
enum SIGSEGV = 11; // Invalid memory reference
|
||||
enum SIGTERM = 15; // Termination
|
||||
}
|
||||
else
|
||||
{
|
||||
enum SIG_ERR = cast(sigfn_t) -1;
|
||||
enum SIG_DFL = cast(sigfn_t) 0;
|
||||
enum SIG_IGN = cast(sigfn_t) 1;
|
||||
|
||||
// standard C signals
|
||||
enum SIGABRT = 22; // Abnormal termination
|
||||
enum SIGFPE = 8; // Floating-point error
|
||||
enum SIGILL = 4; // Illegal hardware instruction
|
||||
enum SIGINT = 2; // Terminal interrupt character
|
||||
enum SIGSEGV = 11; // Invalid memory reference
|
||||
enum SIGTERM = 15; // Termination
|
||||
}
|
||||
|
||||
sigfn_t signal(int sig, sigfn_t func);
|
||||
int raise(int sig);
|
||||
45
druntime/import/core/stdc/stdarg.d
Normal file
45
druntime/import/core/stdc/stdarg.d
Normal file
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.stdarg;
|
||||
|
||||
|
||||
alias void* va_list;
|
||||
|
||||
template va_start( T )
|
||||
{
|
||||
void va_start( out va_list ap, inout T parmn )
|
||||
{
|
||||
ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
|
||||
}
|
||||
}
|
||||
|
||||
template va_arg( T )
|
||||
{
|
||||
T va_arg( inout va_list ap )
|
||||
{
|
||||
T arg = *cast(T*) ap;
|
||||
ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
|
||||
return arg;
|
||||
}
|
||||
}
|
||||
|
||||
void va_end( va_list ap )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void va_copy( out va_list dest, va_list src )
|
||||
{
|
||||
dest = src;
|
||||
}
|
||||
28
druntime/import/core/stdc/stddef.d
Normal file
28
druntime/import/core/stdc/stddef.d
Normal file
@@ -0,0 +1,28 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.stddef;
|
||||
|
||||
extern (C):
|
||||
|
||||
//alias typeof(int.sizeof) size_t;
|
||||
//alias typeof(cast(void*)0 - cast(void*)0) ptrdiff_t;
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
alias wchar wchar_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias dchar wchar_t;
|
||||
}
|
||||
154
druntime/import/core/stdc/stdint.d
Normal file
154
druntime/import/core/stdc/stdint.d
Normal file
@@ -0,0 +1,154 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.stdint;
|
||||
|
||||
private import core.stdc.stddef; // for ptrdiff_t, size_t, wchar_t
|
||||
private import core.stdc.signal; // for sig_atomic_t
|
||||
private import core.stdc.wchar_; // for wint_t
|
||||
|
||||
private
|
||||
{
|
||||
template typify(T)
|
||||
{
|
||||
T typify( T val ) { return val; }
|
||||
}
|
||||
}
|
||||
|
||||
extern (C):
|
||||
|
||||
alias byte int8_t;
|
||||
alias short int16_t;
|
||||
alias int int32_t;
|
||||
alias long int64_t;
|
||||
//alias cent int128_t;
|
||||
|
||||
alias ubyte uint8_t;
|
||||
alias ushort uint16_t;
|
||||
alias uint uint32_t;
|
||||
alias ulong uint64_t;
|
||||
//alias ucent uint128_t;
|
||||
|
||||
alias byte int_least8_t;
|
||||
alias short int_least16_t;
|
||||
alias int int_least32_t;
|
||||
alias long int_least64_t;
|
||||
|
||||
alias ubyte uint_least8_t;
|
||||
alias ushort uint_least16_t;
|
||||
alias uint uint_least32_t;
|
||||
alias ulong uint_least64_t;
|
||||
|
||||
alias byte int_fast8_t;
|
||||
alias int int_fast16_t;
|
||||
alias int int_fast32_t;
|
||||
alias long int_fast64_t;
|
||||
|
||||
alias ubyte uint_fast8_t;
|
||||
alias uint uint_fast16_t;
|
||||
alias uint uint_fast32_t;
|
||||
alias ulong uint_fast64_t;
|
||||
|
||||
version( X86_64 )
|
||||
{
|
||||
alias long intptr_t;
|
||||
alias ulong uintptr_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias int intptr_t;
|
||||
alias uint uintptr_t;
|
||||
}
|
||||
|
||||
alias long intmax_t;
|
||||
alias ulong uintmax_t;
|
||||
|
||||
enum int8_t INT8_MIN = int8_t.min;
|
||||
enum int8_t INT8_MAX = int8_t.max;
|
||||
enum int16_t INT16_MIN = int16_t.min;
|
||||
enum int16_t INT16_MAX = int16_t.max;
|
||||
enum int32_t INT32_MIN = int32_t.min;
|
||||
enum int32_t INT32_MAX = int32_t.max;
|
||||
enum int64_t INT64_MIN = int64_t.min;
|
||||
enum int64_t INT64_MAX = int64_t.max;
|
||||
|
||||
enum uint8_t UINT8_MAX = uint8_t.max;
|
||||
enum uint16_t UINT16_MAX = uint16_t.max;
|
||||
enum uint32_t UINT32_MAX = uint32_t.max;
|
||||
enum uint64_t UINT64_MAX = uint64_t.max;
|
||||
|
||||
enum int_least8_t INT_LEAST8_MIN = int_least8_t.min;
|
||||
enum int_least8_t INT_LEAST8_MAX = int_least8_t.max;
|
||||
enum int_least16_t INT_LEAST16_MIN = int_least16_t.min;
|
||||
enum int_least16_t INT_LEAST16_MAX = int_least16_t.max;
|
||||
enum int_least32_t INT_LEAST32_MIN = int_least32_t.min;
|
||||
enum int_least32_t INT_LEAST32_MAX = int_least32_t.max;
|
||||
enum int_least64_t INT_LEAST64_MIN = int_least64_t.min;
|
||||
enum int_least64_t INT_LEAST64_MAX = int_least64_t.max;
|
||||
|
||||
enum uint_least8_t UINT_LEAST8_MAX = uint_least8_t.max;
|
||||
enum uint_least16_t UINT_LEAST16_MAX = uint_least16_t.max;
|
||||
enum uint_least32_t UINT_LEAST32_MAX = uint_least32_t.max;
|
||||
enum uint_least64_t UINT_LEAST64_MAX = uint_least64_t.max;
|
||||
|
||||
enum int_fast8_t INT_FAST8_MIN = int_fast8_t.min;
|
||||
enum int_fast8_t INT_FAST8_MAX = int_fast8_t.max;
|
||||
enum int_fast16_t INT_FAST16_MIN = int_fast16_t.min;
|
||||
enum int_fast16_t INT_FAST16_MAX = int_fast16_t.max;
|
||||
enum int_fast32_t INT_FAST32_MIN = int_fast32_t.min;
|
||||
enum int_fast32_t INT_FAST32_MAX = int_fast32_t.max;
|
||||
enum int_fast64_t INT_FAST64_MIN = int_fast64_t.min;
|
||||
enum int_fast64_t INT_FAST64_MAX = int_fast64_t.max;
|
||||
|
||||
enum uint_fast8_t UINT_FAST8_MAX = uint_fast8_t.max;
|
||||
enum uint_fast16_t UINT_FAST16_MAX = uint_fast16_t.max;
|
||||
enum uint_fast32_t UINT_FAST32_MAX = uint_fast32_t.max;
|
||||
enum uint_fast64_t UINT_FAST64_MAX = uint_fast64_t.max;
|
||||
|
||||
enum intptr_t INTPTR_MIN = intptr_t.min;
|
||||
enum intptr_t INTPTR_MAX = intptr_t.max;
|
||||
|
||||
enum uintptr_t UINTPTR_MIN = uintptr_t.min;
|
||||
enum uintptr_t UINTPTR_MAX = uintptr_t.max;
|
||||
|
||||
enum intmax_t INTMAX_MIN = intmax_t.min;
|
||||
enum intmax_t INTMAX_MAX = intmax_t.max;
|
||||
|
||||
enum uintmax_t UINTMAX_MAX = uintmax_t.max;
|
||||
|
||||
enum ptrdiff_t PTRDIFF_MIN = ptrdiff_t.min;
|
||||
enum ptrdiff_t PTRDIFF_MAX = ptrdiff_t.max;
|
||||
|
||||
enum sig_atomic_t SIG_ATOMIC_MIN = sig_atomic_t.min;
|
||||
enum sig_atomic_t SIG_ATOMIC_MAX = sig_atomic_t.max;
|
||||
|
||||
enum size_t SIZE_MAX = size_t.max;
|
||||
|
||||
enum wchar_t WCHAR_MIN = wchar_t.min;
|
||||
enum wchar_t WCHAR_MAX = wchar_t.max;
|
||||
|
||||
enum wint_t WINT_MIN = wint_t.min;
|
||||
enum wint_t WINT_MAX = wint_t.max;
|
||||
|
||||
alias typify!(int8_t) INT8_C;
|
||||
alias typify!(int16_t) INT16_C;
|
||||
alias typify!(int32_t) INT32_C;
|
||||
alias typify!(int64_t) INT64_C;
|
||||
|
||||
alias typify!(uint8_t) UINT8_C;
|
||||
alias typify!(uint16_t) UINT16_C;
|
||||
alias typify!(uint32_t) UINT32_C;
|
||||
alias typify!(uint64_t) UINT64_C;
|
||||
|
||||
alias typify!(intmax_t) INTMAX_C;
|
||||
alias typify!(uintmax_t) UINTMAX_C;
|
||||
411
druntime/import/core/stdc/stdio.d
Normal file
411
druntime/import/core/stdc/stdio.d
Normal file
@@ -0,0 +1,411 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.stdio;
|
||||
|
||||
private
|
||||
{
|
||||
import core.stdc.config;
|
||||
import core.stdc.stddef; // for size_t
|
||||
import core.stdc.stdarg; // for va_list
|
||||
}
|
||||
|
||||
extern (C):
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
enum
|
||||
{
|
||||
BUFSIZ = 0x4000,
|
||||
EOF = -1,
|
||||
FOPEN_MAX = 20,
|
||||
FILENAME_MAX = 256, // 255 plus NULL
|
||||
TMP_MAX = 32767,
|
||||
SYS_OPEN = 20, // non-standard
|
||||
}
|
||||
|
||||
enum int _NFILE = 60; // non-standard
|
||||
enum string _P_tmpdir = "\\"; // non-standard
|
||||
enum wstring _wP_tmpdir = "\\"; // non-standard
|
||||
enum int L_tmpnam = _P_tmpdir.length + 12;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
BUFSIZ = 8192,
|
||||
EOF = -1,
|
||||
FOPEN_MAX = 16,
|
||||
FILENAME_MAX = 4095,
|
||||
TMP_MAX = 238328,
|
||||
L_tmpnam = 20
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
BUFSIZ = 1024,
|
||||
EOF = -1,
|
||||
FOPEN_MAX = 20,
|
||||
FILENAME_MAX = 1024,
|
||||
TMP_MAX = 308915776,
|
||||
L_tmpnam = 1024,
|
||||
}
|
||||
|
||||
private
|
||||
{
|
||||
struct __sbuf
|
||||
{
|
||||
ubyte* _base;
|
||||
int _size;
|
||||
}
|
||||
|
||||
struct __sFILEX
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
else version ( FreeBSD )
|
||||
{
|
||||
enum
|
||||
{
|
||||
EOF = -1,
|
||||
FOPEN_MAX = 20,
|
||||
FILENAME_MAX = 1024,
|
||||
TMP_MAX = 308915776,
|
||||
L_tmpnam = 1024
|
||||
}
|
||||
|
||||
private
|
||||
{
|
||||
struct __sbuf
|
||||
{
|
||||
ubyte *_base;
|
||||
int _size;
|
||||
}
|
||||
struct __sFILEX
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SEEK_SET,
|
||||
SEEK_CUR,
|
||||
SEEK_END
|
||||
}
|
||||
|
||||
struct _iobuf
|
||||
{
|
||||
align (1):
|
||||
version( Windows )
|
||||
{
|
||||
char* _ptr;
|
||||
int _cnt;
|
||||
char* _base;
|
||||
int _flag;
|
||||
int _file;
|
||||
int _charbuf;
|
||||
int _bufsiz;
|
||||
int __tmpnum;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
char* _read_ptr;
|
||||
char* _read_end;
|
||||
char* _read_base;
|
||||
char* _write_base;
|
||||
char* _write_ptr;
|
||||
char* _write_end;
|
||||
char* _buf_base;
|
||||
char* _buf_end;
|
||||
char* _save_base;
|
||||
char* _backup_base;
|
||||
char* _save_end;
|
||||
void* _markers;
|
||||
_iobuf* _chain;
|
||||
int _fileno;
|
||||
int _blksize;
|
||||
int _old_offset;
|
||||
ushort _cur_column;
|
||||
byte _vtable_offset;
|
||||
char[1] _shortbuf;
|
||||
void* _lock;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
ubyte* _p;
|
||||
int _r;
|
||||
int _w;
|
||||
short _flags;
|
||||
short _file;
|
||||
__sbuf _bf;
|
||||
int _lbfsize;
|
||||
|
||||
int* function(void*) _close;
|
||||
int* function(void*, char*, int) _read;
|
||||
fpos_t* function(void*, fpos_t, int) _seek;
|
||||
int* function(void*, char *, int) _write;
|
||||
|
||||
__sbuf _ub;
|
||||
__sFILEX* _extra;
|
||||
int _ur;
|
||||
|
||||
ubyte[3] _ubuf;
|
||||
ubyte[1] _nbuf;
|
||||
|
||||
__sbuf _lb;
|
||||
|
||||
int _blksize;
|
||||
fpos_t _offset;
|
||||
}
|
||||
else version( FreeBSD )
|
||||
{
|
||||
ubyte* _p;
|
||||
int _r;
|
||||
int _w;
|
||||
short _flags;
|
||||
short _file;
|
||||
__sbuf _bf;
|
||||
int _lbfsize;
|
||||
|
||||
void* function() _cookie;
|
||||
int* function(void*) _close;
|
||||
int* function(void*, char*, int) _read;
|
||||
fpos_t* function(void*, fpos_t, int) _seek;
|
||||
int* function(void*, char *, int) _write;
|
||||
|
||||
__sbuf _ub;
|
||||
__sFILEX* _extra;
|
||||
int _ur;
|
||||
|
||||
ubyte[3] _ubuf;
|
||||
ubyte[1] _nbuf;
|
||||
|
||||
__sbuf _lb;
|
||||
|
||||
int _blksize;
|
||||
fpos_t _offset;
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
}
|
||||
|
||||
alias shared(_iobuf) FILE;
|
||||
|
||||
enum
|
||||
{
|
||||
_F_RDWR = 0x0003, // non-standard
|
||||
_F_READ = 0x0001, // non-standard
|
||||
_F_WRIT = 0x0002, // non-standard
|
||||
_F_BUF = 0x0004, // non-standard
|
||||
_F_LBUF = 0x0008, // non-standard
|
||||
_F_ERR = 0x0010, // non-standard
|
||||
_F_EOF = 0x0020, // non-standard
|
||||
_F_BIN = 0x0040, // non-standard
|
||||
_F_IN = 0x0080, // non-standard
|
||||
_F_OUT = 0x0100, // non-standard
|
||||
_F_TERM = 0x0200, // non-standard
|
||||
}
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
enum
|
||||
{
|
||||
_IOFBF = 0,
|
||||
_IOLBF = 0x40,
|
||||
_IONBF = 4,
|
||||
_IOREAD = 1, // non-standard
|
||||
_IOWRT = 2, // non-standard
|
||||
_IOMYBUF = 8, // non-standard
|
||||
_IOEOF = 0x10, // non-standard
|
||||
_IOERR = 0x20, // non-standard
|
||||
_IOSTRG = 0x40, // non-standard
|
||||
_IORW = 0x80, // non-standard
|
||||
_IOTRAN = 0x100, // non-standard
|
||||
_IOAPP = 0x200, // non-standard
|
||||
}
|
||||
|
||||
extern shared void function() _fcloseallp;
|
||||
|
||||
private extern shared FILE[_NFILE] _iob;
|
||||
|
||||
shared stdin = &_iob[0];
|
||||
shared stdout = &_iob[1];
|
||||
shared stderr = &_iob[2];
|
||||
shared stdaux = &_iob[3];
|
||||
shared stdprn = &_iob[4];
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
_IOFBF = 0,
|
||||
_IOLBF = 1,
|
||||
_IONBF = 2,
|
||||
}
|
||||
|
||||
extern shared FILE* stdin;
|
||||
extern shared FILE* stdout;
|
||||
extern shared FILE* stderr;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
_IOFBF = 0,
|
||||
_IOLBF = 1,
|
||||
_IONBF = 2,
|
||||
}
|
||||
|
||||
private extern shared FILE* __stdinp;
|
||||
private extern shared FILE* __stdoutp;
|
||||
private extern shared FILE* __stderrp;
|
||||
|
||||
alias __stdinp stdin;
|
||||
alias __stdoutp stdout;
|
||||
alias __stderrp stderr;
|
||||
}
|
||||
else version( FreeBSD )
|
||||
{
|
||||
private extern shared FILE[3] __sF;
|
||||
|
||||
shared stdin = &__sF[0];
|
||||
shared stdout = &__sF[1];
|
||||
shared stderr = &__sF[2];
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
alias int fpos_t;
|
||||
|
||||
int remove(in char* filename);
|
||||
int rename(in char* from, in char* to);
|
||||
|
||||
FILE* tmpfile();
|
||||
char* tmpnam(char* s);
|
||||
|
||||
int fclose(FILE* stream);
|
||||
int fflush(FILE* stream);
|
||||
FILE* fopen(in char* filename, in char* mode);
|
||||
FILE* freopen(in char* filename, in char* mode, FILE* stream);
|
||||
|
||||
void setbuf(FILE* stream, char* buf);
|
||||
int setvbuf(FILE* stream, char* buf, int mode, size_t size);
|
||||
|
||||
int fprintf(FILE* stream, in char* format, ...);
|
||||
int fscanf(FILE* stream, in char* format, ...);
|
||||
int sprintf(char* s, in char* format, ...);
|
||||
int sscanf(in char* s, in char* format, ...);
|
||||
int vfprintf(FILE* stream, in char* format, va_list arg);
|
||||
int vfscanf(FILE* stream, in char* format, va_list arg);
|
||||
int vsprintf(char* s, in char* format, va_list arg);
|
||||
int vsscanf(in char* s, in char* format, va_list arg);
|
||||
int vprintf(in char* format, va_list arg);
|
||||
int vscanf(in char* format, va_list arg);
|
||||
int printf(in char* format, ...);
|
||||
int scanf(in char* format, ...);
|
||||
|
||||
int fgetc(FILE* stream);
|
||||
int fputc(int c, FILE* stream);
|
||||
|
||||
char* fgets(char* s, int n, FILE* stream);
|
||||
int fputs(in char* s, FILE* stream);
|
||||
char* gets(char* s);
|
||||
int puts(in char* s);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
int getchar() { return getc(stdin); }
|
||||
int putchar(int c) { return putc(c,stdout); }
|
||||
int getc(FILE* stream) { return fgetc(stream); }
|
||||
int putc(int c, FILE* stream) { return fputc(c,stream); }
|
||||
}
|
||||
|
||||
int ungetc(int c, FILE* stream);
|
||||
|
||||
size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);
|
||||
size_t fwrite(in void* ptr, size_t size, size_t nmemb, FILE* stream);
|
||||
|
||||
int fgetpos(FILE* stream, fpos_t * pos);
|
||||
int fsetpos(FILE* stream, in fpos_t* pos);
|
||||
|
||||
int fseek(FILE* stream, c_long offset, int whence);
|
||||
c_long ftell(FILE* stream);
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
extern (D)
|
||||
{
|
||||
void rewind(FILE* stream) { fseek(stream,0L,SEEK_SET); stream._flag&=~_IOERR; }
|
||||
void clearerr(FILE* stream) { stream._flag &= ~(_IOERR|_IOEOF); }
|
||||
int feof(FILE* stream) { return stream._flag&_IOEOF; }
|
||||
int ferror(FILE* stream) { return stream._flag&_IOERR; }
|
||||
}
|
||||
int _snprintf(char* s, size_t n, in char* fmt, ...);
|
||||
alias _snprintf snprintf;
|
||||
|
||||
int _vsnprintf(char* s, size_t n, in char* format, va_list arg);
|
||||
alias _vsnprintf vsnprintf;
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
void rewind(FILE* stream);
|
||||
void clearerr(FILE* stream);
|
||||
int feof(FILE* stream);
|
||||
int ferror(FILE* stream);
|
||||
int fileno(FILE *);
|
||||
|
||||
int snprintf(char* s, size_t n, in char* format, ...);
|
||||
int vsnprintf(char* s, size_t n, in char* format, va_list arg);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
void rewind(FILE*);
|
||||
void clearerr(FILE*);
|
||||
int feof(FILE*);
|
||||
int ferror(FILE*);
|
||||
int fileno(FILE*);
|
||||
|
||||
int snprintf(char* s, size_t n, in char* format, ...);
|
||||
int vsnprintf(char* s, size_t n, in char* format, va_list arg);
|
||||
}
|
||||
else version( FreeBSD )
|
||||
{
|
||||
void rewind(FILE*);
|
||||
void clearerr(FILE*);
|
||||
int feof(FILE*);
|
||||
int ferror(FILE*);
|
||||
int fileno(FILE*);
|
||||
|
||||
int snprintf(char* s, size_t n, in char* format, ...);
|
||||
int vsnprintf(char* s, size_t n, in char* format, va_list arg);
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
void perror(in char* s);
|
||||
93
druntime/import/core/stdc/stdlib.d
Normal file
93
druntime/import/core/stdc/stdlib.d
Normal file
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.stdlib;
|
||||
|
||||
private import core.stdc.config;
|
||||
public import core.stdc.stddef; // for size_t, wchar_t
|
||||
|
||||
extern (C):
|
||||
|
||||
struct div_t
|
||||
{
|
||||
int quot,
|
||||
rem;
|
||||
}
|
||||
|
||||
struct ldiv_t
|
||||
{
|
||||
int quot,
|
||||
rem;
|
||||
}
|
||||
|
||||
struct lldiv_t
|
||||
{
|
||||
long quot,
|
||||
rem;
|
||||
}
|
||||
|
||||
enum EXIT_SUCCESS = 0;
|
||||
enum EXIT_FAILURE = 1;
|
||||
enum RAND_MAX = 32767;
|
||||
enum MB_CUR_MAX = 1;
|
||||
|
||||
double atof(in char* nptr);
|
||||
int atoi(in char* nptr);
|
||||
c_long atol(in char* nptr);
|
||||
long atoll(in char* nptr);
|
||||
|
||||
double strtod(in char* nptr, char** endptr);
|
||||
float strtof(in char* nptr, char** endptr);
|
||||
real strtold(in char* nptr, char** endptr);
|
||||
c_long strtol(in char* nptr, char** endptr, int base);
|
||||
long strtoll(in char* nptr, char** endptr, int base);
|
||||
c_ulong strtoul(in char* nptr, char** endptr, int base);
|
||||
ulong strtoull(in char* nptr, char** endptr, int base);
|
||||
|
||||
int rand();
|
||||
void srand(uint seed);
|
||||
|
||||
void* malloc(size_t size);
|
||||
void* calloc(size_t nmemb, size_t size);
|
||||
void* realloc(void* ptr, size_t size);
|
||||
void free(void* ptr);
|
||||
|
||||
void abort();
|
||||
void exit(int status);
|
||||
int atexit(void function() func);
|
||||
void _Exit(int status);
|
||||
|
||||
char* getenv(in char* name);
|
||||
int system(in char* string);
|
||||
|
||||
void* bsearch(in void* key, in void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
|
||||
void qsort(void* base, size_t nmemb, size_t size, int function(in void*, in void*) compar);
|
||||
|
||||
int abs(int j);
|
||||
c_long labs(c_long j);
|
||||
long llabs(long j);
|
||||
|
||||
div_t div(int numer, int denom);
|
||||
ldiv_t ldiv(c_long numer, c_long denom);
|
||||
lldiv_t lldiv(long numer, long denom);
|
||||
|
||||
int mblen(in char* s, size_t n);
|
||||
int mbtowc(wchar_t* pwc, in char* s, size_t n);
|
||||
int wctomb(char*s, wchar_t wc);
|
||||
size_t mbstowcs(wchar_t* pwcs, in char* s, size_t n);
|
||||
size_t wcstombs(char* s, in wchar_t* pwcs, size_t n);
|
||||
|
||||
version( DigitalMars )
|
||||
{
|
||||
void* alloca(size_t size); // non-standard
|
||||
}
|
||||
42
druntime/import/core/stdc/string.d
Normal file
42
druntime/import/core/stdc/string.d
Normal file
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.string;
|
||||
|
||||
private import core.stdc.stddef; // for size_t
|
||||
|
||||
extern (C):
|
||||
|
||||
void* memchr(in void* s, int c, size_t n);
|
||||
int memcmp(in void* s1, in void* s2, size_t n);
|
||||
void* memcpy(void* s1, in void* s2, size_t n);
|
||||
void* memmove(void* s1, in void* s2, size_t n);
|
||||
void* memset(void* s, int c, size_t n);
|
||||
|
||||
char* strcpy(char* s1, in char* s2);
|
||||
char* strncpy(char* s1, in char* s2, size_t n);
|
||||
char* strcat(char* s1, in char* s2);
|
||||
char* strncat(char* s1, in char* s2, size_t n);
|
||||
int strcmp(in char* s1, in char* s2);
|
||||
int strcoll(in char* s1, in char* s2);
|
||||
int strncmp(in char* s1, in char* s2, size_t n);
|
||||
size_t strxfrm(char* s1, in char* s2, size_t n);
|
||||
char* strchr(in char* s, int c);
|
||||
size_t strcspn(in char* s1, in char* s2);
|
||||
char* strpbrk(in char* s1, in char* s2);
|
||||
char* strrchr(in char* s, int c);
|
||||
size_t strspn(in char* s1, in char* s2);
|
||||
char* strstr(in char* s1, in char* s2);
|
||||
char* strtok(char* s1, in char* s2);
|
||||
char* strerror(int errnum);
|
||||
size_t strlen(in char* s);
|
||||
657
druntime/import/core/stdc/tgmath.d
Normal file
657
druntime/import/core/stdc/tgmath.d
Normal file
@@ -0,0 +1,657 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.tgmath;
|
||||
|
||||
private import core.stdc.config;
|
||||
private static import core.stdc.math;
|
||||
private static import core.stdc.complex;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( freebsd )
|
||||
{
|
||||
alias core.stdc.math.acos acos;
|
||||
alias core.stdc.math.acosf acos;
|
||||
alias core.stdc.math.acosl acos;
|
||||
|
||||
alias core.stdc.complex.cacos acos;
|
||||
alias core.stdc.complex.cacosf acos;
|
||||
alias core.stdc.complex.cacosl acos;
|
||||
|
||||
alias core.stdc.math.asin asin;
|
||||
alias core.stdc.math.asinf asin;
|
||||
alias core.stdc.math.asinl asin;
|
||||
|
||||
alias core.stdc.complex.casin asin;
|
||||
alias core.stdc.complex.casinf asin;
|
||||
alias core.stdc.complex.casinl asin;
|
||||
|
||||
alias core.stdc.math.atan atan;
|
||||
alias core.stdc.math.atanf atan;
|
||||
alias core.stdc.math.atanl atan;
|
||||
|
||||
alias core.stdc.complex.catan atan;
|
||||
alias core.stdc.complex.catanf atan;
|
||||
alias core.stdc.complex.catanl atan;
|
||||
|
||||
alias core.stdc.math.atan2 atan2;
|
||||
alias core.stdc.math.atan2f atan2;
|
||||
alias core.stdc.math.atan2l atan2;
|
||||
|
||||
alias core.stdc.math.cos cos;
|
||||
alias core.stdc.math.cosf cos;
|
||||
alias core.stdc.math.cosl cos;
|
||||
|
||||
alias core.stdc.complex.ccos cos;
|
||||
alias core.stdc.complex.ccosf cos;
|
||||
alias core.stdc.complex.ccosl cos;
|
||||
|
||||
alias core.stdc.math.sin sin;
|
||||
alias core.stdc.math.sinf sin;
|
||||
alias core.stdc.math.sinl sin;
|
||||
|
||||
alias core.stdc.complex.csin csin;
|
||||
alias core.stdc.complex.csinf csin;
|
||||
alias core.stdc.complex.csinl csin;
|
||||
|
||||
alias core.stdc.math.tan tan;
|
||||
alias core.stdc.math.tanf tan;
|
||||
alias core.stdc.math.tanl tan;
|
||||
|
||||
alias core.stdc.complex.ctan tan;
|
||||
alias core.stdc.complex.ctanf tan;
|
||||
alias core.stdc.complex.ctanl tan;
|
||||
|
||||
alias core.stdc.math.acosh acosh;
|
||||
alias core.stdc.math.acoshf acosh;
|
||||
alias core.stdc.math.acoshl acosh;
|
||||
|
||||
alias core.stdc.complex.cacosh acosh;
|
||||
alias core.stdc.complex.cacoshf acosh;
|
||||
alias core.stdc.complex.cacoshl acosh;
|
||||
|
||||
alias core.stdc.math.asinh asinh;
|
||||
alias core.stdc.math.asinhf asinh;
|
||||
alias core.stdc.math.asinhl asinh;
|
||||
|
||||
alias core.stdc.complex.casinh asinh;
|
||||
alias core.stdc.complex.casinhf asinh;
|
||||
alias core.stdc.complex.casinhl asinh;
|
||||
|
||||
alias core.stdc.math.atanh atanh;
|
||||
alias core.stdc.math.atanhf atanh;
|
||||
alias core.stdc.math.atanhl atanh;
|
||||
|
||||
alias core.stdc.complex.catanh atanh;
|
||||
alias core.stdc.complex.catanhf atanh;
|
||||
alias core.stdc.complex.catanhl atanh;
|
||||
|
||||
alias core.stdc.math.cosh cosh;
|
||||
alias core.stdc.math.coshf cosh;
|
||||
alias core.stdc.math.coshl cosh;
|
||||
|
||||
alias core.stdc.complex.ccosh cosh;
|
||||
alias core.stdc.complex.ccoshf cosh;
|
||||
alias core.stdc.complex.ccoshl cosh;
|
||||
|
||||
alias core.stdc.math.sinh sinh;
|
||||
alias core.stdc.math.sinhf sinh;
|
||||
alias core.stdc.math.sinhl sinh;
|
||||
|
||||
alias core.stdc.complex.csinh sinh;
|
||||
alias core.stdc.complex.csinhf sinh;
|
||||
alias core.stdc.complex.csinhl sinh;
|
||||
|
||||
alias core.stdc.math.tanh tanh;
|
||||
alias core.stdc.math.tanhf tanh;
|
||||
alias core.stdc.math.tanhl tanh;
|
||||
|
||||
alias core.stdc.complex.ctanh tanh;
|
||||
alias core.stdc.complex.ctanhf tanh;
|
||||
alias core.stdc.complex.ctanhl tanh;
|
||||
|
||||
alias core.stdc.math.exp exp;
|
||||
alias core.stdc.math.expf exp;
|
||||
alias core.stdc.math.expl exp;
|
||||
|
||||
alias core.stdc.complex.cexp exp;
|
||||
alias core.stdc.complex.cexpf exp;
|
||||
alias core.stdc.complex.cexpl exp;
|
||||
|
||||
alias core.stdc.math.exp2 exp2;
|
||||
alias core.stdc.math.exp2f exp2;
|
||||
alias core.stdc.math.exp2l exp2;
|
||||
|
||||
alias core.stdc.math.expm1 expm1;
|
||||
alias core.stdc.math.expm1f expm1;
|
||||
alias core.stdc.math.expm1l expm1;
|
||||
|
||||
alias core.stdc.math.frexp frexp;
|
||||
alias core.stdc.math.frexpf frexp;
|
||||
alias core.stdc.math.frexpl frexp;
|
||||
|
||||
alias core.stdc.math.ilogb ilogb;
|
||||
alias core.stdc.math.ilogbf ilogb;
|
||||
alias core.stdc.math.ilogbl ilogb;
|
||||
|
||||
alias core.stdc.math.ldexp ldexp;
|
||||
alias core.stdc.math.ldexpf ldexp;
|
||||
alias core.stdc.math.ldexpl ldexp;
|
||||
|
||||
alias core.stdc.math.log log;
|
||||
alias core.stdc.math.logf log;
|
||||
alias core.stdc.math.logl log;
|
||||
|
||||
alias core.stdc.complex.clog log;
|
||||
alias core.stdc.complex.clogf log;
|
||||
alias core.stdc.complex.clogl log;
|
||||
|
||||
alias core.stdc.math.log10 log10;
|
||||
alias core.stdc.math.log10f log10;
|
||||
alias core.stdc.math.log10l log10;
|
||||
|
||||
alias core.stdc.math.log1p log1p;
|
||||
alias core.stdc.math.log1pf log1p;
|
||||
alias core.stdc.math.log1pl log1p;
|
||||
|
||||
alias core.stdc.math.log2 log1p;
|
||||
alias core.stdc.math.log2f log1p;
|
||||
alias core.stdc.math.log2l log1p;
|
||||
|
||||
alias core.stdc.math.logb log1p;
|
||||
alias core.stdc.math.logbf log1p;
|
||||
alias core.stdc.math.logbl log1p;
|
||||
|
||||
alias core.stdc.math.modf modf;
|
||||
alias core.stdc.math.modff modf;
|
||||
// alias core.stdc.math.modfl modf;
|
||||
|
||||
alias core.stdc.math.scalbn scalbn;
|
||||
alias core.stdc.math.scalbnf scalbn;
|
||||
alias core.stdc.math.scalbnl scalbn;
|
||||
|
||||
alias core.stdc.math.scalbln scalbln;
|
||||
alias core.stdc.math.scalblnf scalbln;
|
||||
alias core.stdc.math.scalblnl scalbln;
|
||||
|
||||
alias core.stdc.math.cbrt cbrt;
|
||||
alias core.stdc.math.cbrtf cbrt;
|
||||
alias core.stdc.math.cbrtl cbrt;
|
||||
|
||||
alias core.stdc.math.fabs fabs;
|
||||
alias core.stdc.math.fabsf fabs;
|
||||
alias core.stdc.math.fabsl fabs;
|
||||
|
||||
alias core.stdc.complex.cabs fabs;
|
||||
alias core.stdc.complex.cabsf fabs;
|
||||
alias core.stdc.complex.cabsl fabs;
|
||||
|
||||
alias core.stdc.math.hypot hypot;
|
||||
alias core.stdc.math.hypotf hypot;
|
||||
alias core.stdc.math.hypotl hypot;
|
||||
|
||||
alias core.stdc.math.pow pow;
|
||||
alias core.stdc.math.powf pow;
|
||||
alias core.stdc.math.powl pow;
|
||||
|
||||
alias core.stdc.complex.cpow pow;
|
||||
alias core.stdc.complex.cpowf pow;
|
||||
alias core.stdc.complex.cpowl pow;
|
||||
|
||||
alias core.stdc.math.sqrt sqrt;
|
||||
alias core.stdc.math.sqrtf sqrt;
|
||||
alias core.stdc.math.sqrtl sqrt;
|
||||
|
||||
alias core.stdc.complex.csqrt sqrt;
|
||||
alias core.stdc.complex.csqrtf sqrt;
|
||||
alias core.stdc.complex.csqrtl sqrt;
|
||||
|
||||
alias core.stdc.math.erf erf;
|
||||
alias core.stdc.math.erff erf;
|
||||
alias core.stdc.math.erfl erf;
|
||||
|
||||
alias core.stdc.math.erfc erfc;
|
||||
alias core.stdc.math.erfcf erfc;
|
||||
alias core.stdc.math.erfcl erfc;
|
||||
|
||||
alias core.stdc.math.lgamma lgamma;
|
||||
alias core.stdc.math.lgammaf lgamma;
|
||||
alias core.stdc.math.lgammal lgamma;
|
||||
|
||||
alias core.stdc.math.tgamma tgamma;
|
||||
alias core.stdc.math.tgammaf tgamma;
|
||||
alias core.stdc.math.tgammal tgamma;
|
||||
|
||||
alias core.stdc.math.ceil ceil;
|
||||
alias core.stdc.math.ceilf ceil;
|
||||
alias core.stdc.math.ceill ceil;
|
||||
|
||||
alias core.stdc.math.floor floor;
|
||||
alias core.stdc.math.floorf floor;
|
||||
alias core.stdc.math.floorl floor;
|
||||
|
||||
alias core.stdc.math.nearbyint nearbyint;
|
||||
alias core.stdc.math.nearbyintf nearbyint;
|
||||
alias core.stdc.math.nearbyintl nearbyint;
|
||||
|
||||
alias core.stdc.math.rint rint;
|
||||
alias core.stdc.math.rintf rint;
|
||||
alias core.stdc.math.rintl rint;
|
||||
|
||||
alias core.stdc.math.lrint lrint;
|
||||
alias core.stdc.math.lrintf lrint;
|
||||
alias core.stdc.math.lrintl lrint;
|
||||
|
||||
alias core.stdc.math.llrint llrint;
|
||||
alias core.stdc.math.llrintf llrint;
|
||||
alias core.stdc.math.llrintl llrint;
|
||||
|
||||
alias core.stdc.math.round round;
|
||||
alias core.stdc.math.roundf round;
|
||||
alias core.stdc.math.roundl round;
|
||||
|
||||
alias core.stdc.math.lround lround;
|
||||
alias core.stdc.math.lroundf lround;
|
||||
alias core.stdc.math.lroundl lround;
|
||||
|
||||
alias core.stdc.math.llround llround;
|
||||
alias core.stdc.math.llroundf llround;
|
||||
alias core.stdc.math.llroundl llround;
|
||||
|
||||
alias core.stdc.math.trunc trunc;
|
||||
alias core.stdc.math.truncf trunc;
|
||||
alias core.stdc.math.truncl trunc;
|
||||
|
||||
alias core.stdc.math.fmod fmod;
|
||||
alias core.stdc.math.fmodf fmod;
|
||||
alias core.stdc.math.fmodl fmod;
|
||||
|
||||
alias core.stdc.math.remainder remainder;
|
||||
alias core.stdc.math.remainderf remainder;
|
||||
alias core.stdc.math.remainderl remainder;
|
||||
|
||||
alias core.stdc.math.remquo remquo;
|
||||
alias core.stdc.math.remquof remquo;
|
||||
alias core.stdc.math.remquol remquo;
|
||||
|
||||
alias core.stdc.math.copysign copysign;
|
||||
alias core.stdc.math.copysignf copysign;
|
||||
alias core.stdc.math.copysignl copysign;
|
||||
|
||||
// alias core.stdc.math.nan nan;
|
||||
// alias core.stdc.math.nanf nan;
|
||||
// alias core.stdc.math.nanl nan;
|
||||
|
||||
alias core.stdc.math.nextafter nextafter;
|
||||
alias core.stdc.math.nextafterf nextafter;
|
||||
alias core.stdc.math.nextafterl nextafter;
|
||||
|
||||
alias core.stdc.math.nexttoward nexttoward;
|
||||
alias core.stdc.math.nexttowardf nexttoward;
|
||||
alias core.stdc.math.nexttowardl nexttoward;
|
||||
|
||||
alias core.stdc.math.fdim fdim;
|
||||
alias core.stdc.math.fdimf fdim;
|
||||
alias core.stdc.math.fdiml fdim;
|
||||
|
||||
alias core.stdc.math.fmax fmax;
|
||||
alias core.stdc.math.fmaxf fmax;
|
||||
alias core.stdc.math.fmaxl fmax;
|
||||
|
||||
alias core.stdc.math.fmin fmin;
|
||||
alias core.stdc.math.fmin fmin;
|
||||
alias core.stdc.math.fminl fmin;
|
||||
|
||||
alias core.stdc.math.fma fma;
|
||||
alias core.stdc.math.fmaf fma;
|
||||
alias core.stdc.math.fmal fma;
|
||||
|
||||
alias core.stdc.complex.carg carg;
|
||||
alias core.stdc.complex.cargf carg;
|
||||
alias core.stdc.complex.cargl carg;
|
||||
|
||||
alias core.stdc.complex.cimag cimag;
|
||||
alias core.stdc.complex.cimagf cimag;
|
||||
alias core.stdc.complex.cimagl cimag;
|
||||
|
||||
alias core.stdc.complex.conj conj;
|
||||
alias core.stdc.complex.conjf conj;
|
||||
alias core.stdc.complex.conjl conj;
|
||||
|
||||
alias core.stdc.complex.cproj cproj;
|
||||
alias core.stdc.complex.cprojf cproj;
|
||||
alias core.stdc.complex.cprojl cproj;
|
||||
|
||||
// alias core.stdc.complex.creal creal;
|
||||
// alias core.stdc.complex.crealf creal;
|
||||
// alias core.stdc.complex.creall creal;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias core.stdc.math.acos acos;
|
||||
alias core.stdc.math.acosf acos;
|
||||
alias core.stdc.math.acosl acos;
|
||||
|
||||
alias core.stdc.complex.cacos acos;
|
||||
alias core.stdc.complex.cacosf acos;
|
||||
alias core.stdc.complex.cacosl acos;
|
||||
|
||||
alias core.stdc.math.asin asin;
|
||||
alias core.stdc.math.asinf asin;
|
||||
alias core.stdc.math.asinl asin;
|
||||
|
||||
alias core.stdc.complex.casin asin;
|
||||
alias core.stdc.complex.casinf asin;
|
||||
alias core.stdc.complex.casinl asin;
|
||||
|
||||
alias core.stdc.math.atan atan;
|
||||
alias core.stdc.math.atanf atan;
|
||||
alias core.stdc.math.atanl atan;
|
||||
|
||||
alias core.stdc.complex.catan atan;
|
||||
alias core.stdc.complex.catanf atan;
|
||||
alias core.stdc.complex.catanl atan;
|
||||
|
||||
alias core.stdc.math.atan2 atan2;
|
||||
alias core.stdc.math.atan2f atan2;
|
||||
alias core.stdc.math.atan2l atan2;
|
||||
|
||||
alias core.stdc.math.cos cos;
|
||||
alias core.stdc.math.cosf cos;
|
||||
alias core.stdc.math.cosl cos;
|
||||
|
||||
alias core.stdc.complex.ccos cos;
|
||||
alias core.stdc.complex.ccosf cos;
|
||||
alias core.stdc.complex.ccosl cos;
|
||||
|
||||
alias core.stdc.math.sin sin;
|
||||
alias core.stdc.math.sinf sin;
|
||||
alias core.stdc.math.sinl sin;
|
||||
|
||||
alias core.stdc.complex.csin csin;
|
||||
alias core.stdc.complex.csinf csin;
|
||||
alias core.stdc.complex.csinl csin;
|
||||
|
||||
alias core.stdc.math.tan tan;
|
||||
alias core.stdc.math.tanf tan;
|
||||
alias core.stdc.math.tanl tan;
|
||||
|
||||
alias core.stdc.complex.ctan tan;
|
||||
alias core.stdc.complex.ctanf tan;
|
||||
alias core.stdc.complex.ctanl tan;
|
||||
|
||||
alias core.stdc.math.acosh acosh;
|
||||
alias core.stdc.math.acoshf acosh;
|
||||
alias core.stdc.math.acoshl acosh;
|
||||
|
||||
alias core.stdc.complex.cacosh acosh;
|
||||
alias core.stdc.complex.cacoshf acosh;
|
||||
alias core.stdc.complex.cacoshl acosh;
|
||||
|
||||
alias core.stdc.math.asinh asinh;
|
||||
alias core.stdc.math.asinhf asinh;
|
||||
alias core.stdc.math.asinhl asinh;
|
||||
|
||||
alias core.stdc.complex.casinh asinh;
|
||||
alias core.stdc.complex.casinhf asinh;
|
||||
alias core.stdc.complex.casinhl asinh;
|
||||
|
||||
alias core.stdc.math.atanh atanh;
|
||||
alias core.stdc.math.atanhf atanh;
|
||||
alias core.stdc.math.atanhl atanh;
|
||||
|
||||
alias core.stdc.complex.catanh atanh;
|
||||
alias core.stdc.complex.catanhf atanh;
|
||||
alias core.stdc.complex.catanhl atanh;
|
||||
|
||||
alias core.stdc.math.cosh cosh;
|
||||
alias core.stdc.math.coshf cosh;
|
||||
alias core.stdc.math.coshl cosh;
|
||||
|
||||
alias core.stdc.complex.ccosh cosh;
|
||||
alias core.stdc.complex.ccoshf cosh;
|
||||
alias core.stdc.complex.ccoshl cosh;
|
||||
|
||||
alias core.stdc.math.sinh sinh;
|
||||
alias core.stdc.math.sinhf sinh;
|
||||
alias core.stdc.math.sinhl sinh;
|
||||
|
||||
alias core.stdc.complex.csinh sinh;
|
||||
alias core.stdc.complex.csinhf sinh;
|
||||
alias core.stdc.complex.csinhl sinh;
|
||||
|
||||
alias core.stdc.math.tanh tanh;
|
||||
alias core.stdc.math.tanhf tanh;
|
||||
alias core.stdc.math.tanhl tanh;
|
||||
|
||||
alias core.stdc.complex.ctanh tanh;
|
||||
alias core.stdc.complex.ctanhf tanh;
|
||||
alias core.stdc.complex.ctanhl tanh;
|
||||
|
||||
alias core.stdc.math.exp exp;
|
||||
alias core.stdc.math.expf exp;
|
||||
alias core.stdc.math.expl exp;
|
||||
|
||||
alias core.stdc.complex.cexp exp;
|
||||
alias core.stdc.complex.cexpf exp;
|
||||
alias core.stdc.complex.cexpl exp;
|
||||
|
||||
alias core.stdc.math.exp2 exp2;
|
||||
alias core.stdc.math.exp2f exp2;
|
||||
alias core.stdc.math.exp2l exp2;
|
||||
|
||||
alias core.stdc.math.expm1 expm1;
|
||||
alias core.stdc.math.expm1f expm1;
|
||||
alias core.stdc.math.expm1l expm1;
|
||||
|
||||
alias core.stdc.math.frexp frexp;
|
||||
alias core.stdc.math.frexpf frexp;
|
||||
alias core.stdc.math.frexpl frexp;
|
||||
|
||||
alias core.stdc.math.ilogb ilogb;
|
||||
alias core.stdc.math.ilogbf ilogb;
|
||||
alias core.stdc.math.ilogbl ilogb;
|
||||
|
||||
alias core.stdc.math.ldexp ldexp;
|
||||
alias core.stdc.math.ldexpf ldexp;
|
||||
alias core.stdc.math.ldexpl ldexp;
|
||||
|
||||
alias core.stdc.math.log log;
|
||||
alias core.stdc.math.logf log;
|
||||
alias core.stdc.math.logl log;
|
||||
|
||||
alias core.stdc.complex.clog log;
|
||||
alias core.stdc.complex.clogf log;
|
||||
alias core.stdc.complex.clogl log;
|
||||
|
||||
alias core.stdc.math.log10 log10;
|
||||
alias core.stdc.math.log10f log10;
|
||||
alias core.stdc.math.log10l log10;
|
||||
|
||||
alias core.stdc.math.log1p log1p;
|
||||
alias core.stdc.math.log1pf log1p;
|
||||
alias core.stdc.math.log1pl log1p;
|
||||
|
||||
alias core.stdc.math.log2 log1p;
|
||||
alias core.stdc.math.log2f log1p;
|
||||
alias core.stdc.math.log2l log1p;
|
||||
|
||||
alias core.stdc.math.logb log1p;
|
||||
alias core.stdc.math.logbf log1p;
|
||||
alias core.stdc.math.logbl log1p;
|
||||
|
||||
alias core.stdc.math.modf modf;
|
||||
alias core.stdc.math.modff modf;
|
||||
alias core.stdc.math.modfl modf;
|
||||
|
||||
alias core.stdc.math.scalbn scalbn;
|
||||
alias core.stdc.math.scalbnf scalbn;
|
||||
alias core.stdc.math.scalbnl scalbn;
|
||||
|
||||
alias core.stdc.math.scalbln scalbln;
|
||||
alias core.stdc.math.scalblnf scalbln;
|
||||
alias core.stdc.math.scalblnl scalbln;
|
||||
|
||||
alias core.stdc.math.cbrt cbrt;
|
||||
alias core.stdc.math.cbrtf cbrt;
|
||||
alias core.stdc.math.cbrtl cbrt;
|
||||
|
||||
alias core.stdc.math.fabs fabs;
|
||||
alias core.stdc.math.fabsf fabs;
|
||||
alias core.stdc.math.fabsl fabs;
|
||||
|
||||
alias core.stdc.complex.cabs fabs;
|
||||
alias core.stdc.complex.cabsf fabs;
|
||||
alias core.stdc.complex.cabsl fabs;
|
||||
|
||||
alias core.stdc.math.hypot hypot;
|
||||
alias core.stdc.math.hypotf hypot;
|
||||
alias core.stdc.math.hypotl hypot;
|
||||
|
||||
alias core.stdc.math.pow pow;
|
||||
alias core.stdc.math.powf pow;
|
||||
alias core.stdc.math.powl pow;
|
||||
|
||||
alias core.stdc.complex.cpow pow;
|
||||
alias core.stdc.complex.cpowf pow;
|
||||
alias core.stdc.complex.cpowl pow;
|
||||
|
||||
alias core.stdc.math.sqrt sqrt;
|
||||
alias core.stdc.math.sqrtf sqrt;
|
||||
alias core.stdc.math.sqrtl sqrt;
|
||||
|
||||
alias core.stdc.complex.csqrt sqrt;
|
||||
alias core.stdc.complex.csqrtf sqrt;
|
||||
alias core.stdc.complex.csqrtl sqrt;
|
||||
|
||||
alias core.stdc.math.erf erf;
|
||||
alias core.stdc.math.erff erf;
|
||||
alias core.stdc.math.erfl erf;
|
||||
|
||||
alias core.stdc.math.erfc erfc;
|
||||
alias core.stdc.math.erfcf erfc;
|
||||
alias core.stdc.math.erfcl erfc;
|
||||
|
||||
alias core.stdc.math.lgamma lgamma;
|
||||
alias core.stdc.math.lgammaf lgamma;
|
||||
alias core.stdc.math.lgammal lgamma;
|
||||
|
||||
alias core.stdc.math.tgamma tgamma;
|
||||
alias core.stdc.math.tgammaf tgamma;
|
||||
alias core.stdc.math.tgammal tgamma;
|
||||
|
||||
alias core.stdc.math.ceil ceil;
|
||||
alias core.stdc.math.ceilf ceil;
|
||||
alias core.stdc.math.ceill ceil;
|
||||
|
||||
alias core.stdc.math.floor floor;
|
||||
alias core.stdc.math.floorf floor;
|
||||
alias core.stdc.math.floorl floor;
|
||||
|
||||
alias core.stdc.math.nearbyint nearbyint;
|
||||
alias core.stdc.math.nearbyintf nearbyint;
|
||||
alias core.stdc.math.nearbyintl nearbyint;
|
||||
|
||||
alias core.stdc.math.rint rint;
|
||||
alias core.stdc.math.rintf rint;
|
||||
alias core.stdc.math.rintl rint;
|
||||
|
||||
alias core.stdc.math.lrint lrint;
|
||||
alias core.stdc.math.lrintf lrint;
|
||||
alias core.stdc.math.lrintl lrint;
|
||||
|
||||
alias core.stdc.math.llrint llrint;
|
||||
alias core.stdc.math.llrintf llrint;
|
||||
alias core.stdc.math.llrintl llrint;
|
||||
|
||||
alias core.stdc.math.round round;
|
||||
alias core.stdc.math.roundf round;
|
||||
alias core.stdc.math.roundl round;
|
||||
|
||||
alias core.stdc.math.lround lround;
|
||||
alias core.stdc.math.lroundf lround;
|
||||
alias core.stdc.math.lroundl lround;
|
||||
|
||||
alias core.stdc.math.llround llround;
|
||||
alias core.stdc.math.llroundf llround;
|
||||
alias core.stdc.math.llroundl llround;
|
||||
|
||||
alias core.stdc.math.trunc trunc;
|
||||
alias core.stdc.math.truncf trunc;
|
||||
alias core.stdc.math.truncl trunc;
|
||||
|
||||
alias core.stdc.math.fmod fmod;
|
||||
alias core.stdc.math.fmodf fmod;
|
||||
alias core.stdc.math.fmodl fmod;
|
||||
|
||||
alias core.stdc.math.remainder remainder;
|
||||
alias core.stdc.math.remainderf remainder;
|
||||
alias core.stdc.math.remainderl remainder;
|
||||
|
||||
alias core.stdc.math.remquo remquo;
|
||||
alias core.stdc.math.remquof remquo;
|
||||
alias core.stdc.math.remquol remquo;
|
||||
|
||||
alias core.stdc.math.copysign copysign;
|
||||
alias core.stdc.math.copysignf copysign;
|
||||
alias core.stdc.math.copysignl copysign;
|
||||
|
||||
alias core.stdc.math.nan nan;
|
||||
alias core.stdc.math.nanf nan;
|
||||
alias core.stdc.math.nanl nan;
|
||||
|
||||
alias core.stdc.math.nextafter nextafter;
|
||||
alias core.stdc.math.nextafterf nextafter;
|
||||
alias core.stdc.math.nextafterl nextafter;
|
||||
|
||||
alias core.stdc.math.nexttoward nexttoward;
|
||||
alias core.stdc.math.nexttowardf nexttoward;
|
||||
alias core.stdc.math.nexttowardl nexttoward;
|
||||
|
||||
alias core.stdc.math.fdim fdim;
|
||||
alias core.stdc.math.fdimf fdim;
|
||||
alias core.stdc.math.fdiml fdim;
|
||||
|
||||
alias core.stdc.math.fmax fmax;
|
||||
alias core.stdc.math.fmaxf fmax;
|
||||
alias core.stdc.math.fmaxl fmax;
|
||||
|
||||
alias core.stdc.math.fmin fmin;
|
||||
alias core.stdc.math.fmin fmin;
|
||||
alias core.stdc.math.fminl fmin;
|
||||
|
||||
alias core.stdc.math.fma fma;
|
||||
alias core.stdc.math.fmaf fma;
|
||||
alias core.stdc.math.fmal fma;
|
||||
|
||||
alias core.stdc.complex.carg carg;
|
||||
alias core.stdc.complex.cargf carg;
|
||||
alias core.stdc.complex.cargl carg;
|
||||
|
||||
alias core.stdc.complex.cimag cimag;
|
||||
alias core.stdc.complex.cimagf cimag;
|
||||
alias core.stdc.complex.cimagl cimag;
|
||||
|
||||
alias core.stdc.complex.conj conj;
|
||||
alias core.stdc.complex.conjf conj;
|
||||
alias core.stdc.complex.conjl conj;
|
||||
|
||||
alias core.stdc.complex.cproj cproj;
|
||||
alias core.stdc.complex.cprojf cproj;
|
||||
alias core.stdc.complex.cprojl cproj;
|
||||
|
||||
// alias core.stdc.complex.creal creal;
|
||||
// alias core.stdc.complex.crealf creal;
|
||||
// alias core.stdc.complex.creall creal;
|
||||
}
|
||||
98
druntime/import/core/stdc/time.d
Normal file
98
druntime/import/core/stdc/time.d
Normal file
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.time;
|
||||
|
||||
private import core.stdc.config;
|
||||
private import core.stdc.stddef; // for size_t
|
||||
|
||||
extern (C):
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
struct tm
|
||||
{
|
||||
int tm_sec; // seconds after the minute - [0, 60]
|
||||
int tm_min; // minutes after the hour - [0, 59]
|
||||
int tm_hour; // hours since midnight - [0, 23]
|
||||
int tm_mday; // day of the month - [1, 31]
|
||||
int tm_mon; // months since January - [0, 11]
|
||||
int tm_year; // years since 1900
|
||||
int tm_wday; // days since Sunday - [0, 6]
|
||||
int tm_yday; // days since January 1 - [0, 365]
|
||||
int tm_isdst; // Daylight Saving Time flag
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
struct tm
|
||||
{
|
||||
int tm_sec; // seconds after the minute [0-60]
|
||||
int tm_min; // minutes after the hour [0-59]
|
||||
int tm_hour; // hours since midnight [0-23]
|
||||
int tm_mday; // day of the month [1-31]
|
||||
int tm_mon; // months since January [0-11]
|
||||
int tm_year; // years since 1900
|
||||
int tm_wday; // days since Sunday [0-6]
|
||||
int tm_yday; // days since January 1 [0-365]
|
||||
int tm_isdst; // Daylight Savings Time flag
|
||||
c_long tm_gmtoff; // offset from CUT in seconds
|
||||
char* tm_zone; // timezone abbreviation
|
||||
}
|
||||
}
|
||||
|
||||
alias c_long time_t;
|
||||
alias c_long clock_t;
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
clock_t CLOCKS_PER_SEC = 1000;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
clock_t CLOCKS_PER_SEC = 100;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
clock_t CLOCKS_PER_SEC = 128;
|
||||
}
|
||||
else
|
||||
{
|
||||
clock_t CLOCKS_PER_SEC = 1000000;
|
||||
}
|
||||
|
||||
clock_t clock();
|
||||
double difftime(time_t time1, time_t time0);
|
||||
time_t mktime(tm* timeptr);
|
||||
time_t time(time_t* timer);
|
||||
char* asctime(in tm* timeptr);
|
||||
char* ctime(in time_t* timer);
|
||||
tm* gmtime(in time_t* timer);
|
||||
tm* localtime(in time_t* timer);
|
||||
size_t strftime(char* s, size_t maxsize, in char* format, in tm* timeptr);
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
void tzset(); // non-standard
|
||||
void _tzset(); // non-standard
|
||||
char* _strdate(char* s); // non-standard
|
||||
char* _strtime(char* s); // non-standard
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
void tzset(); // non-standard
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
void tzset(); // non-standard
|
||||
}
|
||||
108
druntime/import/core/stdc/wchar_.d
Normal file
108
druntime/import/core/stdc/wchar_.d
Normal file
@@ -0,0 +1,108 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.wchar_;
|
||||
|
||||
private import core.stdc.config;
|
||||
private import core.stdc.stdarg; // for va_list
|
||||
private import core.stdc.stdio; // for FILE, not exposed per spec
|
||||
public import core.stdc.stddef; // for size_t, wchar_t
|
||||
public import core.stdc.time; // for tm
|
||||
public import core.stdc.stdint; // for WCHAR_MIN, WCHAR_MAX
|
||||
|
||||
extern (C):
|
||||
|
||||
alias int mbstate_t;
|
||||
alias wchar_t wint_t;
|
||||
|
||||
enum wchar_t WEOF = 0xFFFF;
|
||||
|
||||
int fwprintf(FILE* stream, in wchar_t* format, ...);
|
||||
int fwscanf(FILE* stream, in wchar_t* format, ...);
|
||||
int swprintf(wchar_t* s, size_t n, in wchar_t* format, ...);
|
||||
int swscanf(in wchar_t* s, in wchar_t* format, ...);
|
||||
int vfwprintf(FILE* stream, in wchar_t* format, va_list arg);
|
||||
int vfwscanf(FILE* stream, in wchar_t* format, va_list arg);
|
||||
int vswprintf(wchar_t* s, size_t n, in wchar_t* format, va_list arg);
|
||||
int vswscanf(in wchar_t* s, in wchar_t* format, va_list arg);
|
||||
int vwprintf(in wchar_t* format, va_list arg);
|
||||
int vwscanf(in wchar_t* format, va_list arg);
|
||||
int wprintf(in wchar_t* format, ...);
|
||||
int wscanf(in wchar_t* format, ...);
|
||||
|
||||
wint_t fgetwc(FILE* stream);
|
||||
wint_t fputwc(wchar_t c, FILE* stream);
|
||||
|
||||
wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
|
||||
int fputws(in wchar_t* s, FILE* stream);
|
||||
|
||||
extern (D)
|
||||
{
|
||||
wint_t getwchar() { return fgetwc(stdin); }
|
||||
wint_t putwchar(wchar_t c) { return fputwc(c,stdout); }
|
||||
wint_t getwc(FILE* stream) { return fgetwc(stream); }
|
||||
wint_t putwc(wchar_t c, FILE* stream) { return fputwc(c, stream); }
|
||||
}
|
||||
|
||||
wint_t ungetwc(wint_t c, FILE* stream);
|
||||
int fwide(FILE* stream, int mode);
|
||||
|
||||
double wcstod(in wchar_t* nptr, wchar_t** endptr);
|
||||
float wcstof(in wchar_t* nptr, wchar_t** endptr);
|
||||
real wcstold(in wchar_t* nptr, wchar_t** endptr);
|
||||
c_long wcstol(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
long wcstoll(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
c_ulong wcstoul(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
ulong wcstoull(in wchar_t* nptr, wchar_t** endptr, int base);
|
||||
|
||||
wchar_t* wcscpy(wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcsncpy(wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
wchar_t* wcscat(wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcsncat(wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
int wcscmp(in wchar_t* s1, in wchar_t* s2);
|
||||
int wcscoll(in wchar_t* s1, in wchar_t* s2);
|
||||
int wcsncmp(in wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
size_t wcsxfrm(wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
wchar_t* wcschr(in wchar_t* s, wchar_t c);
|
||||
size_t wcscspn(in wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcspbrk(in wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcsrchr(in wchar_t* s, wchar_t c);
|
||||
size_t wcsspn(in wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcsstr(in wchar_t* s1, in wchar_t* s2);
|
||||
wchar_t* wcstok(wchar_t* s1, in wchar_t* s2, wchar_t** ptr);
|
||||
size_t wcslen(wchar_t* s);
|
||||
|
||||
wchar_t* wmemchr(in wchar_t* s, wchar_t c, size_t n);
|
||||
int wmemcmp(in wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
wchar_t* wmemcpy(wchar_t* s1, in wchar_t* s2, size_t n);
|
||||
wchar_t* wmemmove(wchar_t*s1, in wchar_t* s2, size_t n);
|
||||
wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);
|
||||
|
||||
size_t wcsftime(wchar_t* s, size_t maxsize, in wchar_t* format, in tm* timeptr);
|
||||
|
||||
version( Windows )
|
||||
{
|
||||
wchar_t* _wasctime(tm*); // non-standard
|
||||
wchar_t* _wctime(time_t*); // non-standard
|
||||
wchar_t* _wstrdate(wchar_t*); // non-standard
|
||||
wchar_t* _wstrtime(wchar_t*); // non-standard
|
||||
}
|
||||
|
||||
wint_t btowc(int c);
|
||||
int wctob(wint_t c);
|
||||
int mbsinit(in mbstate_t* ps);
|
||||
size_t mbrlen(in char* s, size_t n, mbstate_t* ps);
|
||||
size_t mbrtowc(wchar_t* pwc, in char* s, size_t n, mbstate_t* ps);
|
||||
size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
|
||||
size_t mbsrtowcs(wchar_t* dst, in char** src, size_t len, mbstate_t* ps);
|
||||
size_t wcsrtombs(char* dst, in wchar_t** src, size_t len, mbstate_t* ps);
|
||||
41
druntime/import/core/stdc/wctype.d
Normal file
41
druntime/import/core/stdc/wctype.d
Normal file
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* D header file for C99.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: ISO/IEC 9899:1999 (E)
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.stdc.wctype;
|
||||
|
||||
public import core.stdc.wchar_; // for wint_t, WEOF
|
||||
|
||||
extern (C):
|
||||
|
||||
alias wchar_t wctrans_t;
|
||||
alias wchar_t wctype_t;
|
||||
|
||||
int iswalnum(wint_t wc);
|
||||
int iswalpha(wint_t wc);
|
||||
int iswblank(wint_t wc);
|
||||
int iswcntrl(wint_t wc);
|
||||
int iswdigit(wint_t wc);
|
||||
int iswgraph(wint_t wc);
|
||||
int iswlower(wint_t wc);
|
||||
int iswprint(wint_t wc);
|
||||
int iswpunct(wint_t wc);
|
||||
int iswspace(wint_t wc);
|
||||
int iswupper(wint_t wc);
|
||||
int iswxdigit(wint_t wc);
|
||||
|
||||
int iswctype(wint_t wc, wctype_t desc);
|
||||
wctype_t wctype(in char* property);
|
||||
wint_t towlower(wint_t wc);
|
||||
wint_t towupper(wint_t wc);
|
||||
wint_t towctrans(wint_t wc, wctrans_t desc);
|
||||
wctrans_t wctrans(in char* property);
|
||||
71
druntime/import/core/sys/osx/mach/kern_return.d
Normal file
71
druntime/import/core/sys/osx/mach/kern_return.d
Normal file
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* D header file for OSX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2008 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2008 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.osx.mach.kern_return;
|
||||
|
||||
extern (C):
|
||||
|
||||
alias int kern_return_t;
|
||||
|
||||
enum : kern_return_t
|
||||
{
|
||||
KERN_SUCCESS = 0,
|
||||
KERN_INVALID_ADDRESS = 1,
|
||||
KERN_PROTECTION_FAILURE = 2,
|
||||
KERN_NO_SPACE = 3,
|
||||
KERN_INVALID_ARGUMENT = 4,
|
||||
KERN_FAILURE = 5,
|
||||
KERN_RESOURCE_SHORTAGE = 6,
|
||||
KERN_NOT_RECEIVER = 7,
|
||||
KERN_NO_ACCESS = 8,
|
||||
KERN_MEMORY_FAILURE = 9,
|
||||
KERN_MEMORY_ERROR = 10,
|
||||
KERN_ALREADY_IN_SET = 11,
|
||||
KERN_NOT_IN_SET = 12,
|
||||
KERN_NAME_EXISTS = 13,
|
||||
KERN_ABORTED = 14,
|
||||
KERN_INVALID_NAME = 15,
|
||||
KERN_INVALID_TASK = 16,
|
||||
KERN_INVALID_RIGHT = 17,
|
||||
KERN_INVALID_VALUE = 18,
|
||||
KERN_UREFS_OVERFLOW = 19,
|
||||
KERN_INVALID_CAPABILITY = 20,
|
||||
KERN_RIGHT_EXISTS = 21,
|
||||
KERN_INVALID_HOST = 22,
|
||||
KERN_MEMORY_PRESENT = 23,
|
||||
KERN_MEMORY_DATA_MOVED = 24,
|
||||
KERN_MEMORY_RESTART_COPY = 25,
|
||||
KERN_INVALID_PROCESSOR_SET = 26,
|
||||
KERN_POLICY_LIMIT = 27,
|
||||
KERN_INVALID_POLICY = 28,
|
||||
KERN_INVALID_OBJECT = 29,
|
||||
KERN_ALREADY_WAITING = 30,
|
||||
KERN_DEFAULT_SET = 31,
|
||||
KERN_EXCEPTION_PROTECTED = 32,
|
||||
KERN_INVALID_LEDGER = 33,
|
||||
KERN_INVALID_MEMORY_CONTROL = 34,
|
||||
KERN_INVALID_SECURITY = 35,
|
||||
KERN_NOT_DEPRESSED = 36,
|
||||
KERN_TERMINATED = 37,
|
||||
KERN_LOCK_SET_DESTROYED = 38,
|
||||
KERN_LOCK_UNSTABLE = 39,
|
||||
KERN_LOCK_OWNED = 40,
|
||||
KERN_LOCK_OWNED_SELF = 41,
|
||||
KERN_SEMAPHORE_DESTROYED = 42,
|
||||
KERN_RPC_SERVER_TERMINATED = 43,
|
||||
KERN_RPC_TERMINATE_ORPHAN = 44,
|
||||
KERN_RPC_CONTINUE_ORPHAN = 45,
|
||||
KERN_NOT_SUPPORTED = 46,
|
||||
KERN_NODE_DOWN = 47,
|
||||
KERN_OPERATION_TIMED_OUT = 49,
|
||||
KERN_RETURN_MAX = 0x100,
|
||||
}
|
||||
25
druntime/import/core/sys/osx/mach/port.d
Normal file
25
druntime/import/core/sys/osx/mach/port.d
Normal file
@@ -0,0 +1,25 @@
|
||||
/**
|
||||
* D header file for OSX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2008 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2008 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.osx.mach.port;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( X86 )
|
||||
version = i386;
|
||||
version( X86_64 )
|
||||
version = i386;
|
||||
version( i386 )
|
||||
{
|
||||
alias uint natural_t;
|
||||
alias natural_t mach_port_t;
|
||||
}
|
||||
54
druntime/import/core/sys/osx/mach/semaphore.d
Normal file
54
druntime/import/core/sys/osx/mach/semaphore.d
Normal file
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* D header file for OSX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2008 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2008 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.osx.mach.semaphore;
|
||||
|
||||
public import core.sys.osx.mach.kern_return;
|
||||
public import core.sys.osx.mach.port;
|
||||
|
||||
extern (C):
|
||||
|
||||
alias mach_port_t task_t;
|
||||
alias mach_port_t thread_t;
|
||||
alias mach_port_t semaphore_t;
|
||||
alias int sync_policy_t;
|
||||
|
||||
alias int clock_res_t;
|
||||
struct mach_timespec_t
|
||||
{
|
||||
uint tv_sec;
|
||||
clock_res_t tv_nsec;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SYNC_POLICY_FIFO = 0x0,
|
||||
SYNC_POLICY_FIXED_PRIORITY = 0x1,
|
||||
SYNC_POLICY_REVERSED = 0x2,
|
||||
SYNC_POLICY_ORDER_MASK = 0x3,
|
||||
SYNC_POLICY_LIFO = (SYNC_POLICY_FIFO | SYNC_POLICY_REVERSED),
|
||||
SYNC_POLICY_MAX = 0x7,
|
||||
}
|
||||
|
||||
task_t mach_task_self();
|
||||
kern_return_t semaphore_create(task_t, semaphore_t*, int, int);
|
||||
kern_return_t semaphore_destroy(task_t, semaphore_t);
|
||||
|
||||
kern_return_t semaphore_signal(semaphore_t);
|
||||
kern_return_t semaphore_signal_all(semaphore_t);
|
||||
kern_return_t semaphore_signal_thread(semaphore_t, thread_t);
|
||||
|
||||
kern_return_t semaphore_wait(semaphore_t);
|
||||
kern_return_t semaphore_wait_signal(semaphore_t, semaphore_t);
|
||||
|
||||
kern_return_t semaphore_timedwait(semaphore_t, mach_timespec_t);
|
||||
kern_return_t semaphore_timedwait_signal(semaphore_t, semaphore_t, mach_timespec_t);
|
||||
124
druntime/import/core/sys/osx/mach/thread_act.d
Normal file
124
druntime/import/core/sys/osx/mach/thread_act.d
Normal file
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* D header file for OSX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2008 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2008 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.osx.mach.thread_act;
|
||||
|
||||
public import core.sys.osx.mach.kern_return;
|
||||
public import core.sys.osx.mach.port;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( X86 )
|
||||
version = i386;
|
||||
version( X86_64 )
|
||||
version = i386;
|
||||
version( i386 )
|
||||
{
|
||||
alias mach_port_t thread_act_t;
|
||||
alias void thread_state_t;
|
||||
alias int thread_state_flavor_t;
|
||||
alias natural_t mach_msg_type_number_t;
|
||||
|
||||
enum
|
||||
{
|
||||
x86_THREAD_STATE32 = 1,
|
||||
x86_FLOAT_STATE32 = 2,
|
||||
x86_EXCEPTION_STATE32 = 3,
|
||||
x86_THREAD_STATE64 = 4,
|
||||
x86_FLOAT_STATE64 = 5,
|
||||
x86_EXCEPTION_STATE64 = 6,
|
||||
x86_THREAD_STATE = 7,
|
||||
x86_FLOAT_STATE = 8,
|
||||
x86_EXCEPTION_STATE = 9,
|
||||
x86_DEBUG_STATE32 = 10,
|
||||
x86_DEBUG_STATE64 = 11,
|
||||
x86_DEBUG_STATE = 12,
|
||||
THREAD_STATE_NONE = 13,
|
||||
}
|
||||
|
||||
struct x86_thread_state32_t
|
||||
{
|
||||
uint eax;
|
||||
uint ebx;
|
||||
uint ecx;
|
||||
uint edx;
|
||||
uint edi;
|
||||
uint esi;
|
||||
uint ebp;
|
||||
uint esp;
|
||||
uint ss;
|
||||
uint eflags;
|
||||
uint eip;
|
||||
uint cs;
|
||||
uint ds;
|
||||
uint es;
|
||||
uint fs;
|
||||
uint gs;
|
||||
}
|
||||
|
||||
struct x86_thread_state64_t
|
||||
{
|
||||
ulong rax;
|
||||
ulong rbx;
|
||||
ulong rcx;
|
||||
ulong rdx;
|
||||
ulong rdi;
|
||||
ulong rsi;
|
||||
ulong rbp;
|
||||
ulong rsp;
|
||||
ulong r8;
|
||||
ulong r9;
|
||||
ulong r10;
|
||||
ulong r11;
|
||||
ulong r12;
|
||||
ulong r13;
|
||||
ulong r14;
|
||||
ulong r15;
|
||||
ulong rip;
|
||||
ulong rflags;
|
||||
ulong cs;
|
||||
ulong fs;
|
||||
ulong gs;
|
||||
}
|
||||
|
||||
struct x86_state_hdr_t
|
||||
{
|
||||
int flavor;
|
||||
int count;
|
||||
}
|
||||
|
||||
struct x86_thread_state_t
|
||||
{
|
||||
x86_state_hdr_t tsh;
|
||||
union _uts
|
||||
{
|
||||
x86_thread_state32_t ts32;
|
||||
x86_thread_state64_t ts64;
|
||||
}
|
||||
_uts uts;
|
||||
}
|
||||
|
||||
enum : mach_msg_type_number_t
|
||||
{
|
||||
x86_THREAD_STATE32_COUNT = cast(mach_msg_type_number_t)( x86_thread_state32_t.sizeof / int.sizeof ),
|
||||
x86_THREAD_STATE64_COUNT = cast(mach_msg_type_number_t)( x86_thread_state64_t.sizeof / int.sizeof ),
|
||||
x86_THREAD_STATE_COUNT = cast(mach_msg_type_number_t)( x86_thread_state_t.sizeof / int.sizeof ),
|
||||
}
|
||||
|
||||
alias x86_THREAD_STATE MACHINE_THREAD_STATE;
|
||||
alias x86_THREAD_STATE_COUNT MACHINE_THREAD_STATE_COUNT;
|
||||
|
||||
mach_port_t mach_thread_self();
|
||||
kern_return_t thread_suspend(thread_act_t);
|
||||
kern_return_t thread_resume(thread_act_t);
|
||||
kern_return_t thread_get_state(thread_act_t, thread_state_flavor_t, thread_state_t*, mach_msg_type_number_t*);
|
||||
}
|
||||
132
druntime/import/core/sys/posix/arpa/inet.d
Normal file
132
druntime/import/core/sys/posix/arpa/inet.d
Normal file
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.arpa.inet;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.inttypes; // for uint32_t, uint16_t
|
||||
public import core.sys.posix.sys.socket; // for socklen_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
in_port_t // from core.sys.posix.netinet.in_
|
||||
in_addr_t // from core.sys.posix.netinet.in_
|
||||
|
||||
struct in_addr // from core.sys.posix.netinet.in_
|
||||
INET_ADDRSTRLEN // from core.sys.posix.netinet.in_
|
||||
|
||||
uint32_t // from core.stdc.inttypes
|
||||
uint16_t // from core.stdc.inttypes
|
||||
|
||||
uint32_t htonl(uint32_t);
|
||||
uint16_t htons(uint16_t);
|
||||
uint32_t ntohl(uint32_t);
|
||||
uint16_t ntohs(uint16_t);
|
||||
|
||||
in_addr_t inet_addr(in char*);
|
||||
char* inet_ntoa(in_addr);
|
||||
// per spec: const char* inet_ntop(int, const void*, char*, socklen_t);
|
||||
char* inet_ntop(int, in void*, char*, socklen_t);
|
||||
int inet_pton(int, in char*, void*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
alias uint16_t in_port_t;
|
||||
alias uint32_t in_addr_t;
|
||||
|
||||
struct in_addr
|
||||
{
|
||||
in_addr_t s_addr;
|
||||
}
|
||||
|
||||
enum INET_ADDRSTRLEN = 16;
|
||||
|
||||
uint32_t htonl(uint32_t);
|
||||
uint16_t htons(uint16_t);
|
||||
uint32_t ntohl(uint32_t);
|
||||
uint16_t ntohs(uint16_t);
|
||||
|
||||
in_addr_t inet_addr(in char*);
|
||||
char* inet_ntoa(in_addr);
|
||||
char* inet_ntop(int, in void*, char*, socklen_t);
|
||||
int inet_pton(int, in char*, void*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
alias uint16_t in_port_t; // TODO: verify
|
||||
alias uint32_t in_addr_t; // TODO: verify
|
||||
|
||||
struct in_addr
|
||||
{
|
||||
in_addr_t s_addr;
|
||||
}
|
||||
|
||||
enum INET_ADDRSTRLEN = 16;
|
||||
|
||||
uint32_t htonl(uint32_t);
|
||||
uint16_t htons(uint16_t);
|
||||
uint32_t ntohl(uint32_t);
|
||||
uint16_t ntohs(uint16_t);
|
||||
|
||||
in_addr_t inet_addr(in char*);
|
||||
char* inet_ntoa(in_addr);
|
||||
char* inet_ntop(int, in void*, char*, socklen_t);
|
||||
int inet_pton(int, in char*, void*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias uint16_t in_port_t; // TODO: verify
|
||||
alias uint32_t in_addr_t; // TODO: verify
|
||||
|
||||
struct in_addr
|
||||
{
|
||||
in_addr_t s_addr;
|
||||
}
|
||||
|
||||
enum INET_ADDRSTRLEN = 16;
|
||||
|
||||
uint32_t htonl(uint32_t);
|
||||
uint16_t htons(uint16_t);
|
||||
uint32_t ntohl(uint32_t);
|
||||
uint16_t ntohs(uint16_t);
|
||||
|
||||
in_addr_t inet_addr(in char*);
|
||||
char* inet_ntoa(in_addr);
|
||||
char* inet_ntop(int, in void*, char*, socklen_t);
|
||||
int inet_pton(int, in char*, void*);
|
||||
}
|
||||
|
||||
//
|
||||
// IPV6 (IP6)
|
||||
//
|
||||
/*
|
||||
INET6_ADDRSTRLEN // from core.sys.posix.netinet.in_
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum INET6_ADDRSTRLEN = 46;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum INET6_ADDRSTRLEN = 46;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum INET6_ADDRSTRLEN = 46;
|
||||
}
|
||||
32
druntime/import/core/sys/posix/config.d
Normal file
32
druntime/import/core/sys/posix/config.d
Normal file
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.config;
|
||||
|
||||
public import core.stdc.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
version( linux )
|
||||
{
|
||||
version( X86_64 )
|
||||
{
|
||||
enum bool __USE_LARGEFILE64 = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
enum bool __USE_LARGEFILE64 = false;
|
||||
}
|
||||
enum bool __USE_FILE_OFFSET64 = __USE_LARGEFILE64;
|
||||
enum bool __REDIRECT = false;
|
||||
}
|
||||
203
druntime/import/core/sys/posix/dirent.d
Normal file
203
druntime/import/core/sys/posix/dirent.d
Normal file
@@ -0,0 +1,203 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.dirent;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for ino_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
DIR
|
||||
|
||||
struct dirent
|
||||
{
|
||||
char[] d_name;
|
||||
}
|
||||
|
||||
int closedir(DIR*);
|
||||
DIR* opendir(in char*);
|
||||
dirent* readdir(DIR*);
|
||||
void rewinddir(DIR*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
// NOTE: The following constants are non-standard Linux definitions
|
||||
// for dirent.d_type.
|
||||
enum
|
||||
{
|
||||
DT_UNKNOWN = 0,
|
||||
DT_FIFO = 1,
|
||||
DT_CHR = 2,
|
||||
DT_DIR = 4,
|
||||
DT_BLK = 6,
|
||||
DT_REG = 8,
|
||||
DT_LNK = 10,
|
||||
DT_SOCK = 12,
|
||||
DT_WHT = 14
|
||||
}
|
||||
|
||||
struct dirent
|
||||
{
|
||||
ino_t d_ino;
|
||||
off_t d_off;
|
||||
ushort d_reclen;
|
||||
ubyte d_type;
|
||||
char[256] d_name;
|
||||
}
|
||||
|
||||
struct DIR
|
||||
{
|
||||
// Managed by OS
|
||||
}
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
dirent* readdir64(DIR*);
|
||||
alias readdir64 readdir;
|
||||
}
|
||||
else
|
||||
{
|
||||
dirent* readdir(DIR*);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
DT_UNKNOWN = 0,
|
||||
DT_FIFO = 1,
|
||||
DT_CHR = 2,
|
||||
DT_DIR = 4,
|
||||
DT_BLK = 6,
|
||||
DT_REG = 8,
|
||||
DT_LNK = 10,
|
||||
DT_SOCK = 12,
|
||||
DT_WHT = 14
|
||||
}
|
||||
|
||||
align(4)
|
||||
struct dirent
|
||||
{
|
||||
ino_t d_ino;
|
||||
ushort d_reclen;
|
||||
ubyte d_type;
|
||||
ubyte d_namlen;
|
||||
char[256] d_name;
|
||||
}
|
||||
|
||||
struct DIR
|
||||
{
|
||||
// Managed by OS
|
||||
}
|
||||
|
||||
dirent* readdir(DIR*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
DT_UNKNOWN = 0,
|
||||
DT_FIFO = 1,
|
||||
DT_CHR = 2,
|
||||
DT_DIR = 4,
|
||||
DT_BLK = 6,
|
||||
DT_REG = 8,
|
||||
DT_LNK = 10,
|
||||
DT_SOCK = 12,
|
||||
DT_WHT = 14
|
||||
}
|
||||
|
||||
align(4)
|
||||
struct dirent
|
||||
{
|
||||
uint d_fileno;
|
||||
ushort d_reclen;
|
||||
ubyte d_type;
|
||||
ubyte d_namelen;
|
||||
char[256] d_name;
|
||||
}
|
||||
|
||||
struct _telldir;
|
||||
struct DIR
|
||||
{
|
||||
int dd_fd;
|
||||
c_long dd_loc;
|
||||
c_long dd_size;
|
||||
char* dd_buf;
|
||||
int dd_len;
|
||||
c_long dd_seek;
|
||||
c_long dd_rewind;
|
||||
int dd_flags;
|
||||
void* dd_lock;
|
||||
_telldir* dd_td;
|
||||
}
|
||||
|
||||
dirent* readdir(DIR*);
|
||||
}
|
||||
else
|
||||
{
|
||||
dirent* readdir(DIR*);
|
||||
}
|
||||
|
||||
int closedir(DIR*);
|
||||
DIR* opendir(in char*);
|
||||
//dirent* readdir(DIR*);
|
||||
void rewinddir(DIR*);
|
||||
|
||||
//
|
||||
// Thread-Safe Functions (TSF)
|
||||
//
|
||||
/*
|
||||
int readdir_r(DIR*, dirent*, dirent**);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int readdir64_r(DIR*, dirent*, dirent**);
|
||||
alias readdir64_r readdir_r;
|
||||
}
|
||||
else
|
||||
{
|
||||
int readdir_r(DIR*, dirent*, dirent**);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int readdir_r(DIR*, dirent*, dirent**);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int readdir_r(DIR*, dirent*, dirent**);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
void seekdir(DIR*, c_long);
|
||||
c_long telldir(DIR*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
void seekdir(DIR*, c_long);
|
||||
c_long telldir(DIR*);
|
||||
}
|
||||
70
druntime/import/core/sys/posix/dlfcn.d
Normal file
70
druntime/import/core/sys/posix/dlfcn.d
Normal file
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.dlfcn;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
RTLD_LAZY
|
||||
RTLD_NOW
|
||||
RTLD_GLOBAL
|
||||
RTLD_LOCAL
|
||||
|
||||
int dlclose(void*);
|
||||
char* dlerror();
|
||||
void* dlopen(in char*, int);
|
||||
void* dlsym(void*, in char*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum RTLD_LAZY = 0x00001;
|
||||
enum RTLD_NOW = 0x00002;
|
||||
enum RTLD_GLOBAL = 0x00100;
|
||||
enum RTLD_LOCAL = 0x00000;
|
||||
|
||||
int dlclose(void*);
|
||||
char* dlerror();
|
||||
void* dlopen(in char*, int);
|
||||
void* dlsym(void*, in char*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum RTLD_LAZY = 0x00001;
|
||||
enum RTLD_NOW = 0x00002;
|
||||
enum RTLD_GLOBAL = 0x00100;
|
||||
enum RTLD_LOCAL = 0x00000;
|
||||
|
||||
int dlclose(void*);
|
||||
char* dlerror();
|
||||
void* dlopen(in char*, int);
|
||||
void* dlsym(void*, in char*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum RTLD_LAZY = 1;
|
||||
enum RTLD_NOW = 2;
|
||||
enum RTLD_GLOBAL = 0x100;
|
||||
enum RTLD_LOCAL = 0;
|
||||
|
||||
int dlclose(void*);
|
||||
char* dlerror();
|
||||
void* dlopen(in char*, int);
|
||||
void* dlsym(void*, in char*);
|
||||
}
|
||||
253
druntime/import/core/sys/posix/fcntl.d
Normal file
253
druntime/import/core/sys/posix/fcntl.d
Normal file
@@ -0,0 +1,253 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.fcntl;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.stdc.stdint;
|
||||
public import core.stdc.stddef; // for size_t
|
||||
public import core.sys.posix.sys.types; // for off_t, mode_t
|
||||
public import core.sys.posix.sys.stat; // for S_IFMT, etc.
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
F_DUPFD
|
||||
F_GETFD
|
||||
F_SETFD
|
||||
F_GETFL
|
||||
F_SETFL
|
||||
F_GETLK
|
||||
F_SETLK
|
||||
F_SETLKW
|
||||
F_GETOWN
|
||||
F_SETOWN
|
||||
|
||||
FD_CLOEXEC
|
||||
|
||||
F_RDLCK
|
||||
F_UNLCK
|
||||
F_WRLCK
|
||||
|
||||
O_CREAT
|
||||
O_EXCL
|
||||
O_NOCTTY
|
||||
O_TRUNC
|
||||
|
||||
O_APPEND
|
||||
O_DSYNC
|
||||
O_NONBLOCK
|
||||
O_RSYNC
|
||||
O_SYNC
|
||||
|
||||
O_ACCMODE
|
||||
O_RDONLY
|
||||
O_RDWR
|
||||
O_WRONLY
|
||||
|
||||
struct flock
|
||||
{
|
||||
short l_type;
|
||||
short l_whence;
|
||||
off_t l_start;
|
||||
off_t l_len;
|
||||
pid_t l_pid;
|
||||
}
|
||||
|
||||
int creat(in char*, mode_t);
|
||||
int fcntl(int, int, ...);
|
||||
int open(in char*, int, ...);
|
||||
*/
|
||||
version( linux )
|
||||
{
|
||||
enum F_DUPFD = 0;
|
||||
enum F_GETFD = 1;
|
||||
enum F_SETFD = 2;
|
||||
enum F_GETFL = 3;
|
||||
enum F_SETFL = 4;
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
enum F_GETLK = 12;
|
||||
enum F_SETLK = 13;
|
||||
enum F_SETLKW = 14;
|
||||
}
|
||||
else
|
||||
{
|
||||
enum F_GETLK = 5;
|
||||
enum F_SETLK = 6;
|
||||
enum F_SETLKW = 7;
|
||||
}
|
||||
enum F_GETOWN = 9;
|
||||
enum F_SETOWN = 8;
|
||||
|
||||
enum FD_CLOEXEC = 1;
|
||||
|
||||
enum F_RDLCK = 0;
|
||||
enum F_UNLCK = 2;
|
||||
enum F_WRLCK = 1;
|
||||
|
||||
enum O_CREAT = 0100;
|
||||
enum O_EXCL = 0200;
|
||||
enum O_NOCTTY = 0400;
|
||||
enum O_TRUNC = 01000;
|
||||
|
||||
enum O_APPEND = 02000;
|
||||
enum O_NONBLOCK = 04000;
|
||||
enum O_SYNC = 010000;
|
||||
enum O_DSYNC = O_SYNC;
|
||||
enum O_RSYNC = O_SYNC;
|
||||
|
||||
enum O_ACCMODE = 0003;
|
||||
enum O_RDONLY = 00;
|
||||
enum O_WRONLY = 01;
|
||||
enum O_RDWR = 02;
|
||||
|
||||
struct flock
|
||||
{
|
||||
short l_type;
|
||||
short l_whence;
|
||||
off_t l_start;
|
||||
off_t l_len;
|
||||
pid_t l_pid;
|
||||
}
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int creat64(in char*, mode_t);
|
||||
alias creat64 creat;
|
||||
|
||||
int open64(in char*, int, ...);
|
||||
alias open64 open;
|
||||
}
|
||||
else
|
||||
{
|
||||
int creat(in char*, mode_t);
|
||||
int open(in char*, int, ...);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum F_DUPFD = 0;
|
||||
enum F_GETFD = 1;
|
||||
enum F_SETFD = 2;
|
||||
enum F_GETFL = 3;
|
||||
enum F_SETFL = 4;
|
||||
enum F_GETOWN = 5;
|
||||
enum F_SETOWN = 6;
|
||||
enum F_GETLK = 7;
|
||||
enum F_SETLK = 8;
|
||||
enum F_SETLKW = 9;
|
||||
|
||||
enum FD_CLOEXEC = 1;
|
||||
|
||||
enum F_RDLCK = 1;
|
||||
enum F_UNLCK = 2;
|
||||
enum F_WRLCK = 3;
|
||||
|
||||
enum O_CREAT = 0x0200;
|
||||
enum O_EXCL = 0x0800;
|
||||
enum O_NOCTTY = 0;
|
||||
enum O_TRUNC = 0x0400;
|
||||
|
||||
enum O_RDONLY = 0x0000;
|
||||
enum O_WRONLY = 0x0001;
|
||||
enum O_RDWR = 0x0002;
|
||||
enum O_ACCMODE = 0x0003;
|
||||
|
||||
enum O_NONBLOCK = 0x0004;
|
||||
enum O_APPEND = 0x0008;
|
||||
enum O_SYNC = 0x0080;
|
||||
//enum O_DSYNC
|
||||
//enum O_RSYNC
|
||||
|
||||
struct flock
|
||||
{
|
||||
off_t l_start;
|
||||
off_t l_len;
|
||||
pid_t l_pid;
|
||||
short l_type;
|
||||
short l_whence;
|
||||
}
|
||||
|
||||
int creat(in char*, mode_t);
|
||||
int open(in char*, int, ...);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum F_DUPFD = 0;
|
||||
enum F_GETFD = 1;
|
||||
enum F_SETFD = 2;
|
||||
enum F_GETFL = 3;
|
||||
enum F_SETFL = 4;
|
||||
enum F_GETOWN = 5;
|
||||
enum F_SETOWN = 6;
|
||||
enum F_GETLK = 7;
|
||||
enum F_SETLK = 8;
|
||||
enum F_SETLKW = 9;
|
||||
|
||||
enum FD_CLOEXEC = 1;
|
||||
|
||||
enum F_RDLCK = 1;
|
||||
enum F_UNLCK = 2;
|
||||
enum F_WRLCK = 3;
|
||||
|
||||
enum O_CREAT = 0x0200;
|
||||
enum O_EXCL = 0x0800;
|
||||
enum O_NOCTTY = 0;
|
||||
enum O_TRUNC = 0x0400;
|
||||
|
||||
enum O_RDONLY = 0x0000;
|
||||
enum O_WRONLY = 0x0001;
|
||||
enum O_RDWR = 0x0002;
|
||||
enum O_ACCMODE = 0x0003;
|
||||
|
||||
enum O_NONBLOCK = 0x0004;
|
||||
enum O_APPEND = 0x0008;
|
||||
enum O_SYNC = 0x0080;
|
||||
//enum O_DSYNC
|
||||
//enum O_RSYNC
|
||||
|
||||
struct flock
|
||||
{
|
||||
off_t l_start;
|
||||
off_t l_len;
|
||||
pid_t l_pid;
|
||||
short l_type;
|
||||
short l_whence;
|
||||
}
|
||||
|
||||
int creat(in char*, mode_t);
|
||||
int open(in char*, int, ...);
|
||||
}
|
||||
|
||||
//int creat(in char*, mode_t);
|
||||
int fcntl(int, int, ...);
|
||||
//int open(in char*, int, ...);
|
||||
|
||||
//
|
||||
// Advisory Information (ADV)
|
||||
//
|
||||
/*
|
||||
POSIX_FADV_NORMAL
|
||||
POSIX_FADV_SEQUENTIAL
|
||||
POSIX_FADV_RANDOM
|
||||
POSIX_FADV_WILLNEED
|
||||
POSIX_FADV_DONTNEED
|
||||
POSIX_FADV_NOREUSE
|
||||
|
||||
int posix_fadvise(int, off_t, off_t, int);
|
||||
int posix_fallocate(int, off_t, off_t);
|
||||
*/
|
||||
35
druntime/import/core/sys/posix/inttypes.d
Normal file
35
druntime/import/core/sys/posix/inttypes.d
Normal file
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.inttypes;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.inttypes;
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
intmax_t imaxabs(intmax_t);
|
||||
imaxdiv_t imaxdiv(intmax_t, intmax_t);
|
||||
intmax_t strtoimax(in char*, char**, int);
|
||||
uintmax_t strtoumax(in char *, char**, int);
|
||||
intmax_t wcstoimax(in wchar_t*, wchar_t**, int);
|
||||
uintmax_t wcstoumax(in wchar_t*, wchar_t**, int);
|
||||
*/
|
||||
intmax_t imaxabs(intmax_t);
|
||||
imaxdiv_t imaxdiv(intmax_t, intmax_t);
|
||||
intmax_t strtoimax(in char*, char**, int);
|
||||
uintmax_t strtoumax(in char *, char**, int);
|
||||
intmax_t wcstoimax(in wchar_t*, wchar_t**, int);
|
||||
uintmax_t wcstoumax(in wchar_t*, wchar_t**, int);
|
||||
82
druntime/import/core/sys/posix/net/if_.d
Normal file
82
druntime/import/core/sys/posix/net/if_.d
Normal file
@@ -0,0 +1,82 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.net.if_;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct if_nameindex // renamed to if_nameindex_t
|
||||
{
|
||||
uint if_index;
|
||||
char* if_name;
|
||||
}
|
||||
|
||||
IF_NAMESIZE
|
||||
|
||||
uint if_nametoindex(in char*);
|
||||
char* if_indextoname(uint, char*);
|
||||
if_nameindex_t* if_nameindex();
|
||||
void if_freenameindex(if_nameindex_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct if_nameindex_t
|
||||
{
|
||||
uint if_index;
|
||||
char* if_name;
|
||||
}
|
||||
|
||||
enum IF_NAMESIZE = 16;
|
||||
|
||||
uint if_nametoindex(in char*);
|
||||
char* if_indextoname(uint, char*);
|
||||
if_nameindex_t* if_nameindex();
|
||||
void if_freenameindex(if_nameindex_t*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct if_nameindex_t
|
||||
{
|
||||
uint if_index;
|
||||
char* if_name;
|
||||
}
|
||||
|
||||
enum IF_NAMESIZE = 16;
|
||||
|
||||
uint if_nametoindex(in char*);
|
||||
char* if_indextoname(uint, char*);
|
||||
if_nameindex_t* if_nameindex();
|
||||
void if_freenameindex(if_nameindex_t*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct if_nameindex_t
|
||||
{
|
||||
uint if_index;
|
||||
char* if_name;
|
||||
}
|
||||
|
||||
enum IF_NAMESIZE = 16;
|
||||
|
||||
uint if_nametoindex(in char*);
|
||||
char* if_indextoname(uint, char*);
|
||||
if_nameindex_t* if_nameindex();
|
||||
void if_freenameindex(if_nameindex_t*);
|
||||
}
|
||||
464
druntime/import/core/sys/posix/netinet/in_.d
Normal file
464
druntime/import/core/sys/posix/netinet/in_.d
Normal file
@@ -0,0 +1,464 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.netinet.in_;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.inttypes; // for uint32_t, uint16_t, uint8_t
|
||||
public import core.sys.posix.arpa.inet;
|
||||
public import core.sys.posix.sys.socket; // for sa_family_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
NOTE: The following must must be defined in core.sys.posix.arpa.inet to break
|
||||
a circular import: in_port_t, in_addr_t, struct in_addr, INET_ADDRSTRLEN.
|
||||
|
||||
in_port_t
|
||||
in_addr_t
|
||||
|
||||
sa_family_t // from core.sys.posix.sys.socket
|
||||
uint8_t // from core.stdc.inttypes
|
||||
uint32_t // from core.stdc.inttypes
|
||||
|
||||
struct in_addr
|
||||
{
|
||||
in_addr_t s_addr;
|
||||
}
|
||||
|
||||
struct sockaddr_in
|
||||
{
|
||||
sa_family_t sin_family;
|
||||
in_port_t sin_port;
|
||||
in_addr sin_addr;
|
||||
}
|
||||
|
||||
IPPROTO_IP
|
||||
IPPROTO_ICMP
|
||||
IPPROTO_TCP
|
||||
IPPROTO_UDP
|
||||
|
||||
INADDR_ANY
|
||||
INADDR_BROADCAST
|
||||
|
||||
INET_ADDRSTRLEN
|
||||
|
||||
htonl() // from core.sys.posix.arpa.inet
|
||||
htons() // from core.sys.posix.arpa.inet
|
||||
ntohl() // from core.sys.posix.arpa.inet
|
||||
ntohs() // from core.sys.posix.arpa.inet
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
private enum __SOCK_SIZE__ = 16;
|
||||
|
||||
struct sockaddr_in
|
||||
{
|
||||
sa_family_t sin_family;
|
||||
in_port_t sin_port;
|
||||
in_addr sin_addr;
|
||||
|
||||
/* Pad to size of `struct sockaddr'. */
|
||||
ubyte[__SOCK_SIZE__ - sa_family_t.sizeof -
|
||||
in_port_t.sizeof - in_addr.sizeof] __pad;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
IPPROTO_IP = 0,
|
||||
IPPROTO_ICMP = 1,
|
||||
IPPROTO_TCP = 6,
|
||||
IPPROTO_UDP = 17
|
||||
}
|
||||
|
||||
enum uint INADDR_ANY = 0x00000000;
|
||||
enum uint INADDR_BROADCAST = 0xffffffff;
|
||||
|
||||
enum INET_ADDRSTRLEN = 16;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
private enum __SOCK_SIZE__ = 16;
|
||||
|
||||
struct sockaddr_in
|
||||
{
|
||||
ubyte sin_len;
|
||||
sa_family_t sin_family;
|
||||
in_port_t sin_port;
|
||||
in_addr sin_addr;
|
||||
ubyte[8] sin_zero;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
IPPROTO_IP = 0,
|
||||
IPPROTO_ICMP = 1,
|
||||
IPPROTO_TCP = 6,
|
||||
IPPROTO_UDP = 17
|
||||
}
|
||||
|
||||
enum uint INADDR_ANY = 0x00000000;
|
||||
enum uint INADDR_BROADCAST = 0xffffffff;
|
||||
|
||||
enum INET_ADDRSTRLEN = 16;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
private enum __SOCK_SIZE__ = 16;
|
||||
|
||||
struct sockaddr_in
|
||||
{
|
||||
ubyte sin_len;
|
||||
sa_family_t sin_family;
|
||||
in_port_t sin_port;
|
||||
in_addr sin_addr;
|
||||
ubyte[8] sin_zero;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
IPPROTO_IP = 0,
|
||||
IPPROTO_ICMP = 1,
|
||||
IPPROTO_TCP = 6,
|
||||
IPPROTO_UDP = 17
|
||||
}
|
||||
|
||||
enum uint INADDR_ANY = 0x00000000;
|
||||
enum uint INADDR_BROADCAST = 0xffffffff;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// IPV6 (IP6)
|
||||
//
|
||||
/*
|
||||
NOTE: The following must must be defined in core.sys.posix.arpa.inet to break
|
||||
a circular import: INET6_ADDRSTRLEN.
|
||||
|
||||
struct in6_addr
|
||||
{
|
||||
uint8_t[16] s6_addr;
|
||||
}
|
||||
|
||||
struct sockaddr_in6
|
||||
{
|
||||
sa_family_t sin6_family;
|
||||
in_port_t sin6_port;
|
||||
uint32_t sin6_flowinfo;
|
||||
in6_addr sin6_addr;
|
||||
uint32_t sin6_scope_id;
|
||||
}
|
||||
|
||||
extern in6_addr in6addr_any;
|
||||
extern in6_addr in6addr_loopback;
|
||||
|
||||
struct ipv6_mreq
|
||||
{
|
||||
in6_addr ipv6mr_multiaddr;
|
||||
uint ipv6mr_interface;
|
||||
}
|
||||
|
||||
IPPROTO_IPV6
|
||||
|
||||
INET6_ADDRSTRLEN
|
||||
|
||||
IPV6_JOIN_GROUP
|
||||
IPV6_LEAVE_GROUP
|
||||
IPV6_MULTICAST_HOPS
|
||||
IPV6_MULTICAST_IF
|
||||
IPV6_MULTICAST_LOOP
|
||||
IPV6_UNICAST_HOPS
|
||||
IPV6_V6ONLY
|
||||
|
||||
// macros
|
||||
int IN6_IS_ADDR_UNSPECIFIED(in6_addr*)
|
||||
int IN6_IS_ADDR_LOOPBACK(in6_addr*)
|
||||
int IN6_IS_ADDR_MULTICAST(in6_addr*)
|
||||
int IN6_IS_ADDR_LINKLOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_SITELOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_V4MAPPED(in6_addr*)
|
||||
int IN6_IS_ADDR_V4COMPAT(in6_addr*)
|
||||
int IN6_IS_ADDR_MC_NODELOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_MC_LINKLOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_MC_SITELOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_MC_ORGLOCAL(in6_addr*)
|
||||
int IN6_IS_ADDR_MC_GLOBAL(in6_addr*)
|
||||
*/
|
||||
|
||||
version ( linux )
|
||||
{
|
||||
struct in6_addr
|
||||
{
|
||||
union
|
||||
{
|
||||
uint8_t[16] s6_addr;
|
||||
uint16_t[8] s6_addr16;
|
||||
uint32_t[4] s6_addr32;
|
||||
}
|
||||
}
|
||||
|
||||
struct sockaddr_in6
|
||||
{
|
||||
sa_family_t sin6_family;
|
||||
in_port_t sin6_port;
|
||||
uint32_t sin6_flowinfo;
|
||||
in6_addr sin6_addr;
|
||||
uint32_t sin6_scope_id;
|
||||
}
|
||||
|
||||
extern in6_addr in6addr_any;
|
||||
extern in6_addr in6addr_loopback;
|
||||
|
||||
struct ipv6_mreq
|
||||
{
|
||||
in6_addr ipv6mr_multiaddr;
|
||||
uint ipv6mr_interface;
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
IPPROTO_IPV6 = 41,
|
||||
|
||||
INET6_ADDRSTRLEN = 46,
|
||||
|
||||
IPV6_JOIN_GROUP = 20,
|
||||
IPV6_LEAVE_GROUP = 21,
|
||||
IPV6_MULTICAST_HOPS = 18,
|
||||
IPV6_MULTICAST_IF = 17,
|
||||
IPV6_MULTICAST_LOOP = 19,
|
||||
IPV6_UNICAST_HOPS = 16,
|
||||
IPV6_V6ONLY = 26
|
||||
}
|
||||
|
||||
// macros
|
||||
extern (D) int IN6_IS_ADDR_UNSPECIFIED( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
(cast(uint32_t*) addr)[3] == 0;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_LOOPBACK( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
(cast(uint32_t*) addr)[3] == htonl( 1 );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MULTICAST( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint8_t*) addr)[0] == 0xff;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_LINKLOCAL( in6_addr* addr )
|
||||
{
|
||||
return ((cast(uint32_t*) addr)[0] & htonl( 0xffc00000 )) == htonl( 0xfe800000 );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_SITELOCAL( in6_addr* addr )
|
||||
{
|
||||
return ((cast(uint32_t*) addr)[0] & htonl( 0xffc00000 )) == htonl( 0xfec00000 );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_V4MAPPED( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == htonl( 0xffff );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_V4COMPAT( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
ntohl( (cast(uint32_t*) addr)[3] ) > 1;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_NODELOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x1;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_LINKLOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x2;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_SITELOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST(addr) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x5;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_ORGLOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x8;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_GLOBAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0xe;
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct in6_addr
|
||||
{
|
||||
union
|
||||
{
|
||||
uint8_t[16] s6_addr;
|
||||
uint16_t[8] s6_addr16;
|
||||
uint32_t[4] s6_addr32;
|
||||
}
|
||||
}
|
||||
|
||||
struct sockaddr_in6
|
||||
{
|
||||
uint8_t sin6_len;
|
||||
sa_family_t sin6_family;
|
||||
in_port_t sin6_port;
|
||||
uint32_t sin6_flowinfo;
|
||||
in6_addr sin6_addr;
|
||||
uint32_t sin6_scope_id;
|
||||
}
|
||||
|
||||
extern in6_addr in6addr_any;
|
||||
extern in6_addr in6addr_loopback;
|
||||
|
||||
struct ipv6_mreq
|
||||
{
|
||||
in6_addr ipv6mr_multiaddr;
|
||||
uint ipv6mr_interface;
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
IPPROTO_IPV6 = 41,
|
||||
|
||||
INET6_ADDRSTRLEN = 46,
|
||||
|
||||
IPV6_JOIN_GROUP = 12,
|
||||
IPV6_LEAVE_GROUP = 13,
|
||||
IPV6_MULTICAST_HOPS = 10,
|
||||
IPV6_MULTICAST_IF = 9,
|
||||
IPV6_MULTICAST_LOOP = 11,
|
||||
IPV6_UNICAST_HOPS = 4,
|
||||
IPV6_V6ONLY = 27
|
||||
}
|
||||
|
||||
// macros
|
||||
extern (D) int IN6_IS_ADDR_UNSPECIFIED( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
(cast(uint32_t*) addr)[3] == 0;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_LOOPBACK( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
(cast(uint32_t*) addr)[3] == ntohl( 1 );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MULTICAST( in6_addr* addr )
|
||||
{
|
||||
return addr.s6_addr[0] == 0xff;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_LINKLOCAL( in6_addr* addr )
|
||||
{
|
||||
return addr.s6_addr[0] == 0xfe && (addr.s6_addr[1] & 0xc0) == 0x80;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_SITELOCAL( in6_addr* addr )
|
||||
{
|
||||
return addr.s6_addr[0] == 0xfe && (addr.s6_addr[1] & 0xc0) == 0xc0;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_V4MAPPED( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == ntohl( 0x0000ffff );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_V4COMPAT( in6_addr* addr )
|
||||
{
|
||||
return (cast(uint32_t*) addr)[0] == 0 &&
|
||||
(cast(uint32_t*) addr)[1] == 0 &&
|
||||
(cast(uint32_t*) addr)[2] == 0 &&
|
||||
(cast(uint32_t*) addr)[3] != 0 &&
|
||||
(cast(uint32_t*) addr)[3] != ntohl( 1 );
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_NODELOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x1;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_LINKLOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x2;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_SITELOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST(addr) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x5;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_ORGLOCAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0x8;
|
||||
}
|
||||
|
||||
extern (D) int IN6_IS_ADDR_MC_GLOBAL( in6_addr* addr )
|
||||
{
|
||||
return IN6_IS_ADDR_MULTICAST( addr ) &&
|
||||
((cast(uint8_t*) addr)[1] & 0xf) == 0xe;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Raw Sockets (RS)
|
||||
//
|
||||
/*
|
||||
IPPROTO_RAW
|
||||
*/
|
||||
|
||||
version (linux )
|
||||
{
|
||||
enum uint IPPROTO_RAW = 255;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum uint IPPROTO_RAW = 255;
|
||||
}
|
||||
38
druntime/import/core/sys/posix/netinet/tcp.d
Normal file
38
druntime/import/core/sys/posix/netinet/tcp.d
Normal file
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.netinet.tcp;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
TCP_NODELAY
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum TCP_NODELAY = 1;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum TCP_NODELAY = 1;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum TCP_NODELAY = 1;
|
||||
}
|
||||
141
druntime/import/core/sys/posix/poll.d
Normal file
141
druntime/import/core/sys/posix/poll.d
Normal file
@@ -0,0 +1,141 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.poll;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
struct pollfd
|
||||
{
|
||||
int fd;
|
||||
short events;
|
||||
short revents;
|
||||
}
|
||||
|
||||
nfds_t
|
||||
|
||||
POLLIN
|
||||
POLLRDNORM
|
||||
POLLRDBAND
|
||||
POLLPRI
|
||||
POLLOUT
|
||||
POLLWRNORM
|
||||
POLLWRBAND
|
||||
POLLERR
|
||||
POLLHUP
|
||||
POLLNVAL
|
||||
|
||||
int poll(pollfd[], nfds_t, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct pollfd
|
||||
{
|
||||
int fd;
|
||||
short events;
|
||||
short revents;
|
||||
}
|
||||
|
||||
alias c_ulong nfds_t;
|
||||
|
||||
enum
|
||||
{
|
||||
POLLIN = 0x001,
|
||||
POLLRDNORM = 0x040,
|
||||
POLLRDBAND = 0x080,
|
||||
POLLPRI = 0x002,
|
||||
POLLOUT = 0x004,
|
||||
POLLWRNORM = 0x100,
|
||||
POLLWRBAND = 0x200,
|
||||
POLLERR = 0x008,
|
||||
POLLHUP = 0x010,
|
||||
POLLNVAL = 0x020,
|
||||
}
|
||||
|
||||
int poll(pollfd*, nfds_t, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct pollfd
|
||||
{
|
||||
int fd;
|
||||
short events;
|
||||
short revents;
|
||||
};
|
||||
|
||||
alias uint nfds_t;
|
||||
|
||||
enum
|
||||
{
|
||||
POLLIN = 0x0001,
|
||||
POLLPRI = 0x0002,
|
||||
POLLOUT = 0x0004,
|
||||
POLLRDNORM = 0x0040,
|
||||
POLLWRNORM = POLLOUT,
|
||||
POLLRDBAND = 0x0080,
|
||||
POLLWRBAND = 0x0100,
|
||||
POLLEXTEND = 0x0200,
|
||||
POLLATTRIB = 0x0400,
|
||||
POLLNLINK = 0x0800,
|
||||
POLLWRITE = 0x1000,
|
||||
POLLERR = 0x0008,
|
||||
POLLHUP = 0x0010,
|
||||
POLLNVAL = 0x0020,
|
||||
|
||||
POLLSTANDARD = (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLRDBAND|
|
||||
POLLWRBAND|POLLERR|POLLHUP|POLLNVAL)
|
||||
}
|
||||
|
||||
int poll(pollfd*, nfds_t, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct pollfd
|
||||
{
|
||||
int fd;
|
||||
short events;
|
||||
short revents;
|
||||
};
|
||||
|
||||
alias uint nfds_t;
|
||||
|
||||
enum
|
||||
{
|
||||
POLLIN = 0x0001,
|
||||
POLLPRI = 0x0002,
|
||||
POLLOUT = 0x0004,
|
||||
POLLRDNORM = 0x0040,
|
||||
POLLWRNORM = POLLOUT,
|
||||
POLLRDBAND = 0x0080,
|
||||
POLLWRBAND = 0x0100,
|
||||
//POLLEXTEND = 0x0200,
|
||||
//POLLATTRIB = 0x0400,
|
||||
//POLLNLINK = 0x0800,
|
||||
//POLLWRITE = 0x1000,
|
||||
POLLERR = 0x0008,
|
||||
POLLHUP = 0x0010,
|
||||
POLLNVAL = 0x0020,
|
||||
|
||||
POLLSTANDARD = (POLLIN|POLLPRI|POLLOUT|POLLRDNORM|POLLRDBAND|
|
||||
POLLWRBAND|POLLERR|POLLHUP|POLLNVAL)
|
||||
}
|
||||
|
||||
int poll(pollfd*, nfds_t, int);
|
||||
}
|
||||
585
druntime/import/core/sys/posix/pthread.d
Normal file
585
druntime/import/core/sys/posix/pthread.d
Normal file
@@ -0,0 +1,585 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.pthread;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types;
|
||||
public import core.sys.posix.sched;
|
||||
public import core.sys.posix.time;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
PTHREAD_CANCEL_ASYNCHRONOUS
|
||||
PTHREAD_CANCEL_ENABLE
|
||||
PTHREAD_CANCEL_DEFERRED
|
||||
PTHREAD_CANCEL_DISABLE
|
||||
PTHREAD_CANCELED
|
||||
PTHREAD_COND_INITIALIZER
|
||||
PTHREAD_CREATE_DETACHED
|
||||
PTHREAD_CREATE_JOINABLE
|
||||
PTHREAD_EXPLICIT_SCHED
|
||||
PTHREAD_INHERIT_SCHED
|
||||
PTHREAD_MUTEX_INITIALIZER
|
||||
PTHREAD_ONCE_INIT
|
||||
PTHREAD_PROCESS_SHARED
|
||||
PTHREAD_PROCESS_PRIVATE
|
||||
|
||||
int pthread_atfork(void function(), void function(), void function());
|
||||
int pthread_attr_destroy(pthread_attr_t*);
|
||||
int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
|
||||
int pthread_attr_init(pthread_attr_t*);
|
||||
int pthread_attr_setdetachstate(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
|
||||
int pthread_cancel(pthread_t);
|
||||
void pthread_cleanup_push(void function(void*), void*);
|
||||
void pthread_cleanup_pop(int);
|
||||
int pthread_cond_broadcast(pthread_cond_t*);
|
||||
int pthread_cond_destroy(pthread_cond_t*);
|
||||
int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*);
|
||||
int pthread_cond_signal(pthread_cond_t*);
|
||||
int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
|
||||
int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
|
||||
int pthread_condattr_destroy(pthread_condattr_t*);
|
||||
int pthread_condattr_init(pthread_condattr_t*);
|
||||
int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
|
||||
int pthread_detach(pthread_t);
|
||||
int pthread_equal(pthread_t, pthread_t);
|
||||
void pthread_exit(void*);
|
||||
void* pthread_getspecific(pthread_key_t);
|
||||
int pthread_join(pthread_t, void**);
|
||||
int pthread_key_create(pthread_key_t*, void function(void*));
|
||||
int pthread_key_delete(pthread_key_t);
|
||||
int pthread_mutex_destroy(pthread_mutex_t*);
|
||||
int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
|
||||
int pthread_mutex_lock(pthread_mutex_t*);
|
||||
int pthread_mutex_trylock(pthread_mutex_t*);
|
||||
int pthread_mutex_unlock(pthread_mutex_t*);
|
||||
int pthread_mutexattr_destroy(pthread_mutexattr_t*);
|
||||
int pthread_mutexattr_init(pthread_mutexattr_t*);
|
||||
int pthread_once(pthread_once_t*, void function());
|
||||
int pthread_rwlock_destroy(pthread_rwlock_t*);
|
||||
int pthread_rwlock_init(in pthread_rwlock_t*, pthread_rwlockattr_t*);
|
||||
int pthread_rwlock_rdlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_trywrlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_unlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_wrlock(pthread_rwlock_t*);
|
||||
int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
|
||||
int pthread_rwlockattr_init(pthread_rwlockattr_t*);
|
||||
pthread_t pthread_self();
|
||||
int pthread_setcancelstate(int, int*);
|
||||
int pthread_setcanceltype(int, int*);
|
||||
int pthread_setspecific(pthread_key_t, in void*);
|
||||
void pthread_testcancel();
|
||||
*/
|
||||
version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_CANCEL_ENABLE,
|
||||
PTHREAD_CANCEL_DISABLE
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_CANCEL_DEFERRED,
|
||||
PTHREAD_CANCEL_ASYNCHRONOUS
|
||||
}
|
||||
|
||||
enum PTHREAD_CANCELED = cast(void*) -1;
|
||||
|
||||
//enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_CREATE_JOINABLE,
|
||||
PTHREAD_CREATE_DETACHED
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_INHERIT_SCHED,
|
||||
PTHREAD_EXPLICIT_SCHED
|
||||
}
|
||||
|
||||
//enum pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
|
||||
|
||||
enum PTHREAD_ONCE_INIT = 0;
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_PROCESS_PRIVATE,
|
||||
PTHREAD_PROCESS_SHARED
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_CANCEL_ENABLE = 1,
|
||||
PTHREAD_CANCEL_DISABLE = 0
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_CANCEL_DEFERRED = 2,
|
||||
PTHREAD_CANCEL_ASYNCHRONOUS = 0
|
||||
}
|
||||
|
||||
enum PTHREAD_CANCELED = cast(void*) -1;
|
||||
|
||||
//enum pthread_mutex_t PTHREAD_COND_INITIALIZER = { __LOCK_ALT_INITIALIZER, 0, "", 0 };
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_CREATE_JOINABLE = 1,
|
||||
PTHREAD_CREATE_DETACHED = 2
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_INHERIT_SCHED = 1,
|
||||
PTHREAD_EXPLICIT_SCHED = 2
|
||||
}
|
||||
|
||||
//enum pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
|
||||
|
||||
enum PTHREAD_ONCE_INIT = 0;
|
||||
|
||||
enum
|
||||
{
|
||||
PTHREAD_PROCESS_PRIVATE = 2,
|
||||
PTHREAD_PROCESS_SHARED = 1
|
||||
}
|
||||
}
|
||||
|
||||
int pthread_atfork(void function(), void function(), void function());
|
||||
int pthread_attr_destroy(pthread_attr_t*);
|
||||
int pthread_attr_getdetachstate(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedparam(in pthread_attr_t*, sched_param*);
|
||||
int pthread_attr_init(pthread_attr_t*);
|
||||
int pthread_attr_setdetachstate(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedparam(in pthread_attr_t*, sched_param*);
|
||||
int pthread_cancel(pthread_t);
|
||||
|
||||
version( linux )
|
||||
{
|
||||
alias void function(void*) _pthread_cleanup_routine;
|
||||
|
||||
struct _pthread_cleanup_buffer
|
||||
{
|
||||
_pthread_cleanup_routine __routine;
|
||||
void* __arg;
|
||||
int __canceltype;
|
||||
_pthread_cleanup_buffer* __prev;
|
||||
}
|
||||
|
||||
void _pthread_cleanup_push(_pthread_cleanup_buffer*, _pthread_cleanup_routine, void*);
|
||||
void _pthread_cleanup_pop(_pthread_cleanup_buffer*, int);
|
||||
|
||||
struct pthread_cleanup
|
||||
{
|
||||
_pthread_cleanup_buffer buffer = void;
|
||||
|
||||
void push()( _pthread_cleanup_routine routine, void* arg )
|
||||
{
|
||||
_pthread_cleanup_push( &buffer, routine, arg );
|
||||
}
|
||||
|
||||
void pop()( int execute )
|
||||
{
|
||||
_pthread_cleanup_pop( &buffer, execute );
|
||||
}
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
alias void function(void*) _pthread_cleanup_routine;
|
||||
|
||||
struct _pthread_cleanup_buffer
|
||||
{
|
||||
_pthread_cleanup_routine __routine;
|
||||
void* __arg;
|
||||
_pthread_cleanup_buffer* __next;
|
||||
}
|
||||
|
||||
struct pthread_cleanup
|
||||
{
|
||||
_pthread_cleanup_buffer buffer = void;
|
||||
|
||||
void push()( _pthread_cleanup_routine routine, void* arg )
|
||||
{
|
||||
pthread_t self = pthread_self();
|
||||
buffer.__routine = routine;
|
||||
buffer.__arg = arg;
|
||||
buffer.__next = cast(_pthread_cleanup_buffer*) self.__cleanup_stack;
|
||||
self.__cleanup_stack = cast(pthread_handler_rec*) &buffer;
|
||||
}
|
||||
|
||||
void pop()( int execute )
|
||||
{
|
||||
pthread_t self = pthread_self();
|
||||
self.__cleanup_stack = cast(pthread_handler_rec*) buffer.__next;
|
||||
if( execute )
|
||||
{
|
||||
buffer.__routine( buffer.__arg );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
void pthread_cleanup_push(void function(void*), void*);
|
||||
void pthread_cleanup_pop(int);
|
||||
}
|
||||
|
||||
int pthread_cond_broadcast(pthread_cond_t*);
|
||||
int pthread_cond_destroy(pthread_cond_t*);
|
||||
int pthread_cond_init(in pthread_cond_t*, pthread_condattr_t*);
|
||||
int pthread_cond_signal(pthread_cond_t*);
|
||||
int pthread_cond_timedwait(pthread_cond_t*, pthread_mutex_t*, in timespec*);
|
||||
int pthread_cond_wait(pthread_cond_t*, pthread_mutex_t*);
|
||||
int pthread_condattr_destroy(pthread_condattr_t*);
|
||||
int pthread_condattr_init(pthread_condattr_t*);
|
||||
int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*);
|
||||
int pthread_detach(pthread_t);
|
||||
int pthread_equal(pthread_t, pthread_t);
|
||||
void pthread_exit(void*);
|
||||
void* pthread_getspecific(pthread_key_t);
|
||||
int pthread_join(pthread_t, void**);
|
||||
int pthread_key_create(pthread_key_t*, void function(void*));
|
||||
int pthread_key_delete(pthread_key_t);
|
||||
int pthread_mutex_destroy(pthread_mutex_t*);
|
||||
int pthread_mutex_init(pthread_mutex_t*, pthread_mutexattr_t*);
|
||||
int pthread_mutex_lock(pthread_mutex_t*);
|
||||
int pthread_mutex_trylock(pthread_mutex_t*);
|
||||
int pthread_mutex_unlock(pthread_mutex_t*);
|
||||
int pthread_mutexattr_destroy(pthread_mutexattr_t*);
|
||||
int pthread_mutexattr_init(pthread_mutexattr_t*);
|
||||
int pthread_once(pthread_once_t*, void function());
|
||||
int pthread_rwlock_destroy(pthread_rwlock_t*);
|
||||
int pthread_rwlock_init(in pthread_rwlock_t*, pthread_rwlockattr_t*);
|
||||
int pthread_rwlock_rdlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_tryrdlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_trywrlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_unlock(pthread_rwlock_t*);
|
||||
int pthread_rwlock_wrlock(pthread_rwlock_t*);
|
||||
int pthread_rwlockattr_destroy(pthread_rwlockattr_t*);
|
||||
int pthread_rwlockattr_init(pthread_rwlockattr_t*);
|
||||
pthread_t pthread_self();
|
||||
int pthread_setcancelstate(int, int*);
|
||||
int pthread_setcanceltype(int, int*);
|
||||
int pthread_setspecific(pthread_key_t, in void*);
|
||||
void pthread_testcancel();
|
||||
|
||||
//
|
||||
// Barrier (BAR)
|
||||
//
|
||||
/*
|
||||
PTHREAD_BARRIER_SERIAL_THREAD
|
||||
|
||||
int pthread_barrier_destroy(pthread_barrier_t*);
|
||||
int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
|
||||
int pthread_barrier_wait(pthread_barrier_t*);
|
||||
int pthread_barrierattr_destroy(pthread_barrierattr_t*);
|
||||
int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*); (BAR|TSH)
|
||||
int pthread_barrierattr_init(pthread_barrierattr_t*);
|
||||
int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int); (BAR|TSH)
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum PTHREAD_BARRIER_SERIAL_THREAD = -1;
|
||||
|
||||
int pthread_barrier_destroy(pthread_barrier_t*);
|
||||
int pthread_barrier_init(pthread_barrier_t*, in pthread_barrierattr_t*, uint);
|
||||
int pthread_barrier_wait(pthread_barrier_t*);
|
||||
int pthread_barrierattr_destroy(pthread_barrierattr_t*);
|
||||
int pthread_barrierattr_getpshared(in pthread_barrierattr_t*, int*);
|
||||
int pthread_barrierattr_init(pthread_barrierattr_t*);
|
||||
int pthread_barrierattr_setpshared(pthread_barrierattr_t*, int);
|
||||
}
|
||||
|
||||
//
|
||||
// Clock (CS)
|
||||
//
|
||||
/*
|
||||
int pthread_condattr_getclock(in pthread_condattr_t*, clockid_t*);
|
||||
int pthread_condattr_setclock(pthread_condattr_t*, clockid_t);
|
||||
*/
|
||||
|
||||
//
|
||||
// Spinlock (SPI)
|
||||
//
|
||||
/*
|
||||
int pthread_spin_destroy(pthread_spinlock_t*);
|
||||
int pthread_spin_init(pthread_spinlock_t*, int);
|
||||
int pthread_spin_lock(pthread_spinlock_t*);
|
||||
int pthread_spin_trylock(pthread_spinlock_t*);
|
||||
int pthread_spin_unlock(pthread_spinlock_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int pthread_spin_destroy(pthread_spinlock_t*);
|
||||
int pthread_spin_init(pthread_spinlock_t*, int);
|
||||
int pthread_spin_lock(pthread_spinlock_t*);
|
||||
int pthread_spin_trylock(pthread_spinlock_t*);
|
||||
int pthread_spin_unlock(pthread_spinlock_t*);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
PTHREAD_MUTEX_DEFAULT
|
||||
PTHREAD_MUTEX_ERRORCHECK
|
||||
PTHREAD_MUTEX_NORMAL
|
||||
PTHREAD_MUTEX_RECURSIVE
|
||||
|
||||
int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setguardsize(pthread_attr_t*, size_t);
|
||||
int pthread_getconcurrency();
|
||||
int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
|
||||
int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
|
||||
int pthread_setconcurrency(int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum PTHREAD_MUTEX_NORMAL = 0;
|
||||
enum PTHREAD_MUTEX_RECURSIVE = 1;
|
||||
enum PTHREAD_MUTEX_ERRORCHECK = 2;
|
||||
enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
|
||||
|
||||
int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setguardsize(pthread_attr_t*, size_t);
|
||||
int pthread_getconcurrency();
|
||||
int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
|
||||
int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
|
||||
int pthread_setconcurrency(int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum PTHREAD_MUTEX_NORMAL = 0;
|
||||
enum PTHREAD_MUTEX_ERRORCHECK = 1;
|
||||
enum PTHREAD_MUTEX_RECURSIVE = 2;
|
||||
enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL;
|
||||
|
||||
int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setguardsize(pthread_attr_t*, size_t);
|
||||
int pthread_getconcurrency();
|
||||
int pthread_mutexattr_gettype(in pthread_mutexattr_t*, int*);
|
||||
int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
|
||||
int pthread_setconcurrency(int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_MUTEX_ERRORCHECK = 1,
|
||||
PTHREAD_MUTEX_RECURSIVE = 2,
|
||||
PTHREAD_MUTEX_NORMAL = 3,
|
||||
PTHREAD_MUTEX_ADAPTIVE_NP = 4,
|
||||
PTHREAD_MUTEX_TYPE_MAX
|
||||
}
|
||||
enum PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_ERRORCHECK;
|
||||
|
||||
int pthread_attr_getguardsize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setguardsize(pthread_attr_t*, size_t);
|
||||
int pthread_getconcurrency();
|
||||
int pthread_mutexattr_gettype(pthread_mutexattr_t*, int*);
|
||||
int pthread_mutexattr_settype(pthread_mutexattr_t*, int);
|
||||
int pthread_setconcurrency(int);
|
||||
}
|
||||
|
||||
//
|
||||
// CPU Time (TCT)
|
||||
//
|
||||
/*
|
||||
int pthread_getcpuclockid(pthread_t, clockid_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int pthread_getcpuclockid(pthread_t, clockid_t*);
|
||||
}
|
||||
|
||||
//
|
||||
// Timeouts (TMO)
|
||||
//
|
||||
/*
|
||||
int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
|
||||
int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
|
||||
int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
|
||||
int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
|
||||
int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int pthread_mutex_timedlock(pthread_mutex_t*, timespec*);
|
||||
int pthread_rwlock_timedrdlock(pthread_rwlock_t*, in timespec*);
|
||||
int pthread_rwlock_timedwrlock(pthread_rwlock_t*, in timespec*);
|
||||
}
|
||||
|
||||
//
|
||||
// Priority (TPI|TPP)
|
||||
//
|
||||
/*
|
||||
PTHREAD_PRIO_INHERIT (TPI)
|
||||
PTHREAD_PRIO_NONE (TPP|TPI)
|
||||
PTHREAD_PRIO_PROTECT (TPI)
|
||||
|
||||
int pthread_mutex_getprioceiling(in pthread_mutex_t*, int*); (TPP)
|
||||
int pthread_mutex_setprioceiling(pthread_mutex_t*, int, int*); (TPP)
|
||||
int pthread_mutexattr_getprioceiling(pthread_mutexattr_t*, int*); (TPP)
|
||||
int pthread_mutexattr_getprotocol(in pthread_mutexattr_t*, int*); (TPI|TPP)
|
||||
int pthread_mutexattr_setprioceiling(pthread_mutexattr_t*, int); (TPP)
|
||||
int pthread_mutexattr_setprotocol(pthread_mutexattr_t*, int); (TPI|TPP)
|
||||
*/
|
||||
|
||||
//
|
||||
// Scheduling (TPS)
|
||||
//
|
||||
/*
|
||||
PTHREAD_SCOPE_PROCESS
|
||||
PTHREAD_SCOPE_SYSTEM
|
||||
|
||||
int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getscope(in pthread_attr_t*, int*);
|
||||
int pthread_attr_setinheritsched(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedpolicy(pthread_attr_t*, int);
|
||||
int pthread_attr_setscope(pthread_attr_t*, int);
|
||||
int pthread_getschedparam(pthread_t, int*, sched_param*);
|
||||
int pthread_setschedparam(pthread_t, int, in sched_param*);
|
||||
int pthread_setschedprio(pthread_t, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_SCOPE_SYSTEM,
|
||||
PTHREAD_SCOPE_PROCESS
|
||||
}
|
||||
|
||||
int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getscope(in pthread_attr_t*, int*);
|
||||
int pthread_attr_setinheritsched(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedpolicy(pthread_attr_t*, int);
|
||||
int pthread_attr_setscope(pthread_attr_t*, int);
|
||||
int pthread_getschedparam(pthread_t, int*, sched_param*);
|
||||
int pthread_setschedparam(pthread_t, int, in sched_param*);
|
||||
//int pthread_setschedprio(pthread_t, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_SCOPE_SYSTEM = 1,
|
||||
PTHREAD_SCOPE_PROCESS = 2
|
||||
}
|
||||
|
||||
int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getscope(in pthread_attr_t*, int*);
|
||||
int pthread_attr_setinheritsched(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedpolicy(pthread_attr_t*, int);
|
||||
int pthread_attr_setscope(pthread_attr_t*, int);
|
||||
int pthread_getschedparam(pthread_t, int*, sched_param*);
|
||||
int pthread_setschedparam(pthread_t, int, in sched_param*);
|
||||
//int pthread_setschedprio(pthread_t, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
PTHREAD_SCOPE_PROCESS = 0,
|
||||
PTHREAD_SCOPE_SYSTEM = 0x2
|
||||
}
|
||||
|
||||
int pthread_attr_getinheritsched(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getschedpolicy(in pthread_attr_t*, int*);
|
||||
int pthread_attr_getscope(in pthread_attr_t*, int*);
|
||||
int pthread_attr_setinheritsched(pthread_attr_t*, int);
|
||||
int pthread_attr_setschedpolicy(pthread_attr_t*, int);
|
||||
int pthread_attr_setscope(in pthread_attr_t*, int);
|
||||
int pthread_getschedparam(pthread_t, int*, sched_param*);
|
||||
int pthread_setschedparam(pthread_t, int, sched_param*);
|
||||
//int pthread_setschedprio(pthread_t, int);
|
||||
}
|
||||
|
||||
//
|
||||
// Stack (TSA|TSS)
|
||||
//
|
||||
/*
|
||||
int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*); (TSA|TSS)
|
||||
int pthread_attr_getstackaddr(in pthread_attr_t*, void**); (TSA)
|
||||
int pthread_attr_getstacksize(in pthread_attr_t*, size_t*); (TSS)
|
||||
int pthread_attr_setstack(pthread_attr_t*, void*, size_t); (TSA|TSS)
|
||||
int pthread_attr_setstackaddr(pthread_attr_t*, void*); (TSA)
|
||||
int pthread_attr_setstacksize(pthread_attr_t*, size_t); (TSS)
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
|
||||
int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
|
||||
int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
|
||||
int pthread_attr_setstackaddr(pthread_attr_t*, void*);
|
||||
int pthread_attr_setstacksize(pthread_attr_t*, size_t);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
|
||||
int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
|
||||
int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
|
||||
int pthread_attr_setstackaddr(pthread_attr_t*, void*);
|
||||
int pthread_attr_setstacksize(pthread_attr_t*, size_t);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int pthread_attr_getstack(in pthread_attr_t*, void**, size_t*);
|
||||
int pthread_attr_getstackaddr(in pthread_attr_t*, void**);
|
||||
int pthread_attr_getstacksize(in pthread_attr_t*, size_t*);
|
||||
int pthread_attr_setstack(pthread_attr_t*, void*, size_t);
|
||||
int pthread_attr_setstackaddr(pthread_attr_t*, void*);
|
||||
int pthread_attr_setstacksize(pthread_attr_t*, size_t);
|
||||
}
|
||||
|
||||
//
|
||||
// Shared Synchronization (TSH)
|
||||
//
|
||||
/*
|
||||
int pthread_condattr_getpshared(in pthread_condattr_t*, int*);
|
||||
int pthread_condattr_setpshared(pthread_condattr_t*, int);
|
||||
int pthread_mutexattr_getpshared(in pthread_mutexattr_t*, int*);
|
||||
int pthread_mutexattr_setpshared(pthread_mutexattr_t*, int);
|
||||
int pthread_rwlockattr_getpshared(in pthread_rwlockattr_t*, int*);
|
||||
int pthread_rwlockattr_setpshared(pthread_rwlockattr_t*, int);
|
||||
*/
|
||||
137
druntime/import/core/sys/posix/pwd.d
Normal file
137
druntime/import/core/sys/posix/pwd.d
Normal file
@@ -0,0 +1,137 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.pwd;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for gid_t, uid_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct passwd
|
||||
{
|
||||
char* pw_name;
|
||||
uid_t pw_uid;
|
||||
gid_t pw_gid;
|
||||
char* pw_dir;
|
||||
char* pw_shell;
|
||||
}
|
||||
|
||||
passwd* getpwnam(in char*);
|
||||
passwd* getpwuid(uid_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct passwd
|
||||
{
|
||||
char* pw_name;
|
||||
char* pw_passwd;
|
||||
uid_t pw_uid;
|
||||
gid_t pw_gid;
|
||||
char* pw_gecos;
|
||||
char* pw_dir;
|
||||
char* pw_shell;
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct passwd
|
||||
{
|
||||
char* pw_name;
|
||||
char* pw_passwd;
|
||||
uid_t pw_uid;
|
||||
gid_t pw_gid;
|
||||
time_t pw_change;
|
||||
char* pw_class;
|
||||
char* pw_gecos;
|
||||
char* pw_dir;
|
||||
char* pw_shell;
|
||||
time_t pw_expire;
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct passwd
|
||||
{
|
||||
char* pw_name; /* user name */
|
||||
char* pw_passwd; /* encrypted password */
|
||||
uid_t pw_uid; /* user uid */
|
||||
gid_t pw_gid; /* user gid */
|
||||
time_t pw_change; /* password change time */
|
||||
char* pw_class; /* user access class */
|
||||
char* pw_gecos; /* Honeywell login info */
|
||||
char* pw_dir; /* home directory */
|
||||
char* pw_shell; /* default shell */
|
||||
time_t pw_expire; /* account expiration */
|
||||
int pw_fields; /* internal: fields filled in */
|
||||
}
|
||||
}
|
||||
|
||||
passwd* getpwnam(in char*);
|
||||
passwd* getpwuid(uid_t);
|
||||
|
||||
//
|
||||
// Thread-Safe Functions (TSF)
|
||||
//
|
||||
/*
|
||||
int getpwnam_r(in char*, passwd*, char*, size_t, passwd**);
|
||||
int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int getpwnam_r(in char*, passwd*, char*, size_t, passwd**);
|
||||
int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int getpwnam_r(in char*, passwd*, char*, size_t, passwd**);
|
||||
int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int getpwnam_r(in char*, passwd*, char*, size_t, passwd**);
|
||||
int getpwuid_r(uid_t, passwd*, char*, size_t, passwd**);
|
||||
}
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
void endpwent();
|
||||
passwd* getpwent();
|
||||
void setpwent();
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
void endpwent();
|
||||
passwd* getpwent();
|
||||
void setpwent();
|
||||
}
|
||||
else version ( OSX )
|
||||
{
|
||||
void endpwent();
|
||||
passwd* getpwent();
|
||||
void setpwent();
|
||||
}
|
||||
else version ( freebsd )
|
||||
{
|
||||
void endpwent();
|
||||
passwd* getpwent();
|
||||
void setpwent();
|
||||
}
|
||||
137
druntime/import/core/sys/posix/sched.d
Normal file
137
druntime/import/core/sys/posix/sched.d
Normal file
@@ -0,0 +1,137 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sched;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.time;
|
||||
public import core.sys.posix.sys.types;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct sched_param
|
||||
{
|
||||
int sched_priority (THR)
|
||||
int sched_ss_low_priority (SS|TSP)
|
||||
struct timespec sched_ss_repl_period (SS|TSP)
|
||||
struct timespec sched_ss_init_budget (SS|TSP)
|
||||
int sched_ss_max_repl (SS|TSP)
|
||||
}
|
||||
|
||||
SCHED_FIFO
|
||||
SCHED_RR
|
||||
SCHED_SPORADIC (SS|TSP)
|
||||
SCHED_OTHER
|
||||
|
||||
int sched_getparam(pid_t, sched_param*);
|
||||
int sched_getscheduler(pid_t);
|
||||
int sched_setparam(pid_t, in sched_param*);
|
||||
int sched_setscheduler(pid_t, int, in sched_param*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct sched_param
|
||||
{
|
||||
int sched_priority;
|
||||
}
|
||||
|
||||
enum SCHED_OTHER = 0;
|
||||
enum SCHED_FIFO = 1;
|
||||
enum SCHED_RR = 2;
|
||||
//SCHED_SPORADIC (SS|TSP)
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum SCHED_OTHER = 1;
|
||||
enum SCHED_FIFO = 4;
|
||||
enum SCHED_RR = 2;
|
||||
//SCHED_SPORADIC (SS|TSP)
|
||||
|
||||
private enum __SCHED_PARAM_SIZE__ = 4;
|
||||
|
||||
struct sched_param
|
||||
{
|
||||
int sched_priority;
|
||||
byte[__PTHREAD_MUTEX_SIZE__] __opaque;
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct sched_param
|
||||
{
|
||||
int sched_priority;
|
||||
}
|
||||
|
||||
enum SCHED_FIFO = 1;
|
||||
enum SCHED_OTHER = 2;
|
||||
enum SCHED_RR = 3;
|
||||
//SCHED_SPORADIC (SS|TSP)
|
||||
}
|
||||
|
||||
int sched_getparam(pid_t, sched_param*);
|
||||
int sched_getscheduler(pid_t);
|
||||
int sched_setparam(pid_t, in sched_param*);
|
||||
int sched_setscheduler(pid_t, int, in sched_param*);
|
||||
|
||||
//
|
||||
// Thread (THR)
|
||||
//
|
||||
/*
|
||||
int sched_yield();
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int sched_yield();
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int sched_yield();
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int sched_yield();
|
||||
}
|
||||
|
||||
//
|
||||
// Scheduling (TPS)
|
||||
//
|
||||
/*
|
||||
int sched_get_priority_max(int);
|
||||
int sched_get_priority_min(int);
|
||||
int sched_rr_get_interval(pid_t, timespec*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int sched_get_priority_max(int);
|
||||
int sched_get_priority_min(int);
|
||||
int sched_rr_get_interval(pid_t, timespec*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int sched_get_priority_min(int);
|
||||
int sched_get_priority_max(int);
|
||||
//int sched_rr_get_interval(pid_t, timespec*); // FIXME: unavailable?
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int sched_get_priority_min(int);
|
||||
int sched_get_priority_max(int);
|
||||
int sched_rr_get_interval(pid_t, timespec*);
|
||||
}
|
||||
102
druntime/import/core/sys/posix/semaphore.d
Normal file
102
druntime/import/core/sys/posix/semaphore.d
Normal file
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.semaphore;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.sys.posix.time;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
sem_t
|
||||
SEM_FAILED
|
||||
|
||||
int sem_close(sem_t*);
|
||||
int sem_destroy(sem_t*);
|
||||
int sem_getvalue(sem_t*, int*);
|
||||
int sem_init(sem_t*, int, uint);
|
||||
sem_t* sem_open(in char*, int, ...);
|
||||
int sem_post(sem_t*);
|
||||
int sem_trywait(sem_t*);
|
||||
int sem_unlink(in char*);
|
||||
int sem_wait(sem_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
private alias int __atomic_lock_t;
|
||||
|
||||
private struct _pthread_fastlock
|
||||
{
|
||||
c_long __status;
|
||||
__atomic_lock_t __spinlock;
|
||||
}
|
||||
|
||||
struct sem_t
|
||||
{
|
||||
_pthread_fastlock __sem_lock;
|
||||
int __sem_value;
|
||||
void* __sem_waiting;
|
||||
}
|
||||
|
||||
enum SEM_FAILED = cast(sem_t*) null;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
alias int sem_t;
|
||||
|
||||
enum SEM_FAILED = cast(sem_t*) null;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum SEM_MAGIC = 0x09fa4012;
|
||||
enum SEM_USER = 0;
|
||||
|
||||
alias void* sem_t;
|
||||
|
||||
enum SEM_FAILED = cast(sem_t*) null;
|
||||
}
|
||||
|
||||
int sem_close(sem_t*);
|
||||
int sem_destroy(sem_t*);
|
||||
int sem_getvalue(sem_t*, int*);
|
||||
int sem_init(sem_t*, int, uint);
|
||||
sem_t* sem_open(in char*, int, ...);
|
||||
int sem_post(sem_t*);
|
||||
int sem_trywait(sem_t*);
|
||||
int sem_unlink(in char*);
|
||||
int sem_wait(sem_t*);
|
||||
|
||||
//
|
||||
// Timeouts (TMO)
|
||||
//
|
||||
/*
|
||||
int sem_timedwait(sem_t*, in timespec*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int sem_timedwait(sem_t*, in timespec*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int sem_timedwait(sem_t*, in timespec*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int sem_timedwait(sem_t*, in timespec*);
|
||||
}
|
||||
108
druntime/import/core/sys/posix/setjmp.d
Normal file
108
druntime/import/core/sys/posix/setjmp.d
Normal file
@@ -0,0 +1,108 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.setjmp;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.sys.posix.signal; // for sigset_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
jmp_buf
|
||||
|
||||
int setjmp(jmp_buf);
|
||||
void longjmp(jmp_buf, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
version( X86_64 )
|
||||
{
|
||||
//enum JB_BX = 0;
|
||||
//enum JB_BP = 1;
|
||||
//enum JB_12 = 2;
|
||||
//enum JB_13 = 3;
|
||||
//enum JB_14 = 4;
|
||||
//enum JB_15 = 5;
|
||||
//enum JB_SP = 6;
|
||||
//enum JB_PC = 7;
|
||||
//enum JB_SIZE = 64;
|
||||
|
||||
alias long[8] __jmp_buf;
|
||||
}
|
||||
else version( X86 )
|
||||
{
|
||||
//enum JB_BX = 0;
|
||||
//enum JB_SI = 1;
|
||||
//enum JB_DI = 2;
|
||||
//enum JB_BP = 3;
|
||||
//enum JB_SP = 4;
|
||||
//enum JB_PC = 5;
|
||||
//enum JB_SIZE = 24;
|
||||
|
||||
alias int[6] __jmp_buf;
|
||||
}
|
||||
else version ( SPARC )
|
||||
{
|
||||
alias int[3] __jmp_buf;
|
||||
}
|
||||
|
||||
struct __jmp_buf_tag
|
||||
{
|
||||
__jmp_buf __jmpbuf;
|
||||
int __mask_was_saved;
|
||||
sigset_t __saved_mask;
|
||||
}
|
||||
|
||||
alias __jmp_buf_tag[1] jmp_buf;
|
||||
|
||||
alias _setjmp setjmp; // see XOpen block
|
||||
void longjmp(jmp_buf, int);
|
||||
}
|
||||
|
||||
//
|
||||
// C Extension (CX)
|
||||
//
|
||||
/*
|
||||
sigjmp_buf
|
||||
|
||||
int sigsetjmp(sigjmp_buf, int);
|
||||
void siglongjmp(sigjmp_buf, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
alias jmp_buf sigjmp_buf;
|
||||
|
||||
int __sigsetjmp(sigjmp_buf, int);
|
||||
alias __sigsetjmp sigsetjmp;
|
||||
void siglongjmp(sigjmp_buf, int);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
int _setjmp(jmp_buf);
|
||||
void _longjmp(jmp_buf, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int _setjmp(jmp_buf);
|
||||
void _longjmp(jmp_buf, int);
|
||||
}
|
||||
843
druntime/import/core/sys/posix/signal.d
Normal file
843
druntime/import/core/sys/posix/signal.d
Normal file
@@ -0,0 +1,843 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.signal;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.signal;
|
||||
public import core.stdc.stddef; // for size_t
|
||||
public import core.sys.posix.sys.types; // for pid_t
|
||||
//public import core.sys.posix.time; // for timespec, now defined here
|
||||
|
||||
extern (C):
|
||||
|
||||
private alias void function(int) sigfn_t;
|
||||
private alias void function(int, siginfo_t*, void*) sigactfn_t;
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
SIG_DFL (defined in core.stdc.signal)
|
||||
SIG_ERR (defined in core.stdc.signal)
|
||||
SIG_IGN (defined in core.stdc.signal)
|
||||
|
||||
sig_atomic_t (defined in core.stdc.signal)
|
||||
|
||||
SIGEV_NONE
|
||||
SIGEV_SIGNAL
|
||||
SIGEV_THREAD
|
||||
|
||||
union sigval
|
||||
{
|
||||
int sival_int;
|
||||
void* sival_ptr;
|
||||
}
|
||||
|
||||
SIGRTMIN
|
||||
SIGRTMAX
|
||||
|
||||
SIGABRT (defined in core.stdc.signal)
|
||||
SIGALRM
|
||||
SIGBUS
|
||||
SIGCHLD
|
||||
SIGCONT
|
||||
SIGFPE (defined in core.stdc.signal)
|
||||
SIGHUP
|
||||
SIGILL (defined in core.stdc.signal)
|
||||
SIGINT (defined in core.stdc.signal)
|
||||
SIGKILL
|
||||
SIGPIPE
|
||||
SIGQUIT
|
||||
SIGSEGV (defined in core.stdc.signal)
|
||||
SIGSTOP
|
||||
SIGTERM (defined in core.stdc.signal)
|
||||
SIGTSTP
|
||||
SIGTTIN
|
||||
SIGTTOU
|
||||
SIGUSR1
|
||||
SIGUSR2
|
||||
SIGURG
|
||||
|
||||
struct sigaction_t
|
||||
{
|
||||
sigfn_t sa_handler;
|
||||
sigset_t sa_mask;
|
||||
sigactfn_t sa_sigaction;
|
||||
}
|
||||
|
||||
sigfn_t signal(int sig, sigfn_t func); (defined in core.stdc.signal)
|
||||
int raise(int sig); (defined in core.stdc.signal)
|
||||
*/
|
||||
|
||||
//SIG_DFL (defined in core.stdc.signal)
|
||||
//SIG_ERR (defined in core.stdc.signal)
|
||||
//SIG_IGN (defined in core.stdc.signal)
|
||||
|
||||
//sig_atomic_t (defined in core.stdc.signal)
|
||||
|
||||
enum
|
||||
{
|
||||
SIGEV_SIGNAL,
|
||||
SIGEV_NONE,
|
||||
SIGEV_THREAD
|
||||
}
|
||||
|
||||
union sigval
|
||||
{
|
||||
int sival_int;
|
||||
void* sival_ptr;
|
||||
}
|
||||
|
||||
private extern (C) int __libc_current_sigrtmin();
|
||||
private extern (C) int __libc_current_sigrtmax();
|
||||
|
||||
alias __libc_current_sigrtmin SIGRTMIN;
|
||||
alias __libc_current_sigrtmax SIGRTMAX;
|
||||
|
||||
version( linux )
|
||||
{
|
||||
//SIGABRT (defined in core.stdc.signal)
|
||||
enum SIGALRM = 14;
|
||||
enum SIGBUS = 7;
|
||||
enum SIGCHLD = 17;
|
||||
enum SIGCONT = 18;
|
||||
//SIGFPE (defined in core.stdc.signal)
|
||||
enum SIGHUP = 1;
|
||||
//SIGILL (defined in core.stdc.signal)
|
||||
//SIGINT (defined in core.stdc.signal)
|
||||
enum SIGKILL = 9;
|
||||
enum SIGPIPE = 13;
|
||||
enum SIGQUIT = 3;
|
||||
//SIGSEGV (defined in core.stdc.signal)
|
||||
enum SIGSTOP = 19;
|
||||
//SIGTERM (defined in core.stdc.signal)
|
||||
enum SIGTSTP = 20;
|
||||
enum SIGTTIN = 21;
|
||||
enum SIGTTOU = 22;
|
||||
enum SIGUSR1 = 10;
|
||||
enum SIGUSR2 = 12;
|
||||
enum SIGURG = 23;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
//SIGABRT (defined in core.stdc.signal)
|
||||
enum SIGALRM = 14;
|
||||
enum SIGBUS = 10;
|
||||
enum SIGCHLD = 20;
|
||||
enum SIGCONT = 19;
|
||||
//SIGFPE (defined in core.stdc.signal)
|
||||
enum SIGHUP = 1;
|
||||
//SIGILL (defined in core.stdc.signal)
|
||||
//SIGINT (defined in core.stdc.signal)
|
||||
enum SIGKILL = 9;
|
||||
enum SIGPIPE = 13;
|
||||
enum SIGQUIT = 3;
|
||||
//SIGSEGV (defined in core.stdc.signal)
|
||||
enum SIGSTOP = 17;
|
||||
//SIGTERM (defined in core.stdc.signal)
|
||||
enum SIGTSTP = 18;
|
||||
enum SIGTTIN = 21;
|
||||
enum SIGTTOU = 22;
|
||||
enum SIGUSR1 = 30;
|
||||
enum SIGUSR2 = 31;
|
||||
enum SIGURG = 16;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
//SIGABRT (defined in core.stdc.signal)
|
||||
enum SIGALRM = 14;
|
||||
enum SIGBUS = 10;
|
||||
enum SIGCHLD = 20;
|
||||
enum SIGCONT = 19;
|
||||
//SIGFPE (defined in core.stdc.signal)
|
||||
enum SIGHUP = 1;
|
||||
//SIGILL (defined in core.stdc.signal)
|
||||
//SIGINT (defined in core.stdc.signal)
|
||||
enum SIGKILL = 9;
|
||||
enum SIGPIPE = 13;
|
||||
enum SIGQUIT = 3;
|
||||
//SIGSEGV (defined in core.stdc.signal)
|
||||
enum SIGSTOP = 17;
|
||||
//SIGTERM (defined in core.stdc.signal)
|
||||
enum SIGTSTP = 18;
|
||||
enum SIGTTIN = 21;
|
||||
enum SIGTTOU = 22;
|
||||
enum SIGUSR1 = 30;
|
||||
enum SIGUSR2 = 31;
|
||||
enum SIGURG = 16;
|
||||
}
|
||||
|
||||
struct sigaction_t
|
||||
{
|
||||
static if( true /* __USE_POSIX199309 */ )
|
||||
{
|
||||
union
|
||||
{
|
||||
sigfn_t sa_handler;
|
||||
sigactfn_t sa_sigaction;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
sigfn_t sa_handler;
|
||||
}
|
||||
sigset_t sa_mask;
|
||||
int sa_flags;
|
||||
|
||||
version( OSX ) {} else {
|
||||
void function() sa_restorer;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// C Extension (CX)
|
||||
//
|
||||
/*
|
||||
SIG_HOLD
|
||||
|
||||
sigset_t
|
||||
pid_t (defined in core.sys.types)
|
||||
|
||||
SIGABRT (defined in core.stdc.signal)
|
||||
SIGFPE (defined in core.stdc.signal)
|
||||
SIGILL (defined in core.stdc.signal)
|
||||
SIGINT (defined in core.stdc.signal)
|
||||
SIGSEGV (defined in core.stdc.signal)
|
||||
SIGTERM (defined in core.stdc.signal)
|
||||
|
||||
SA_NOCLDSTOP (CX|XSI)
|
||||
SIG_BLOCK
|
||||
SIG_UNBLOCK
|
||||
SIG_SETMASK
|
||||
|
||||
struct siginfo_t
|
||||
{
|
||||
int si_signo;
|
||||
int si_code;
|
||||
|
||||
version( XSI )
|
||||
{
|
||||
int si_errno;
|
||||
pid_t si_pid;
|
||||
uid_t si_uid;
|
||||
void* si_addr;
|
||||
int si_status;
|
||||
c_long si_band;
|
||||
}
|
||||
version( RTS )
|
||||
{
|
||||
sigval si_value;
|
||||
}
|
||||
}
|
||||
|
||||
SI_USER
|
||||
SI_QUEUE
|
||||
SI_TIMER
|
||||
SI_ASYNCIO
|
||||
SI_MESGQ
|
||||
|
||||
int kill(pid_t, int);
|
||||
int sigaction(int, in sigaction_t*, sigaction_t*);
|
||||
int sigaddset(sigset_t*, int);
|
||||
int sigdelset(sigset_t*, int);
|
||||
int sigemptyset(sigset_t*);
|
||||
int sigfillset(sigset_t*);
|
||||
int sigismember(in sigset_t*, int);
|
||||
int sigpending(sigset_t*);
|
||||
int sigprocmask(int, in sigset_t*, sigset_t*);
|
||||
int sigsuspend(in sigset_t*);
|
||||
int sigwait(in sigset_t*, int*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum SIG_HOLD = cast(sigfn_t) 1;
|
||||
|
||||
private enum _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof);
|
||||
|
||||
struct sigset_t
|
||||
{
|
||||
c_ulong[_SIGSET_NWORDS] __val;
|
||||
}
|
||||
|
||||
// pid_t (defined in core.sys.types)
|
||||
|
||||
//SIGABRT (defined in core.stdc.signal)
|
||||
//SIGFPE (defined in core.stdc.signal)
|
||||
//SIGILL (defined in core.stdc.signal)
|
||||
//SIGINT (defined in core.stdc.signal)
|
||||
//SIGSEGV (defined in core.stdc.signal)
|
||||
//SIGTERM (defined in core.stdc.signal)
|
||||
|
||||
enum SA_NOCLDSTOP = 1; // (CX|XSI)
|
||||
|
||||
enum SIG_BLOCK = 0;
|
||||
enum SIG_UNBLOCK = 1;
|
||||
enum SIG_SETMASK = 2;
|
||||
|
||||
private enum __SI_MAX_SIZE = 128;
|
||||
|
||||
static if( false /* __WORDSIZE == 64 */ )
|
||||
{
|
||||
private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3);
|
||||
}
|
||||
|
||||
struct siginfo_t
|
||||
{
|
||||
int si_signo; // Signal number
|
||||
int si_errno; // If non-zero, an errno value associated with
|
||||
// this signal, as defined in <errno.h>
|
||||
int si_code; // Signal code
|
||||
|
||||
union _sifields_t
|
||||
{
|
||||
int _pad[__SI_PAD_SIZE];
|
||||
|
||||
// kill()
|
||||
struct _kill_t
|
||||
{
|
||||
pid_t si_pid; // Sending process ID
|
||||
uid_t si_uid; // Real user ID of sending process
|
||||
} _kill_t _kill;
|
||||
|
||||
// POSIX.1b timers.
|
||||
struct _timer_t
|
||||
{
|
||||
int si_tid; // Timer ID
|
||||
int si_overrun; // Overrun count
|
||||
sigval si_sigval; // Signal value
|
||||
} _timer_t _timer;
|
||||
|
||||
// POSIX.1b signals
|
||||
struct _rt_t
|
||||
{
|
||||
pid_t si_pid; // Sending process ID
|
||||
uid_t si_uid; // Real user ID of sending process
|
||||
sigval si_sigval; // Signal value
|
||||
} _rt_t _rt;
|
||||
|
||||
// SIGCHLD
|
||||
struct _sigchild_t
|
||||
{
|
||||
pid_t si_pid; // Which child
|
||||
uid_t si_uid; // Real user ID of sending process
|
||||
int si_status; // Exit value or signal
|
||||
clock_t si_utime;
|
||||
clock_t si_stime;
|
||||
} _sigchild_t _sigchld;
|
||||
|
||||
// SIGILL, SIGFPE, SIGSEGV, SIGBUS
|
||||
struct _sigfault_t
|
||||
{
|
||||
void* si_addr; // Faulting insn/memory ref
|
||||
} _sigfault_t _sigfault;
|
||||
|
||||
// SIGPOLL
|
||||
struct _sigpoll_t
|
||||
{
|
||||
c_long si_band; // Band event for SIGPOLL
|
||||
int si_fd;
|
||||
} _sigpoll_t _sigpoll;
|
||||
} _sifields_t _sifields;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SI_ASYNCNL = -60,
|
||||
SI_TKILL = -6,
|
||||
SI_SIGIO,
|
||||
SI_ASYNCIO,
|
||||
SI_MESGQ,
|
||||
SI_TIMER,
|
||||
SI_QUEUE,
|
||||
SI_USER,
|
||||
SI_KERNEL = 0x80
|
||||
}
|
||||
|
||||
int kill(pid_t, int);
|
||||
int sigaction(int, in sigaction_t*, sigaction_t*);
|
||||
int sigaddset(sigset_t*, int);
|
||||
int sigdelset(sigset_t*, int);
|
||||
int sigemptyset(sigset_t*);
|
||||
int sigfillset(sigset_t*);
|
||||
int sigismember(in sigset_t*, int);
|
||||
int sigpending(sigset_t*);
|
||||
int sigprocmask(int, in sigset_t*, sigset_t*);
|
||||
int sigsuspend(in sigset_t*);
|
||||
int sigwait(in sigset_t*, int*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
//SIG_HOLD
|
||||
|
||||
alias uint sigset_t;
|
||||
// pid_t (defined in core.sys.types)
|
||||
|
||||
//SIGABRT (defined in core.stdc.signal)
|
||||
//SIGFPE (defined in core.stdc.signal)
|
||||
//SIGILL (defined in core.stdc.signal)
|
||||
//SIGINT (defined in core.stdc.signal)
|
||||
//SIGSEGV (defined in core.stdc.signal)
|
||||
//SIGTERM (defined in core.stdc.signal)
|
||||
|
||||
//SA_NOCLDSTOP (CX|XSI)
|
||||
|
||||
//SIG_BLOCK
|
||||
//SIG_UNBLOCK
|
||||
//SIG_SETMASK
|
||||
|
||||
struct siginfo_t
|
||||
{
|
||||
int si_signo;
|
||||
int si_errno;
|
||||
int si_code;
|
||||
pid_t si_pid;
|
||||
uid_t si_uid;
|
||||
int si_status;
|
||||
void* si_addr;
|
||||
sigval si_value;
|
||||
int si_band;
|
||||
uint pad[7];
|
||||
}
|
||||
|
||||
//SI_USER
|
||||
//SI_QUEUE
|
||||
//SI_TIMER
|
||||
//SI_ASYNCIO
|
||||
//SI_MESGQ
|
||||
|
||||
int kill(pid_t, int);
|
||||
int sigaction(int, in sigaction_t*, sigaction_t*);
|
||||
int sigaddset(sigset_t*, int);
|
||||
int sigdelset(sigset_t*, int);
|
||||
int sigemptyset(sigset_t*);
|
||||
int sigfillset(sigset_t*);
|
||||
int sigismember(in sigset_t*, int);
|
||||
int sigpending(sigset_t*);
|
||||
int sigprocmask(int, in sigset_t*, sigset_t*);
|
||||
int sigsuspend(in sigset_t*);
|
||||
int sigwait(in sigset_t*, int*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct sigset_t
|
||||
{
|
||||
uint __bits[4];
|
||||
}
|
||||
|
||||
struct siginfo_t
|
||||
{
|
||||
int si_signo;
|
||||
int si_errno;
|
||||
int si_code;
|
||||
pid_t si_pid;
|
||||
uid_t si_uid;
|
||||
int si_status;
|
||||
void* si_addr;
|
||||
sigval si_value;
|
||||
union __reason
|
||||
{
|
||||
struct __fault
|
||||
{
|
||||
int _trapno;
|
||||
}
|
||||
__fault _fault;
|
||||
struct __timer
|
||||
{
|
||||
int _timerid;
|
||||
int _overrun;
|
||||
}
|
||||
__timer _timer;
|
||||
struct __mesgq
|
||||
{
|
||||
int _mqd;
|
||||
}
|
||||
__mesgq _mesgq;
|
||||
struct __poll
|
||||
{
|
||||
c_long _band;
|
||||
}
|
||||
__poll _poll;
|
||||
struct ___spare___
|
||||
{
|
||||
c_long __spare1__;
|
||||
int[7] __spare2__;
|
||||
}
|
||||
___spare___ __spare__;
|
||||
}
|
||||
__reason _reason;
|
||||
}
|
||||
|
||||
int kill(pid_t, int);
|
||||
int sigaction(int, in sigaction_t*, sigaction_t);
|
||||
int sigaddset(sigset_t*, int);
|
||||
int sigdelset(sigset_t*, int);
|
||||
int sigemptyset(sigset_t *);
|
||||
int sigfillset(sigset_t *);
|
||||
int sigismember(in sigset_t *, int);
|
||||
int sigpending(sigset_t *);
|
||||
int sigprocmask(int, in sigset_t*, sigset_t*);
|
||||
int sigsuspend(in sigset_t *);
|
||||
int sigwait(in sigset_t*, int*);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
SIGPOLL
|
||||
SIGPROF
|
||||
SIGSYS
|
||||
SIGTRAP
|
||||
SIGVTALRM
|
||||
SIGXCPU
|
||||
SIGXFSZ
|
||||
|
||||
SA_ONSTACK
|
||||
SA_RESETHAND
|
||||
SA_RESTART
|
||||
SA_SIGINFO
|
||||
SA_NOCLDWAIT
|
||||
SA_NODEFER
|
||||
SS_ONSTACK
|
||||
SS_DISABLE
|
||||
MINSIGSTKSZ
|
||||
SIGSTKSZ
|
||||
|
||||
ucontext_t // from ucontext
|
||||
mcontext_t // from ucontext
|
||||
|
||||
struct stack_t
|
||||
{
|
||||
void* ss_sp;
|
||||
size_t ss_size;
|
||||
int ss_flags;
|
||||
}
|
||||
|
||||
struct sigstack
|
||||
{
|
||||
int ss_onstack;
|
||||
void* ss_sp;
|
||||
}
|
||||
|
||||
ILL_ILLOPC
|
||||
ILL_ILLOPN
|
||||
ILL_ILLADR
|
||||
ILL_ILLTRP
|
||||
ILL_PRVOPC
|
||||
ILL_PRVREG
|
||||
ILL_COPROC
|
||||
ILL_BADSTK
|
||||
|
||||
FPE_INTDIV
|
||||
FPE_INTOVF
|
||||
FPE_FLTDIV
|
||||
FPE_FLTOVF
|
||||
FPE_FLTUND
|
||||
FPE_FLTRES
|
||||
FPE_FLTINV
|
||||
FPE_FLTSUB
|
||||
|
||||
SEGV_MAPERR
|
||||
SEGV_ACCERR
|
||||
|
||||
BUS_ADRALN
|
||||
BUS_ADRERR
|
||||
BUS_OBJERR
|
||||
|
||||
TRAP_BRKPT
|
||||
TRAP_TRACE
|
||||
|
||||
CLD_EXITED
|
||||
CLD_KILLED
|
||||
CLD_DUMPED
|
||||
CLD_TRAPPED
|
||||
CLD_STOPPED
|
||||
CLD_CONTINUED
|
||||
|
||||
POLL_IN
|
||||
POLL_OUT
|
||||
POLL_MSG
|
||||
POLL_ERR
|
||||
POLL_PRI
|
||||
POLL_HUP
|
||||
|
||||
sigfn_t bsd_signal(int sig, sigfn_t func);
|
||||
sigfn_t sigset(int sig, sigfn_t func);
|
||||
|
||||
int killpg(pid_t, int);
|
||||
int sigaltstack(in stack_t*, stack_t*);
|
||||
int sighold(int);
|
||||
int sigignore(int);
|
||||
int siginterrupt(int, int);
|
||||
int sigpause(int);
|
||||
int sigrelse(int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum SIGPOLL = 29;
|
||||
enum SIGPROF = 27;
|
||||
enum SIGSYS = 31;
|
||||
enum SIGTRAP = 5;
|
||||
enum SIGVTALRM = 26;
|
||||
enum SIGXCPU = 24;
|
||||
enum SIGXFSZ = 25;
|
||||
|
||||
enum SA_ONSTACK = 0x08000000;
|
||||
enum SA_RESETHAND = 0x80000000;
|
||||
enum SA_RESTART = 0x10000000;
|
||||
enum SA_SIGINFO = 4;
|
||||
enum SA_NOCLDWAIT = 2;
|
||||
enum SA_NODEFER = 0x40000000;
|
||||
enum SS_ONSTACK = 1;
|
||||
enum SS_DISABLE = 2;
|
||||
enum MINSIGSTKSZ = 2048;
|
||||
enum SIGSTKSZ = 8192;
|
||||
|
||||
//ucontext_t (defined in core.sys.posix.ucontext)
|
||||
//mcontext_t (defined in core.sys.posix.ucontext)
|
||||
|
||||
struct stack_t
|
||||
{
|
||||
void* ss_sp;
|
||||
int ss_flags;
|
||||
size_t ss_size;
|
||||
}
|
||||
|
||||
struct sigstack
|
||||
{
|
||||
void* ss_sp;
|
||||
int ss_onstack;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
ILL_ILLOPC = 1,
|
||||
ILL_ILLOPN,
|
||||
ILL_ILLADR,
|
||||
ILL_ILLTRP,
|
||||
ILL_PRVOPC,
|
||||
ILL_PRVREG,
|
||||
ILL_COPROC,
|
||||
ILL_BADSTK
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
FPE_INTDIV = 1,
|
||||
FPE_INTOVF,
|
||||
FPE_FLTDIV,
|
||||
FPE_FLTOVF,
|
||||
FPE_FLTUND,
|
||||
FPE_FLTRES,
|
||||
FPE_FLTINV,
|
||||
FPE_FLTSUB
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SEGV_MAPERR = 1,
|
||||
SEGV_ACCERR
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
BUS_ADRALN = 1,
|
||||
BUS_ADRERR,
|
||||
BUS_OBJERR
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
TRAP_BRKPT = 1,
|
||||
TRAP_TRACE
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
CLD_EXITED = 1,
|
||||
CLD_KILLED,
|
||||
CLD_DUMPED,
|
||||
CLD_TRAPPED,
|
||||
CLD_STOPPED,
|
||||
CLD_CONTINUED
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
POLL_IN = 1,
|
||||
POLL_OUT,
|
||||
POLL_MSG,
|
||||
POLL_ERR,
|
||||
POLL_PRI,
|
||||
POLL_HUP
|
||||
}
|
||||
|
||||
sigfn_t bsd_signal(int sig, sigfn_t func);
|
||||
sigfn_t sigset(int sig, sigfn_t func);
|
||||
|
||||
int killpg(pid_t, int);
|
||||
int sigaltstack(in stack_t*, stack_t*);
|
||||
int sighold(int);
|
||||
int sigignore(int);
|
||||
int siginterrupt(int, int);
|
||||
int sigpause(int);
|
||||
int sigrelse(int);
|
||||
}
|
||||
|
||||
//
|
||||
// Timer (TMR)
|
||||
//
|
||||
/*
|
||||
NOTE: This should actually be defined in core.sys.posix.time.
|
||||
It is defined here instead to break a circular import.
|
||||
|
||||
struct timespec
|
||||
{
|
||||
time_t tv_sec;
|
||||
int tv_nsec;
|
||||
}
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct timespec
|
||||
{
|
||||
time_t tv_sec;
|
||||
c_long tv_nsec;
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct timespec
|
||||
{
|
||||
time_t tv_sec;
|
||||
c_long tv_nsec;
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct timespec
|
||||
{
|
||||
time_t tv_sec;
|
||||
c_long tv_nsec;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Realtime Signals (RTS)
|
||||
//
|
||||
/*
|
||||
struct sigevent
|
||||
{
|
||||
int sigev_notify;
|
||||
int sigev_signo;
|
||||
sigval sigev_value;
|
||||
void(*)(sigval) sigev_notify_function;
|
||||
pthread_attr_t* sigev_notify_attributes;
|
||||
}
|
||||
|
||||
int sigqueue(pid_t, int, in sigval);
|
||||
int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*);
|
||||
int sigwaitinfo(in sigset_t*, siginfo_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
private enum __SIGEV_MAX_SIZE = 64;
|
||||
|
||||
static if( false /* __WORDSIZE == 64 */ )
|
||||
{
|
||||
private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
|
||||
}
|
||||
else
|
||||
{
|
||||
private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3);
|
||||
}
|
||||
|
||||
struct sigevent
|
||||
{
|
||||
sigval sigev_value;
|
||||
int sigev_signo;
|
||||
int sigev_notify;
|
||||
|
||||
union _sigev_un_t
|
||||
{
|
||||
int[__SIGEV_PAD_SIZE] _pad;
|
||||
pid_t _tid;
|
||||
|
||||
struct _sigev_thread_t
|
||||
{
|
||||
void function(sigval) _function;
|
||||
void* _attribute;
|
||||
} _sigev_thread_t _sigev_thread;
|
||||
} _sigev_un_t _sigev_un;
|
||||
}
|
||||
|
||||
int sigqueue(pid_t, int, in sigval);
|
||||
int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*);
|
||||
int sigwaitinfo(in sigset_t*, siginfo_t*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct sigevent
|
||||
{
|
||||
int sigev_notify;
|
||||
int sigev_signo;
|
||||
sigval sigev_value;
|
||||
union _sigev_un
|
||||
{
|
||||
lwpid_t _threadid;
|
||||
struct _sigev_thread
|
||||
{
|
||||
void function(sigval) _function;
|
||||
void* _attribute;
|
||||
}
|
||||
c_long[8] __spare__;
|
||||
}
|
||||
}
|
||||
|
||||
int sigqueue(pid_t, int, in sigval);
|
||||
int sigtimedwait(in sigset_t*, siginfo_t*, in timespec*);
|
||||
int sigwaitinfo(in sigset_t*, siginfo_t*);
|
||||
}
|
||||
//
|
||||
// Threads (THR)
|
||||
//
|
||||
/*
|
||||
int pthread_kill(pthread_t, int);
|
||||
int pthread_sigmask(int, in sigset_t*, sigset_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int pthread_kill(pthread_t, int);
|
||||
int pthread_sigmask(int, in sigset_t*, sigset_t*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int pthread_kill(pthread_t, int);
|
||||
int pthread_sigmask(int, in sigset_t*, sigset_t*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int pthread_kill(pthread_t, int);
|
||||
int pthread_sigmask(int, in sigset_t*, sigset_t*);
|
||||
}
|
||||
219
druntime/import/core/sys/posix/stdio.d
Normal file
219
druntime/import/core/sys/posix/stdio.d
Normal file
@@ -0,0 +1,219 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.stdio;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.stdio;
|
||||
public import core.sys.posix.sys.types; // for off_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required (defined in core.stdc.stdio)
|
||||
//
|
||||
/*
|
||||
BUFSIZ
|
||||
_IOFBF
|
||||
_IOLBF
|
||||
_IONBF
|
||||
L_tmpnam
|
||||
SEEK_CUR
|
||||
SEEK_END
|
||||
SEEK_SET
|
||||
FILENAME_MAX
|
||||
FOPEN_MAX
|
||||
TMP_MAX
|
||||
EOF
|
||||
NULL
|
||||
stderr
|
||||
stdin
|
||||
stdout
|
||||
FILE
|
||||
fpos_t
|
||||
size_t
|
||||
|
||||
void clearerr(FILE*);
|
||||
int fclose(FILE*);
|
||||
int feof(FILE*);
|
||||
int ferror(FILE*);
|
||||
int fflush(FILE*);
|
||||
int fgetc(FILE*);
|
||||
int fgetpos(FILE*, fpos_t *);
|
||||
char* fgets(char*, int, FILE*);
|
||||
FILE* fopen(in char*, in char*);
|
||||
int fprintf(FILE*, in char*, ...);
|
||||
int fputc(int, FILE*);
|
||||
int fputs(in char*, FILE*);
|
||||
size_t fread(void *, size_t, size_t, FILE*);
|
||||
FILE* freopen(in char*, in char*, FILE*);
|
||||
int fscanf(FILE*, in char*, ...);
|
||||
int fseek(FILE*, c_long, int);
|
||||
int fsetpos(FILE*, in fpos_t*);
|
||||
c_long ftell(FILE*);
|
||||
size_t fwrite(in void *, size_t, size_t, FILE*);
|
||||
int getc(FILE*);
|
||||
int getchar();
|
||||
char* gets(char*);
|
||||
void perror(in char*);
|
||||
int printf(in char*, ...);
|
||||
int putc(int, FILE*);
|
||||
int putchar(int);
|
||||
int puts(in char*);
|
||||
int remove(in char*);
|
||||
int rename(in char*, in char*);
|
||||
void rewind(FILE*);
|
||||
int scanf(in char*, ...);
|
||||
void setbuf(FILE*, char*);
|
||||
int setvbuf(FILE*, char*, int, size_t);
|
||||
int snprintf(char*, size_t, in char*, ...);
|
||||
int sprintf(char*, in char*, ...);
|
||||
int sscanf(in char*, in char*, int ...);
|
||||
FILE* tmpfile();
|
||||
char* tmpnam(char*);
|
||||
int ungetc(int, FILE*);
|
||||
int vfprintf(FILE*, in char*, va_list);
|
||||
int vfscanf(FILE*, in char*, va_list);
|
||||
int vprintf(in char*, va_list);
|
||||
int vscanf(in char*, va_list);
|
||||
int vsnprintf(char*, size_t, in char*, va_list);
|
||||
int vsprintf(char*, in char*, va_list);
|
||||
int vsscanf(in char*, in char*, va_list arg);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int fgetpos64(FILE*, fpos_t *);
|
||||
alias fgetpos64 fgetpos;
|
||||
|
||||
FILE* fopen64(in char*, in char*);
|
||||
alias fopen64 fopen;
|
||||
|
||||
FILE* freopen64(in char*, in char*, FILE*);
|
||||
alias freopen64 freopen;
|
||||
|
||||
int fseek64(FILE*, c_long, int);
|
||||
alias fseek64 fseek;
|
||||
|
||||
int fsetpos64(FILE*, in fpos_t*);
|
||||
alias fsetpos64 fsetpos;
|
||||
|
||||
FILE* tmpfile64();
|
||||
alias tmpfile64 tmpfile;
|
||||
}
|
||||
else
|
||||
{
|
||||
int fgetpos(FILE*, fpos_t *);
|
||||
FILE* fopen(in char*, in char*);
|
||||
FILE* freopen(in char*, in char*, FILE*);
|
||||
int fseek(FILE*, c_long, int);
|
||||
int fsetpos(FILE*, in fpos_t*);
|
||||
FILE* tmpfile();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// C Extension (CX)
|
||||
//
|
||||
/*
|
||||
L_ctermid
|
||||
|
||||
char* ctermid(char*);
|
||||
FILE* fdopen(int, in char*);
|
||||
int fileno(FILE*);
|
||||
int fseeko(FILE*, off_t, int);
|
||||
off_t ftello(FILE*);
|
||||
char* gets(char*);
|
||||
FILE* popen(in char*, in char*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum L_ctermid = 9;
|
||||
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
int fseeko64(FILE*, off_t, int);
|
||||
alias fseeko64 fseeko;
|
||||
}
|
||||
else
|
||||
{
|
||||
int fseeko(FILE*, off_t, int);
|
||||
}
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
off_t ftello64(FILE*);
|
||||
alias ftello64 ftello;
|
||||
}
|
||||
else
|
||||
{
|
||||
off_t ftello(FILE*);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int fseeko(FILE*, off_t, int);
|
||||
off_t ftello(FILE*);
|
||||
}
|
||||
|
||||
char* ctermid(char*);
|
||||
FILE* fdopen(int, in char*);
|
||||
int fileno(FILE*);
|
||||
//int fseeko(FILE*, off_t, int);
|
||||
//off_t ftello(FILE*);
|
||||
char* gets(char*);
|
||||
FILE* popen(in char*, in char*);
|
||||
|
||||
//
|
||||
// Thread-Safe Functions (TSF)
|
||||
//
|
||||
/*
|
||||
void flockfile(FILE*);
|
||||
int ftrylockfile(FILE*);
|
||||
void funlockfile(FILE*);
|
||||
int getc_unlocked(FILE*);
|
||||
int getchar_unlocked();
|
||||
int putc_unlocked(int, FILE*);
|
||||
int putchar_unlocked(int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
void flockfile(FILE*);
|
||||
int ftrylockfile(FILE*);
|
||||
void funlockfile(FILE*);
|
||||
int getc_unlocked(FILE*);
|
||||
int getchar_unlocked();
|
||||
int putc_unlocked(int, FILE*);
|
||||
int putchar_unlocked(int);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
P_tmpdir
|
||||
va_list (defined in core.stdc.stdarg)
|
||||
|
||||
char* tempnam(in char*, in char*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum P_tmpdir = "/tmp";
|
||||
|
||||
char* tempnam(in char*, in char*);
|
||||
}
|
||||
310
druntime/import/core/sys/posix/stdlib.d
Normal file
310
druntime/import/core/sys/posix/stdlib.d
Normal file
@@ -0,0 +1,310 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.stdlib;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.stdlib;
|
||||
public import core.sys.posix.sys.wait;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required (defined in core.stdc.stdlib)
|
||||
//
|
||||
/*
|
||||
EXIT_FAILURE
|
||||
EXIT_SUCCESS
|
||||
NULL
|
||||
RAND_MAX
|
||||
MB_CUR_MAX
|
||||
div_t
|
||||
ldiv_t
|
||||
lldiv_t
|
||||
size_t
|
||||
wchar_t
|
||||
|
||||
void _Exit(int);
|
||||
void abort();
|
||||
int abs(int);
|
||||
int atexit(void function());
|
||||
double atof(in char*);
|
||||
int atoi(in char*);
|
||||
c_long atol(in char*);
|
||||
long atoll(in char*);
|
||||
void* bsearch(in void*, in void*, size_t, size_t, int function(in void*, in void*));
|
||||
void* calloc(size_t, size_t);
|
||||
div_t div(int, int);
|
||||
void exit(int);
|
||||
void free(void*);
|
||||
char* getenv(in char*);
|
||||
c_long labs(c_long);
|
||||
ldiv_t ldiv(c_long, c_long);
|
||||
long llabs(long);
|
||||
lldiv_t lldiv(long, long);
|
||||
void* malloc(size_t);
|
||||
int mblen(in char*, size_t);
|
||||
size_t mbstowcs(wchar_t*, in char*, size_t);
|
||||
int mbtowc(wchar_t*, in char*, size_t);
|
||||
void qsort(void*, size_t, size_t, int function(in void*, in void*));
|
||||
int rand();
|
||||
void* realloc(void*, size_t);
|
||||
void srand(uint);
|
||||
double strtod(in char*, char**);
|
||||
float strtof(in char*, char**);
|
||||
c_long strtol(in char*, char**, int);
|
||||
real strtold(in char*, char**);
|
||||
long strtoll(in char*, char**, int);
|
||||
c_ulong strtoul(in char*, char**, int);
|
||||
ulong strtoull(in char*, char**, int);
|
||||
int system(in char*);
|
||||
size_t wcstombs(char*, in wchar_t*, size_t);
|
||||
int wctomb(char*, wchar_t);
|
||||
*/
|
||||
|
||||
//
|
||||
// Advisory Information (ADV)
|
||||
//
|
||||
/*
|
||||
int posix_memalign(void**, size_t, size_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int posix_memalign(void**, size_t, size_t);
|
||||
}
|
||||
|
||||
//
|
||||
// C Extension (CX)
|
||||
//
|
||||
/*
|
||||
int setenv(in char*, in char*, int);
|
||||
int unsetenv(in char*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int setenv(in char*, in char*, int);
|
||||
int unsetenv(in char*);
|
||||
|
||||
void* valloc(size_t); // LEGACY non-standard
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int setenv(in char*, in char*, int);
|
||||
int unsetenv(in char*);
|
||||
|
||||
void* valloc(size_t); // LEGACY non-standard
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int setenv(in char*, in char*, int);
|
||||
int unsetenv(in char*);
|
||||
|
||||
void* valloc(size_t); // LEGACY non-standard
|
||||
}
|
||||
|
||||
//
|
||||
// Thread-Safe Functions (TSF)
|
||||
//
|
||||
/*
|
||||
int rand_r(uint*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int rand_r(uint*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int rand_r(uint*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int rand_r(uint*);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
WNOHANG (defined in core.sys.posix.sys.wait)
|
||||
WUNTRACED (defined in core.sys.posix.sys.wait)
|
||||
WEXITSTATUS (defined in core.sys.posix.sys.wait)
|
||||
WIFEXITED (defined in core.sys.posix.sys.wait)
|
||||
WIFSIGNALED (defined in core.sys.posix.sys.wait)
|
||||
WIFSTOPPED (defined in core.sys.posix.sys.wait)
|
||||
WSTOPSIG (defined in core.sys.posix.sys.wait)
|
||||
WTERMSIG (defined in core.sys.posix.sys.wait)
|
||||
|
||||
c_long a64l(in char*);
|
||||
double drand48();
|
||||
char* ecvt(double, int, int *, int *); // LEGACY
|
||||
double erand48(ushort[3]);
|
||||
char* fcvt(double, int, int *, int *); // LEGACY
|
||||
char* gcvt(double, int, char*); // LEGACY
|
||||
// per spec: int getsubopt(char** char* const*, char**);
|
||||
int getsubopt(char**, in char**, char**);
|
||||
int grantpt(int);
|
||||
char* initstate(uint, char*, size_t);
|
||||
c_long jrand48(ushort[3]);
|
||||
char* l64a(c_long);
|
||||
void lcong48(ushort[7]);
|
||||
c_long lrand48();
|
||||
char* mktemp(char*); // LEGACY
|
||||
int mkstemp(char*);
|
||||
c_long mrand48();
|
||||
c_long nrand48(ushort[3]);
|
||||
int posix_openpt(int);
|
||||
char* ptsname(int);
|
||||
int putenv(char*);
|
||||
c_long random();
|
||||
char* realpath(in char*, char*);
|
||||
ushort seed48(ushort[3]);
|
||||
void setkey(in char*);
|
||||
char* setstate(in char*);
|
||||
void srand48(c_long);
|
||||
void srandom(uint);
|
||||
int unlockpt(int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
//WNOHANG (defined in core.sys.posix.sys.wait)
|
||||
//WUNTRACED (defined in core.sys.posix.sys.wait)
|
||||
//WEXITSTATUS (defined in core.sys.posix.sys.wait)
|
||||
//WIFEXITED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSIGNALED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSTOPPED (defined in core.sys.posix.sys.wait)
|
||||
//WSTOPSIG (defined in core.sys.posix.sys.wait)
|
||||
//WTERMSIG (defined in core.sys.posix.sys.wait)
|
||||
|
||||
c_long a64l(in char*);
|
||||
double drand48();
|
||||
char* ecvt(double, int, int *, int *); // LEGACY
|
||||
double erand48(ushort[3]);
|
||||
char* fcvt(double, int, int *, int *); // LEGACY
|
||||
char* gcvt(double, int, char*); // LEGACY
|
||||
int getsubopt(char**, in char**, char**);
|
||||
int grantpt(int);
|
||||
char* initstate(uint, char*, size_t);
|
||||
c_long jrand48(ushort[3]);
|
||||
char* l64a(c_long);
|
||||
void lcong48(ushort[7]);
|
||||
c_long lrand48();
|
||||
char* mktemp(char*); // LEGACY
|
||||
//int mkstemp(char*);
|
||||
c_long mrand48();
|
||||
c_long nrand48(ushort[3]);
|
||||
int posix_openpt(int);
|
||||
char* ptsname(int);
|
||||
int putenv(char*);
|
||||
c_long random();
|
||||
char* realpath(in char*, char*);
|
||||
ushort seed48(ushort[3]);
|
||||
void setkey(in char*);
|
||||
char* setstate(in char*);
|
||||
void srand48(c_long);
|
||||
void srandom(uint);
|
||||
int unlockpt(int);
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int mkstemp64(char*);
|
||||
alias mkstemp64 mkstemp;
|
||||
}
|
||||
else
|
||||
{
|
||||
int mkstemp(char*);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
//WNOHANG (defined in core.sys.posix.sys.wait)
|
||||
//WUNTRACED (defined in core.sys.posix.sys.wait)
|
||||
//WEXITSTATUS (defined in core.sys.posix.sys.wait)
|
||||
//WIFEXITED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSIGNALED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSTOPPED (defined in core.sys.posix.sys.wait)
|
||||
//WSTOPSIG (defined in core.sys.posix.sys.wait)
|
||||
//WTERMSIG (defined in core.sys.posix.sys.wait)
|
||||
|
||||
c_long a64l(in char*);
|
||||
double drand48();
|
||||
char* ecvt(double, int, int *, int *); // LEGACY
|
||||
double erand48(ushort[3]);
|
||||
char* fcvt(double, int, int *, int *); // LEGACY
|
||||
char* gcvt(double, int, char*); // LEGACY
|
||||
int getsubopt(char**, in char**, char**);
|
||||
int grantpt(int);
|
||||
char* initstate(uint, char*, size_t);
|
||||
c_long jrand48(ushort[3]);
|
||||
char* l64a(c_long);
|
||||
void lcong48(ushort[7]);
|
||||
c_long lrand48();
|
||||
char* mktemp(char*); // LEGACY
|
||||
int mkstemp(char*);
|
||||
c_long mrand48();
|
||||
c_long nrand48(ushort[3]);
|
||||
int posix_openpt(int);
|
||||
char* ptsname(int);
|
||||
int putenv(char*);
|
||||
c_long random();
|
||||
char* realpath(in char*, char*);
|
||||
ushort seed48(ushort[3]);
|
||||
void setkey(in char*);
|
||||
char* setstate(in char*);
|
||||
void srand48(c_long);
|
||||
void srandom(uint);
|
||||
int unlockpt(int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
//WNOHANG (defined in core.sys.posix.sys.wait)
|
||||
//WUNTRACED (defined in core.sys.posix.sys.wait)
|
||||
//WEXITSTATUS (defined in core.sys.posix.sys.wait)
|
||||
//WIFEXITED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSIGNALED (defined in core.sys.posix.sys.wait)
|
||||
//WIFSTOPPED (defined in core.sys.posix.sys.wait)
|
||||
//WSTOPSIG (defined in core.sys.posix.sys.wait)
|
||||
//WTERMSIG (defined in core.sys.posix.sys.wait)
|
||||
|
||||
c_long a64l(in char*);
|
||||
double drand48();
|
||||
//char* ecvt(double, int, int *, int *); // LEGACY
|
||||
double erand48(ushort[3]);
|
||||
//char* fcvt(double, int, int *, int *); // LEGACY
|
||||
//char* gcvt(double, int, char*); // LEGACY
|
||||
int getsubopt(char**, in char**, char**);
|
||||
int grantpt(int);
|
||||
char* initstate(uint, char*, size_t);
|
||||
c_long jrand48(ushort[3]);
|
||||
char* l64a(c_long);
|
||||
void lcong48(ushort[7]);
|
||||
c_long lrand48();
|
||||
char* mktemp(char*); // LEGACY
|
||||
int mkstemp(char*);
|
||||
c_long mrand48();
|
||||
c_long nrand48(ushort[3]);
|
||||
int posix_openpt(int);
|
||||
char* ptsname(int);
|
||||
int putenv(char*);
|
||||
c_long random();
|
||||
char* realpath(in char*, char*);
|
||||
ushort seed48(ushort[3]);
|
||||
void setkey(in char*);
|
||||
char* setstate(in char*);
|
||||
void srand48(c_long);
|
||||
void srandom(uint);
|
||||
int unlockpt(int);
|
||||
}
|
||||
104
druntime/import/core/sys/posix/sys/ipc.d
Normal file
104
druntime/import/core/sys/posix/sys/ipc.d
Normal file
@@ -0,0 +1,104 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.ipc;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for uid_t, gid_t, mode_t, key_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
struct ipc_perm
|
||||
{
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
uid_t cuid;
|
||||
gid_t cgid;
|
||||
mode_t mode;
|
||||
}
|
||||
|
||||
IPC_CREAT
|
||||
IPC_EXCL
|
||||
IPC_NOWAIT
|
||||
|
||||
IPC_PRIVATE
|
||||
|
||||
IPC_RMID
|
||||
IPC_SET
|
||||
IPC_STAT
|
||||
|
||||
key_t ftok(in char*, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct ipc_perm
|
||||
{
|
||||
key_t __key;
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
uid_t cuid;
|
||||
gid_t cgid;
|
||||
ushort mode;
|
||||
ushort __pad1;
|
||||
ushort __seq;
|
||||
ushort __pad2;
|
||||
c_ulong __unused1;
|
||||
c_ulong __unused2;
|
||||
}
|
||||
|
||||
enum IPC_CREAT = 01000;
|
||||
enum IPC_EXCL = 02000;
|
||||
enum IPC_NOWAIT = 04000;
|
||||
|
||||
enum key_t IPC_PRIVATE = 0;
|
||||
|
||||
enum IPC_RMID = 0;
|
||||
enum IPC_SET = 1;
|
||||
enum IPC_STAT = 2;
|
||||
|
||||
key_t ftok(in char*, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct ipc_perm
|
||||
{
|
||||
ushort cuid;
|
||||
ushort cguid;
|
||||
ushort uid;
|
||||
ushort gid;
|
||||
ushort mode;
|
||||
ushort seq;
|
||||
key_t key;
|
||||
}
|
||||
|
||||
enum IPC_CREAT = 01000;
|
||||
enum IPC_EXCL = 02000;
|
||||
enum IPC_NOWAIT = 04000;
|
||||
|
||||
enum key_t IPC_PRIVATE = 0;
|
||||
|
||||
enum IPC_RMID = 0;
|
||||
enum IPC_SET = 1;
|
||||
enum IPC_STAT = 2;
|
||||
|
||||
key_t ftok(in char*, int);
|
||||
}
|
||||
313
druntime/import/core/sys/posix/sys/mman.d
Normal file
313
druntime/import/core/sys/posix/sys/mman.d
Normal file
@@ -0,0 +1,313 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.mman;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.stddef; // for size_t
|
||||
public import core.sys.posix.sys.types; // for off_t, mode_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Advisory Information (ADV)
|
||||
//
|
||||
/*
|
||||
int posix_madvise(void*, size_t, int);
|
||||
*/
|
||||
|
||||
//
|
||||
// Advisory Information and either Memory Mapped Files or Shared Memory Objects (MC1)
|
||||
//
|
||||
/*
|
||||
POSIX_MADV_NORMAL
|
||||
POSIX_MADV_SEQUENTIAL
|
||||
POSIX_MADV_RANDOM
|
||||
POSIX_MADV_WILLNEED
|
||||
POSIX_MADV_DONTNEED
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum POSIX_MADV_NORMAL = 0;
|
||||
enum POSIX_MADV_RANDOM = 1;
|
||||
enum POSIX_MADV_SEQUENTIAL = 2;
|
||||
enum POSIX_MADV_WILLNEED = 3;
|
||||
enum POSIX_MADV_DONTNEED = 4;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum POSIX_MADV_NORMAL = 0;
|
||||
enum POSIX_MADV_RANDOM = 1;
|
||||
enum POSIX_MADV_SEQUENTIAL = 2;
|
||||
enum POSIX_MADV_WILLNEED = 3;
|
||||
enum POSIX_MADV_DONTNEED = 4;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum POSIX_MADV_NORMAL = 0;
|
||||
enum POSIX_MADV_RANDOM = 1;
|
||||
enum POSIX_MADV_SEQUENTIAL = 2;
|
||||
enum POSIX_MADV_WILLNEED = 3;
|
||||
enum POSIX_MADV_DONTNEED = 4;
|
||||
}
|
||||
|
||||
//
|
||||
// Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2)
|
||||
//
|
||||
/*
|
||||
PROT_READ
|
||||
PROT_WRITE
|
||||
PROT_EXEC
|
||||
PROT_NONE
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum PROT_NONE = 0x0;
|
||||
enum PROT_READ = 0x1;
|
||||
enum PROT_WRITE = 0x2;
|
||||
enum PROT_EXEC = 0x4;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum PROT_NONE = 0x00;
|
||||
enum PROT_READ = 0x01;
|
||||
enum PROT_WRITE = 0x02;
|
||||
enum PROT_EXEC = 0x04;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum PROT_NONE = 0x00;
|
||||
enum PROT_READ = 0x01;
|
||||
enum PROT_WRITE = 0x02;
|
||||
enum PROT_EXEC = 0x04;
|
||||
}
|
||||
|
||||
//
|
||||
// Memory Mapped Files, Shared Memory Objects, or Typed Memory Objects (MC3)
|
||||
//
|
||||
/*
|
||||
void* mmap(void*, size_t, int, int, int, off_t);
|
||||
int munmap(void*, size_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
//void* mmap(void*, size_t, int, int, int, off_t);
|
||||
int munmap(void*, size_t);
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
void* mmap64(void*, size_t, int, int, int, off_t);
|
||||
alias mmap64 mmap;
|
||||
}
|
||||
else
|
||||
{
|
||||
void* mmap(void*, size_t, int, int, int, off_t);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
void* mmap(void*, size_t, int, int, int, off_t);
|
||||
int munmap(void*, size_t);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
void* mmap(void*, size_t, int, int, int, off_t);
|
||||
int munmap(void*, size_t);
|
||||
}
|
||||
|
||||
//
|
||||
// Memory Mapped Files (MF)
|
||||
//
|
||||
/*
|
||||
MAP_SHARED (MF|SHM)
|
||||
MAP_PRIVATE (MF|SHM)
|
||||
MAP_FIXED (MF|SHM)
|
||||
MAP_FAILED (MF|SHM)
|
||||
|
||||
MS_ASYNC (MF|SIO)
|
||||
MS_SYNC (MF|SIO)
|
||||
MS_INVALIDATE (MF|SIO)
|
||||
|
||||
int msync(void*, size_t, int); (MF|SIO)
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum MAP_SHARED = 0x01;
|
||||
enum MAP_PRIVATE = 0x02;
|
||||
enum MAP_FIXED = 0x10;
|
||||
enum MAP_ANON = 0x20; // non-standard
|
||||
|
||||
enum MAP_FAILED = cast(void*) -1;
|
||||
|
||||
enum
|
||||
{
|
||||
MS_ASYNC = 1,
|
||||
MS_SYNC = 4,
|
||||
MS_INVALIDATE = 2
|
||||
}
|
||||
|
||||
int msync(void*, size_t, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum MAP_SHARED = 0x0001;
|
||||
enum MAP_PRIVATE = 0x0002;
|
||||
enum MAP_FIXED = 0x0010;
|
||||
enum MAP_ANON = 0x1000; // non-standard
|
||||
|
||||
enum MAP_FAILED = cast(void*)-1;
|
||||
|
||||
enum MS_ASYNC = 0x0001;
|
||||
enum MS_INVALIDATE = 0x0002;
|
||||
enum MS_SYNC = 0x0010;
|
||||
|
||||
int msync(void*, size_t, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum MAP_SHARED = 0x0001;
|
||||
enum MAP_PRIVATE = 0x0002;
|
||||
enum MAP_FIXED = 0x0010;
|
||||
enum MAP_ANON = 0x1000; // non-standard
|
||||
|
||||
enum MAP_FAILED = cast(void*)-1;
|
||||
|
||||
enum MS_SYNC = 0x0000;
|
||||
enum MS_ASYNC = 0x0001;
|
||||
enum MS_INVALIDATE = 0x0002;
|
||||
|
||||
int msync(void*, size_t, int);
|
||||
}
|
||||
|
||||
//
|
||||
// Process Memory Locking (ML)
|
||||
//
|
||||
/*
|
||||
MCL_CURRENT
|
||||
MCL_FUTURE
|
||||
|
||||
int mlockall(int);
|
||||
int munlockall();
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum MCL_CURRENT = 1;
|
||||
enum MCL_FUTURE = 2;
|
||||
|
||||
int mlockall(int);
|
||||
int munlockall();
|
||||
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum MCL_CURRENT = 0x0001;
|
||||
enum MCL_FUTURE = 0x0002;
|
||||
|
||||
int mlockall(int);
|
||||
int munlockall();
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum MCL_CURRENT = 0x0001;
|
||||
enum MCL_FUTURE = 0x0002;
|
||||
|
||||
int mlockall(int);
|
||||
int munlockall();
|
||||
}
|
||||
|
||||
//
|
||||
// Range Memory Locking (MLR)
|
||||
//
|
||||
/*
|
||||
int mlock(in void*, size_t);
|
||||
int munlock(in void*, size_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int mlock(in void*, size_t);
|
||||
int munlock(in void*, size_t);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int mlock(in void*, size_t);
|
||||
int munlock(in void*, size_t);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int mlock(in void*, size_t);
|
||||
int munlock(in void*, size_t);
|
||||
}
|
||||
|
||||
//
|
||||
// Memory Protection (MPR)
|
||||
//
|
||||
/*
|
||||
int mprotect(void*, size_t, int);
|
||||
*/
|
||||
|
||||
version( OSX )
|
||||
{
|
||||
int mprotect(void*, size_t, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int mprotect(void*, size_t, int);
|
||||
}
|
||||
|
||||
//
|
||||
// Shared Memory Objects (SHM)
|
||||
//
|
||||
/*
|
||||
int shm_open(in char*, int, mode_t);
|
||||
int shm_unlink(in char*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
int shm_open(in char*, int, mode_t);
|
||||
int shm_unlink(in char*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int shm_open(in char*, int, mode_t);
|
||||
int shm_unlink(in char*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
int shm_open(in char*, int, mode_t);
|
||||
int shm_unlink(in char*);
|
||||
}
|
||||
|
||||
//
|
||||
// Typed Memory Objects (TYM)
|
||||
//
|
||||
/*
|
||||
POSIX_TYPED_MEM_ALLOCATE
|
||||
POSIX_TYPED_MEM_ALLOCATE_CONTIG
|
||||
POSIX_TYPED_MEM_MAP_ALLOCATABLE
|
||||
|
||||
struct posix_typed_mem_info
|
||||
{
|
||||
size_t posix_tmi_length;
|
||||
}
|
||||
|
||||
int posix_mem_offset(in void*, size_t, off_t *, size_t *, int *);
|
||||
int posix_typed_mem_get_info(int, struct posix_typed_mem_info *);
|
||||
int posix_typed_mem_open(in char*, int, int);
|
||||
*/
|
||||
180
druntime/import/core/sys/posix/sys/select.d
Normal file
180
druntime/import/core/sys/posix/sys/select.d
Normal file
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.select;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.time; // for timespec
|
||||
public import core.sys.posix.sys.time; // for timeval
|
||||
public import core.sys.posix.sys.types; // for time_t
|
||||
public import core.sys.posix.signal; // for sigset_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
NOTE: This module requires timeval from core.sys.posix.sys.time, but timeval
|
||||
is supposedly an XOpen extension. As a result, this header will not
|
||||
compile on platforms that are not XSI-compliant. This must be resolved
|
||||
on a per-platform basis.
|
||||
|
||||
fd_set
|
||||
|
||||
void FD_CLR(int fd, fd_set* fdset);
|
||||
int FD_ISSET(int fd, fd_set* fdset);
|
||||
void FD_SET(int fd, fd_set* fdset);
|
||||
void FD_ZERO(fd_set* fdset);
|
||||
|
||||
FD_SETSIZE
|
||||
|
||||
int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*);
|
||||
int select(int, fd_set*, fd_set*, fd_set*, timeval*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
private
|
||||
{
|
||||
alias c_long __fd_mask;
|
||||
enum __NFDBITS = 8 * __fd_mask.sizeof;
|
||||
|
||||
extern (D) int __FDELT( int d )
|
||||
{
|
||||
return d / __NFDBITS;
|
||||
}
|
||||
|
||||
extern (D) int __FDMASK( int d )
|
||||
{
|
||||
return cast(__fd_mask) 1 << ( d % __NFDBITS );
|
||||
}
|
||||
}
|
||||
|
||||
enum FD_SETSIZE = 1024;
|
||||
|
||||
struct fd_set
|
||||
{
|
||||
__fd_mask[FD_SETSIZE / __NFDBITS] fds_bits;
|
||||
}
|
||||
|
||||
extern (D) void FD_CLR( int fd, fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[__FDELT( fd )] &= ~__FDMASK( fd );
|
||||
}
|
||||
|
||||
extern (D) int FD_ISSET( int fd, fd_set* fdset )
|
||||
{
|
||||
return fdset.fds_bits[__FDELT( fd )] & __FDMASK( fd );
|
||||
}
|
||||
|
||||
extern (D) void FD_SET( int fd, fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[__FDELT( fd )] |= __FDMASK( fd );
|
||||
}
|
||||
|
||||
extern (D) void FD_ZERO( fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[0 .. $] = 0;
|
||||
}
|
||||
|
||||
/+
|
||||
+ GNU ASM Implementation
|
||||
+
|
||||
# define __FD_ZERO(fdsp) \
|
||||
do { \
|
||||
int __d0, __d1; \
|
||||
__asm__ __volatile__ ("cld; rep; stosl" \
|
||||
: "=c" (__d0), "=D" (__d1) \
|
||||
: "a" (0), "0" (sizeof (fd_set) \
|
||||
/ sizeof (__fd_mask)), \
|
||||
"1" (&__FDS_BITS (fdsp)[0]) \
|
||||
: "memory"); \
|
||||
} while (0)
|
||||
|
||||
# define __FD_SET(fd, fdsp) \
|
||||
__asm__ __volatile__ ("btsl %1,%0" \
|
||||
: "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \
|
||||
: "r" (((int) (fd)) % __NFDBITS) \
|
||||
: "cc","memory")
|
||||
# define __FD_CLR(fd, fdsp) \
|
||||
__asm__ __volatile__ ("btrl %1,%0" \
|
||||
: "=m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \
|
||||
: "r" (((int) (fd)) % __NFDBITS) \
|
||||
: "cc","memory")
|
||||
# define __FD_ISSET(fd, fdsp) \
|
||||
(__extension__ \
|
||||
({register char __result; \
|
||||
__asm__ __volatile__ ("btl %1,%2 ; setcb %b0" \
|
||||
: "=q" (__result) \
|
||||
: "r" (((int) (fd)) % __NFDBITS), \
|
||||
"m" (__FDS_BITS (fdsp)[__FDELT (fd)]) \
|
||||
: "cc"); \
|
||||
__result; }))
|
||||
+/
|
||||
|
||||
int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*);
|
||||
int select(int, fd_set*, fd_set*, fd_set*, timeval*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
private
|
||||
{
|
||||
enum uint __DARWIN_NBBY = 8; /* bits in a byte */
|
||||
enum uint __DARWIN_NFDBITS = (int.sizeof * __DARWIN_NBBY); /* bits per mask */
|
||||
}
|
||||
|
||||
enum FD_SETSIZE = 1024;
|
||||
|
||||
struct fd_set
|
||||
{
|
||||
int[(FD_SETSIZE + (__DARWIN_NFDBITS - 1)) / __DARWIN_NFDBITS] fds_bits;
|
||||
}
|
||||
|
||||
extern (D) void FD_CLR( int fd, fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[fd / __DARWIN_NFDBITS] &= ~(1 << (fd % __DARWIN_NFDBITS));
|
||||
}
|
||||
|
||||
extern (D) int FD_ISSET( int fd, fd_set* fdset )
|
||||
{
|
||||
return fdset.fds_bits[fd / __DARWIN_NFDBITS] & (1 << (fd % __DARWIN_NFDBITS));
|
||||
}
|
||||
|
||||
extern (D) void FD_SET( int fd, fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[fd / __DARWIN_NFDBITS] |= 1 << (fd % __DARWIN_NFDBITS);
|
||||
}
|
||||
|
||||
extern (D) void FD_ZERO( fd_set* fdset )
|
||||
{
|
||||
fdset.fds_bits[0 .. $] = 0;
|
||||
}
|
||||
|
||||
int pselect(int, fd_set*, fd_set*, fd_set*, in timespec*, in sigset_t*);
|
||||
int select(int, fd_set*, fd_set*, fd_set*, timeval*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
private
|
||||
{
|
||||
enum uint _NFDBITS = c_ulong.sizeof * 8;
|
||||
}
|
||||
|
||||
enum uint FD_SETSIZE = 1024;
|
||||
|
||||
struct fd_set
|
||||
{
|
||||
c_ulong fds_bits[(FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS];
|
||||
}
|
||||
}
|
||||
116
druntime/import/core/sys/posix/sys/shm.d
Normal file
116
druntime/import/core/sys/posix/sys/shm.d
Normal file
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.shm;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for pid_t, time_t, key_t, size_t
|
||||
public import core.sys.posix.sys.ipc;
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
SHM_RDONLY
|
||||
SHM_RND
|
||||
|
||||
SHMLBA
|
||||
|
||||
shmatt_t
|
||||
|
||||
struct shmid_ds
|
||||
{
|
||||
ipc_perm shm_perm;
|
||||
size_t shm_segsz;
|
||||
pid_t shm_lpid;
|
||||
pid_t shm_cpid;
|
||||
shmatt_t shm_nattch;
|
||||
time_t shm_atime;
|
||||
time_t shm_dtime;
|
||||
time_t shm_ctime;
|
||||
}
|
||||
|
||||
void* shmat(int, in void*, int);
|
||||
int shmctl(int, int, shmid_ds*);
|
||||
int shmdt(in void*);
|
||||
int shmget(key_t, size_t, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum SHM_RDONLY = 010000;
|
||||
enum SHM_RND = 020000;
|
||||
|
||||
int __getpagesize();
|
||||
alias __getpagesize SHMLBA;
|
||||
|
||||
alias c_ulong shmatt_t;
|
||||
|
||||
struct shmid_ds
|
||||
{
|
||||
ipc_perm shm_perm;
|
||||
size_t shm_segsz;
|
||||
time_t shm_atime;
|
||||
c_ulong __unused1;
|
||||
time_t shm_dtime;
|
||||
c_ulong __unused2;
|
||||
time_t shm_ctime;
|
||||
c_ulong __unused3;
|
||||
pid_t shm_cpid;
|
||||
pid_t shm_lpid;
|
||||
shmatt_t shm_nattch;
|
||||
c_ulong __unused4;
|
||||
c_ulong __unused5;
|
||||
}
|
||||
|
||||
void* shmat(int, in void*, int);
|
||||
int shmctl(int, int, shmid_ds*);
|
||||
int shmdt(in void*);
|
||||
int shmget(key_t, size_t, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum SHM_RDONLY = 010000;
|
||||
enum SHM_RND = 020000;
|
||||
enum SHMLBA = 1 << 12; // PAGE_SIZE = (1<<PAGE_SHIFT)
|
||||
|
||||
alias c_ulong shmatt_t;
|
||||
|
||||
struct shmid_ds
|
||||
{
|
||||
ipc_perm shm_perm;
|
||||
size_t shm_segsz;
|
||||
time_t shm_atime;
|
||||
c_ulong __unused1;
|
||||
time_t shm_dtime;
|
||||
c_ulong __unused2;
|
||||
time_t shm_ctime;
|
||||
c_ulong __unused3;
|
||||
pid_t shm_cpid;
|
||||
pid_t shm_lpid;
|
||||
shmatt_t shm_nattch;
|
||||
c_ulong __unused4;
|
||||
c_ulong __unused5;
|
||||
}
|
||||
|
||||
void* shmat(int, in void*, int);
|
||||
int shmctl(int, int, shmid_ds*);
|
||||
int shmdt(in void*);
|
||||
int shmget(key_t, size_t, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
|
||||
}
|
||||
647
druntime/import/core/sys/posix/sys/socket.d
Normal file
647
druntime/import/core/sys/posix/sys/socket.d
Normal file
@@ -0,0 +1,647 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.socket;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for ssize_t, size_t
|
||||
public import core.sys.posix.sys.uio; // for iovec
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
socklen_t
|
||||
sa_family_t
|
||||
|
||||
struct sockaddr
|
||||
{
|
||||
sa_family_t sa_family;
|
||||
char sa_data[];
|
||||
}
|
||||
|
||||
struct sockaddr_storage
|
||||
{
|
||||
sa_family_t ss_family;
|
||||
}
|
||||
|
||||
struct msghdr
|
||||
{
|
||||
void* msg_name;
|
||||
socklen_t msg_namelen;
|
||||
struct iovec* msg_iov;
|
||||
int msg_iovlen;
|
||||
void* msg_control;
|
||||
socklen_t msg_controllen;
|
||||
int msg_flags;
|
||||
}
|
||||
|
||||
struct iovec {} // from core.sys.posix.sys.uio
|
||||
|
||||
struct cmsghdr
|
||||
{
|
||||
socklen_t cmsg_len;
|
||||
int cmsg_level;
|
||||
int cmsg_type;
|
||||
}
|
||||
|
||||
SCM_RIGHTS
|
||||
|
||||
CMSG_DATA(cmsg)
|
||||
CMSG_NXTHDR(mhdr,cmsg)
|
||||
CMSG_FIRSTHDR(mhdr)
|
||||
|
||||
struct linger
|
||||
{
|
||||
int l_onoff;
|
||||
int l_linger;
|
||||
}
|
||||
|
||||
SOCK_DGRAM
|
||||
SOCK_SEQPACKET
|
||||
SOCK_STREAM
|
||||
|
||||
SOL_SOCKET
|
||||
|
||||
SO_ACCEPTCONN
|
||||
SO_BROADCAST
|
||||
SO_DEBUG
|
||||
SO_DONTROUTE
|
||||
SO_ERROR
|
||||
SO_KEEPALIVE
|
||||
SO_LINGER
|
||||
SO_OOBINLINE
|
||||
SO_RCVBUF
|
||||
SO_RCVLOWAT
|
||||
SO_RCVTIMEO
|
||||
SO_REUSEADDR
|
||||
SO_SNDBUF
|
||||
SO_SNDLOWAT
|
||||
SO_SNDTIMEO
|
||||
SO_TYPE
|
||||
|
||||
SOMAXCONN
|
||||
|
||||
MSG_CTRUNC
|
||||
MSG_DONTROUTE
|
||||
MSG_EOR
|
||||
MSG_OOB
|
||||
MSG_PEEK
|
||||
MSG_TRUNC
|
||||
MSG_WAITALL
|
||||
|
||||
AF_INET
|
||||
AF_UNIX
|
||||
AF_UNSPEC
|
||||
|
||||
SHUT_RD
|
||||
SHUT_RDWR
|
||||
SHUT_WR
|
||||
|
||||
int accept(int, sockaddr*, socklen_t*);
|
||||
int bind(int, in sockaddr*, socklen_t);
|
||||
int connect(int, in sockaddr*, socklen_t);
|
||||
int getpeername(int, sockaddr*, socklen_t*);
|
||||
int getsockname(int, sockaddr*, socklen_t*);
|
||||
int getsockopt(int, int, int, void*, socklen_t*);
|
||||
int listen(int, int);
|
||||
ssize_t recv(int, void*, size_t, int);
|
||||
ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
|
||||
ssize_t recvmsg(int, msghdr*, int);
|
||||
ssize_t send(int, in void*, size_t, int);
|
||||
ssize_t sendmsg(int, in msghdr*, int);
|
||||
ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
|
||||
int setsockopt(int, int, int, in void*, socklen_t);
|
||||
int shutdown(int, int);
|
||||
int socket(int, int, int);
|
||||
int sockatmark(int);
|
||||
int socketpair(int, int, int, int[2]);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
alias uint socklen_t;
|
||||
alias ushort sa_family_t;
|
||||
|
||||
struct sockaddr
|
||||
{
|
||||
sa_family_t sa_family;
|
||||
byte[14] sa_data;
|
||||
}
|
||||
|
||||
private enum : size_t
|
||||
{
|
||||
_SS_SIZE = 128,
|
||||
_SS_PADSIZE = _SS_SIZE - (c_ulong.sizeof * 2)
|
||||
}
|
||||
|
||||
struct sockaddr_storage
|
||||
{
|
||||
sa_family_t ss_family;
|
||||
c_ulong __ss_align;
|
||||
byte[_SS_PADSIZE] __ss_padding;
|
||||
}
|
||||
|
||||
struct msghdr
|
||||
{
|
||||
void* msg_name;
|
||||
socklen_t msg_namelen;
|
||||
iovec* msg_iov;
|
||||
size_t msg_iovlen;
|
||||
void* msg_control;
|
||||
size_t msg_controllen;
|
||||
int msg_flags;
|
||||
}
|
||||
|
||||
struct cmsghdr
|
||||
{
|
||||
size_t cmsg_len;
|
||||
int cmsg_level;
|
||||
int cmsg_type;
|
||||
static if( false /* (!is( __STRICT_ANSI__ ) && __GNUC__ >= 2) || __STDC_VERSION__ >= 199901L */ )
|
||||
{
|
||||
ubyte[1] __cmsg_data;
|
||||
}
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SCM_RIGHTS = 0x01
|
||||
}
|
||||
|
||||
static if( false /* (!is( __STRICT_ANSI__ ) && __GNUC__ >= 2) || __STDC_VERSION__ >= 199901L */ )
|
||||
{
|
||||
extern (D) ubyte[1] CMSG_DATA( cmsghdr* cmsg ) { return cmsg.__cmsg_data; }
|
||||
}
|
||||
else
|
||||
{
|
||||
extern (D) ubyte* CMSG_DATA( cmsghdr* cmsg ) { return cast(ubyte*)( cmsg + 1 ); }
|
||||
}
|
||||
|
||||
private cmsghdr* __cmsg_nxthdr(msghdr*, cmsghdr*);
|
||||
alias __cmsg_nxthdr CMSG_NXTHDR;
|
||||
|
||||
extern (D) size_t CMSG_FIRSTHDR( msghdr* mhdr )
|
||||
{
|
||||
return cast(size_t)( mhdr.msg_controllen >= cmsghdr.sizeof
|
||||
? cast(cmsghdr*) mhdr.msg_control
|
||||
: cast(cmsghdr*) null );
|
||||
}
|
||||
|
||||
struct linger
|
||||
{
|
||||
int l_onoff;
|
||||
int l_linger;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOCK_DGRAM = 2,
|
||||
SOCK_SEQPACKET = 5,
|
||||
SOCK_STREAM = 1
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOL_SOCKET = 1
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SO_ACCEPTCONN = 30,
|
||||
SO_BROADCAST = 6,
|
||||
SO_DEBUG = 1,
|
||||
SO_DONTROUTE = 5,
|
||||
SO_ERROR = 4,
|
||||
SO_KEEPALIVE = 9,
|
||||
SO_LINGER = 13,
|
||||
SO_OOBINLINE = 10,
|
||||
SO_RCVBUF = 8,
|
||||
SO_RCVLOWAT = 18,
|
||||
SO_RCVTIMEO = 20,
|
||||
SO_REUSEADDR = 2,
|
||||
SO_SNDBUF = 7,
|
||||
SO_SNDLOWAT = 19,
|
||||
SO_SNDTIMEO = 21,
|
||||
SO_TYPE = 3
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOMAXCONN = 128
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
MSG_CTRUNC = 0x08,
|
||||
MSG_DONTROUTE = 0x04,
|
||||
MSG_EOR = 0x80,
|
||||
MSG_OOB = 0x01,
|
||||
MSG_PEEK = 0x02,
|
||||
MSG_TRUNC = 0x20,
|
||||
MSG_WAITALL = 0x100
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
AF_INET = 2,
|
||||
AF_UNIX = 1,
|
||||
AF_UNSPEC = 0
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SHUT_RD,
|
||||
SHUT_WR,
|
||||
SHUT_RDWR
|
||||
}
|
||||
|
||||
int accept(int, sockaddr*, socklen_t*);
|
||||
int bind(int, in sockaddr*, socklen_t);
|
||||
int connect(int, in sockaddr*, socklen_t);
|
||||
int getpeername(int, sockaddr*, socklen_t*);
|
||||
int getsockname(int, sockaddr*, socklen_t*);
|
||||
int getsockopt(int, int, int, void*, socklen_t*);
|
||||
int listen(int, int);
|
||||
ssize_t recv(int, void*, size_t, int);
|
||||
ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
|
||||
ssize_t recvmsg(int, msghdr*, int);
|
||||
ssize_t send(int, in void*, size_t, int);
|
||||
ssize_t sendmsg(int, in msghdr*, int);
|
||||
ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
|
||||
int setsockopt(int, int, int, in void*, socklen_t);
|
||||
int shutdown(int, int);
|
||||
int socket(int, int, int);
|
||||
int sockatmark(int);
|
||||
int socketpair(int, int, int, int[2]);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
alias uint socklen_t;
|
||||
alias ubyte sa_family_t;
|
||||
|
||||
struct sockaddr
|
||||
{
|
||||
ubyte sa_len;
|
||||
sa_family_t sa_family;
|
||||
byte[14] sa_data;
|
||||
}
|
||||
|
||||
private enum : size_t
|
||||
{
|
||||
_SS_PAD1 = long.sizeof - ubyte.sizeof - sa_family_t.sizeof,
|
||||
_SS_PAD2 = 128 - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1 - long.sizeof
|
||||
}
|
||||
|
||||
struct sockaddr_storage
|
||||
{
|
||||
ubyte ss_len;
|
||||
sa_family_t ss_family;
|
||||
byte[_SS_PAD1] __ss_pad1;
|
||||
long __ss_align;
|
||||
byte[_SS_PAD2] __ss_pad2;
|
||||
}
|
||||
|
||||
struct msghdr
|
||||
{
|
||||
void* msg_name;
|
||||
socklen_t msg_namelen;
|
||||
iovec* msg_iov;
|
||||
int msg_iovlen;
|
||||
void* msg_control;
|
||||
socklen_t msg_controllen;
|
||||
int msg_flags;
|
||||
}
|
||||
|
||||
struct cmsghdr
|
||||
{
|
||||
socklen_t cmsg_len;
|
||||
int cmsg_level;
|
||||
int cmsg_type;
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SCM_RIGHTS = 0x01
|
||||
}
|
||||
|
||||
/+
|
||||
CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + \
|
||||
ALIGN(sizeof(struct cmsghdr)))
|
||||
CMSG_NXTHDR(mhdr, cmsg) \
|
||||
(((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len) + \
|
||||
ALIGN(sizeof(struct cmsghdr)) > \
|
||||
(unsigned char *)(mhdr)->msg_control +(mhdr)->msg_controllen) ? \
|
||||
(struct cmsghdr *)0 /* NULL */ : \
|
||||
(struct cmsghdr *)((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len)))
|
||||
CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
|
||||
+/
|
||||
|
||||
struct linger
|
||||
{
|
||||
int l_onoff;
|
||||
int l_linger;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOCK_DGRAM = 2,
|
||||
SOCK_SEQPACKET = 5,
|
||||
SOCK_STREAM = 1
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SOL_SOCKET = 0xffff
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SO_ACCEPTCONN = 0x0002,
|
||||
SO_BROADCAST = 0x0020,
|
||||
SO_DEBUG = 0x0001,
|
||||
SO_DONTROUTE = 0x0010,
|
||||
SO_ERROR = 0x1007,
|
||||
SO_KEEPALIVE = 0x0008,
|
||||
SO_LINGER = 0x1080,
|
||||
SO_OOBINLINE = 0x0100,
|
||||
SO_RCVBUF = 0x1002,
|
||||
SO_RCVLOWAT = 0x1004,
|
||||
SO_RCVTIMEO = 0x1006,
|
||||
SO_REUSEADDR = 0x0004,
|
||||
SO_SNDBUF = 0x1001,
|
||||
SO_SNDLOWAT = 0x1003,
|
||||
SO_SNDTIMEO = 0x1005,
|
||||
SO_TYPE = 0x1008
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOMAXCONN = 128
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
MSG_CTRUNC = 0x20,
|
||||
MSG_DONTROUTE = 0x4,
|
||||
MSG_EOR = 0x8,
|
||||
MSG_OOB = 0x1,
|
||||
MSG_PEEK = 0x2,
|
||||
MSG_TRUNC = 0x10,
|
||||
MSG_WAITALL = 0x40
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
AF_INET = 2,
|
||||
AF_UNIX = 1,
|
||||
AF_UNSPEC = 0
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SHUT_RD,
|
||||
SHUT_WR,
|
||||
SHUT_RDWR
|
||||
}
|
||||
|
||||
int accept(int, sockaddr*, socklen_t*);
|
||||
int bind(int, in sockaddr*, socklen_t);
|
||||
int connect(int, in sockaddr*, socklen_t);
|
||||
int getpeername(int, sockaddr*, socklen_t*);
|
||||
int getsockname(int, sockaddr*, socklen_t*);
|
||||
int getsockopt(int, int, int, void*, socklen_t*);
|
||||
int listen(int, int);
|
||||
ssize_t recv(int, void*, size_t, int);
|
||||
ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
|
||||
ssize_t recvmsg(int, msghdr*, int);
|
||||
ssize_t send(int, in void*, size_t, int);
|
||||
ssize_t sendmsg(int, in msghdr*, int);
|
||||
ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
|
||||
int setsockopt(int, int, int, in void*, socklen_t);
|
||||
int shutdown(int, int);
|
||||
int socket(int, int, int);
|
||||
int sockatmark(int);
|
||||
int socketpair(int, int, int, int[2]);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias uint socklen_t;
|
||||
alias ubyte sa_family_t;
|
||||
|
||||
struct sockaddr
|
||||
{
|
||||
ubyte sa_len;
|
||||
sa_family_t sa_family;
|
||||
byte[14] sa_data;
|
||||
}
|
||||
|
||||
private
|
||||
{
|
||||
enum _SS_ALIGNSIZE = long.sizeof;
|
||||
enum _SS_MAXSIZE = 128;
|
||||
enum _SS_PAD1SIZE = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
|
||||
enum _SS_PAD2SIZE = _SS_MAXSIZE - ubyte.sizeof - sa_family_t.sizeof - _SS_PAD1SIZE - _SS_ALIGNSIZE;
|
||||
}
|
||||
|
||||
struct sockaddr_storage
|
||||
{
|
||||
ubyte ss_len;
|
||||
sa_family_t ss_family;
|
||||
byte[_SS_PAD1SIZE] __ss_pad1;
|
||||
long __ss_align;
|
||||
byte[_SS_PAD2SIZE] __ss_pad2;
|
||||
}
|
||||
|
||||
struct msghdr
|
||||
{
|
||||
void* msg_name;
|
||||
socklen_t msg_namelen;
|
||||
iovec* msg_iov;
|
||||
int msg_iovlen;
|
||||
void* msg_control;
|
||||
socklen_t msg_controllen;
|
||||
int msg_flags;
|
||||
}
|
||||
|
||||
struct cmsghdr
|
||||
{
|
||||
socklen_t cmsg_len;
|
||||
int cmsg_level;
|
||||
int cmsg_type;
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SCM_RIGHTS = 0x01
|
||||
}
|
||||
|
||||
/+
|
||||
CMSG_DATA(cmsg) ((unsigned char *)(cmsg) + \
|
||||
ALIGN(sizeof(struct cmsghdr)))
|
||||
CMSG_NXTHDR(mhdr, cmsg) \
|
||||
(((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len) + \
|
||||
ALIGN(sizeof(struct cmsghdr)) > \
|
||||
(unsigned char *)(mhdr)->msg_control +(mhdr)->msg_controllen) ? \
|
||||
(struct cmsghdr *)0 /* NULL */ : \
|
||||
(struct cmsghdr *)((unsigned char *)(cmsg) + ALIGN((cmsg)->cmsg_len)))
|
||||
CMSG_FIRSTHDR(mhdr) ((struct cmsghdr *)(mhdr)->msg_control)
|
||||
+/
|
||||
|
||||
struct linger
|
||||
{
|
||||
int l_onoff;
|
||||
int l_linger;
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOCK_DGRAM = 2,
|
||||
SOCK_SEQPACKET = 5,
|
||||
SOCK_STREAM = 1
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SOL_SOCKET = 0xffff
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
SO_ACCEPTCONN = 0x0002,
|
||||
SO_BROADCAST = 0x0020,
|
||||
SO_DEBUG = 0x0001,
|
||||
SO_DONTROUTE = 0x0010,
|
||||
SO_ERROR = 0x1007,
|
||||
SO_KEEPALIVE = 0x0008,
|
||||
SO_LINGER = 0x1080,
|
||||
SO_OOBINLINE = 0x0100,
|
||||
SO_RCVBUF = 0x1002,
|
||||
SO_RCVLOWAT = 0x1004,
|
||||
SO_RCVTIMEO = 0x1006,
|
||||
SO_REUSEADDR = 0x0004,
|
||||
SO_SNDBUF = 0x1001,
|
||||
SO_SNDLOWAT = 0x1003,
|
||||
SO_SNDTIMEO = 0x1005,
|
||||
SO_TYPE = 0x1008
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SOMAXCONN = 128
|
||||
}
|
||||
|
||||
enum : uint
|
||||
{
|
||||
MSG_CTRUNC = 0x20,
|
||||
MSG_DONTROUTE = 0x4,
|
||||
MSG_EOR = 0x8,
|
||||
MSG_OOB = 0x1,
|
||||
MSG_PEEK = 0x2,
|
||||
MSG_TRUNC = 0x10,
|
||||
MSG_WAITALL = 0x40
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
AF_INET = 2,
|
||||
AF_UNIX = 1,
|
||||
AF_UNSPEC = 0
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
SHUT_RD = 0,
|
||||
SHUT_WR = 1,
|
||||
SHUT_RDWR = 2
|
||||
}
|
||||
|
||||
int accept(int, sockaddr*, socklen_t*);
|
||||
int bind(int, in sockaddr*, socklen_t);
|
||||
int connect(int, in sockaddr*, socklen_t);
|
||||
int getpeername(int, sockaddr*, socklen_t*);
|
||||
int getsockname(int, sockaddr*, socklen_t*);
|
||||
int getsockopt(int, int, int, void*, socklen_t*);
|
||||
int listen(int, int);
|
||||
ssize_t recv(int, void*, size_t, int);
|
||||
ssize_t recvfrom(int, void*, size_t, int, sockaddr*, socklen_t*);
|
||||
ssize_t recvmsg(int, msghdr*, int);
|
||||
ssize_t send(int, in void*, size_t, int);
|
||||
ssize_t sendmsg(int, in msghdr*, int);
|
||||
ssize_t sendto(int, in void*, size_t, int, in sockaddr*, socklen_t);
|
||||
int setsockopt(int, int, int, in void*, socklen_t);
|
||||
int shutdown(int, int);
|
||||
int socket(int, int, int);
|
||||
int sockatmark(int);
|
||||
int socketpair(int, int, int, int[2]);
|
||||
}
|
||||
|
||||
//
|
||||
// IPV6 (IP6)
|
||||
//
|
||||
/*
|
||||
AF_INET6
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
AF_INET6 = 10
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
AF_INET6 = 30
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
AF_INET6 = 28
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Raw Sockets (RS)
|
||||
//
|
||||
/*
|
||||
SOCK_RAW
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum
|
||||
{
|
||||
SOCK_RAW = 3
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum
|
||||
{
|
||||
SOCK_RAW = 3
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum
|
||||
{
|
||||
SOCK_RAW = 3
|
||||
}
|
||||
}
|
||||
425
druntime/import/core/sys/posix/sys/stat.d
Normal file
425
druntime/import/core/sys/posix/sys/stat.d
Normal file
@@ -0,0 +1,425 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.stat;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.stdc.stdint;
|
||||
private import core.sys.posix.time; // for timespec
|
||||
public import core.stdc.stddef; // for size_t
|
||||
public import core.sys.posix.sys.types; // for off_t, mode_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct stat
|
||||
{
|
||||
dev_t st_dev;
|
||||
ino_t st_ino;
|
||||
mode_t st_mode;
|
||||
nlink_t st_nlink;
|
||||
uid_t st_uid;
|
||||
gid_t st_gid;
|
||||
off_t st_size;
|
||||
time_t st_atime;
|
||||
time_t st_mtime;
|
||||
time_t st_ctime;
|
||||
}
|
||||
|
||||
S_IRWXU
|
||||
S_IRUSR
|
||||
S_IWUSR
|
||||
S_IXUSR
|
||||
S_IRWXG
|
||||
S_IRGRP
|
||||
S_IWGRP
|
||||
S_IXGRP
|
||||
S_IRWXO
|
||||
S_IROTH
|
||||
S_IWOTH
|
||||
S_IXOTH
|
||||
S_ISUID
|
||||
S_ISGID
|
||||
S_ISVTX
|
||||
|
||||
S_ISBLK(m)
|
||||
S_ISCHR(m)
|
||||
S_ISDIR(m)
|
||||
S_ISFIFO(m)
|
||||
S_ISREG(m)
|
||||
S_ISLNK(m)
|
||||
S_ISSOCK(m)
|
||||
|
||||
S_TYPEISMQ(buf)
|
||||
S_TYPEISSEM(buf)
|
||||
S_TYPEISSHM(buf)
|
||||
|
||||
int chmod(in char*, mode_t);
|
||||
int fchmod(int, mode_t);
|
||||
int fstat(int, stat*);
|
||||
int lstat(in char*, stat*);
|
||||
int mkdir(in char*, mode_t);
|
||||
int mkfifo(in char*, mode_t);
|
||||
int stat(in char*, stat*);
|
||||
mode_t umask(mode_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
private alias uint _pad_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
private alias ushort _pad_t;
|
||||
}
|
||||
|
||||
struct stat_t
|
||||
{
|
||||
dev_t st_dev;
|
||||
_pad_t __pad1;
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
ino_t __st_ino;
|
||||
}
|
||||
else
|
||||
{
|
||||
ino_t st_ino;
|
||||
}
|
||||
mode_t st_mode;
|
||||
nlink_t st_nlink;
|
||||
uid_t st_uid;
|
||||
gid_t st_gid;
|
||||
dev_t st_rdev;
|
||||
_pad_t __pad2;
|
||||
off_t st_size;
|
||||
blksize_t st_blksize;
|
||||
blkcnt_t st_blocks;
|
||||
static if( false /*__USE_MISC*/ ) // true if _BSD_SOURCE || _SVID_SOURCE
|
||||
{
|
||||
timespec st_atim;
|
||||
timespec st_mtim;
|
||||
timespec st_ctim;
|
||||
alias st_atim.tv_sec st_atime;
|
||||
alias st_mtim.tv_sec st_mtime;
|
||||
alias st_ctim.tv_sec st_ctime;
|
||||
}
|
||||
else
|
||||
{
|
||||
time_t st_atime;
|
||||
c_ulong st_atimensec;
|
||||
time_t st_mtime;
|
||||
c_ulong st_mtimensec;
|
||||
time_t st_ctime;
|
||||
c_ulong st_ctimensec;
|
||||
}
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
ino_t st_ino;
|
||||
}
|
||||
else
|
||||
{
|
||||
c_ulong __unused4;
|
||||
c_ulong __unused5;
|
||||
}
|
||||
}
|
||||
|
||||
enum S_IRUSR = 0400;
|
||||
enum S_IWUSR = 0200;
|
||||
enum S_IXUSR = 0100;
|
||||
enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
|
||||
|
||||
enum S_IRGRP = S_IRUSR >> 3;
|
||||
enum S_IWGRP = S_IWUSR >> 3;
|
||||
enum S_IXGRP = S_IXUSR >> 3;
|
||||
enum S_IRWXG = S_IRWXU >> 3;
|
||||
|
||||
enum S_IROTH = S_IRGRP >> 3;
|
||||
enum S_IWOTH = S_IWGRP >> 3;
|
||||
enum S_IXOTH = S_IXGRP >> 3;
|
||||
enum S_IRWXO = S_IRWXG >> 3;
|
||||
|
||||
enum S_ISUID = 04000;
|
||||
enum S_ISGID = 02000;
|
||||
enum S_ISVTX = 01000;
|
||||
|
||||
private
|
||||
{
|
||||
extern (D) bool S_ISTYPE( mode_t mode, uint mask )
|
||||
{
|
||||
return ( mode & S_IFMT ) == mask;
|
||||
}
|
||||
}
|
||||
|
||||
extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
|
||||
extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
|
||||
extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
|
||||
extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
|
||||
extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
|
||||
extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
|
||||
extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
|
||||
|
||||
static if( true /*__USE_POSIX199309*/ )
|
||||
{
|
||||
extern bool S_TYPEISMQ( stat_t* buf ) { return false; }
|
||||
extern bool S_TYPEISSEM( stat_t* buf ) { return false; }
|
||||
extern bool S_TYPEISSHM( stat_t* buf ) { return false; }
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct stat_t
|
||||
{
|
||||
dev_t st_dev;
|
||||
ino_t st_ino;
|
||||
mode_t st_mode;
|
||||
nlink_t st_nlink;
|
||||
uid_t st_uid;
|
||||
gid_t st_gid;
|
||||
dev_t st_rdev;
|
||||
static if( false /*!_POSIX_C_SOURCE || _DARWIN_C_SOURCE*/ )
|
||||
{
|
||||
timespec st_atimespec;
|
||||
timespec st_mtimespec;
|
||||
timespec st_ctimespec;
|
||||
}
|
||||
else
|
||||
{
|
||||
time_t st_atime;
|
||||
c_long st_atimensec;
|
||||
time_t st_mtime;
|
||||
c_long st_mtimensec;
|
||||
time_t st_ctime;
|
||||
c_long st_ctimensec;
|
||||
}
|
||||
off_t st_size;
|
||||
blkcnt_t st_blocks;
|
||||
blksize_t st_blksize;
|
||||
uint st_flags;
|
||||
uint st_gen;
|
||||
int st_lspare;
|
||||
long st_qspare[2];
|
||||
}
|
||||
|
||||
enum S_IRUSR = 0400;
|
||||
enum S_IWUSR = 0200;
|
||||
enum S_IXUSR = 0100;
|
||||
enum S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
|
||||
|
||||
enum S_IRGRP = S_IRUSR >> 3;
|
||||
enum S_IWGRP = S_IWUSR >> 3;
|
||||
enum S_IXGRP = S_IXUSR >> 3;
|
||||
enum S_IRWXG = S_IRWXU >> 3;
|
||||
|
||||
enum S_IROTH = S_IRGRP >> 3;
|
||||
enum S_IWOTH = S_IWGRP >> 3;
|
||||
enum S_IXOTH = S_IXGRP >> 3;
|
||||
enum S_IRWXO = S_IRWXG >> 3;
|
||||
|
||||
enum S_ISUID = 04000;
|
||||
enum S_ISGID = 02000;
|
||||
enum S_ISVTX = 01000;
|
||||
|
||||
private
|
||||
{
|
||||
extern (D) bool S_ISTYPE( mode_t mode, uint mask )
|
||||
{
|
||||
return ( mode & S_IFMT ) == mask;
|
||||
}
|
||||
}
|
||||
|
||||
extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
|
||||
extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
|
||||
extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
|
||||
extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
|
||||
extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
|
||||
extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
|
||||
extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct stat_t
|
||||
{
|
||||
dev_t st_dev;
|
||||
ino_t st_ino;
|
||||
mode_t st_mode;
|
||||
nlink_t st_nlink;
|
||||
uid_t st_uid;
|
||||
gid_t st_gid;
|
||||
dev_t st_rdev;
|
||||
|
||||
timespec st_atimespec;
|
||||
timespec st_mtimespec;
|
||||
timespec st_ctimespec;
|
||||
time_t st_atime()
|
||||
{
|
||||
return st_atimespec.tv_sec;
|
||||
}
|
||||
time_t st_mtime()
|
||||
{
|
||||
return st_mtimespec.tv_sec;
|
||||
}
|
||||
time_t st_ctime()
|
||||
{
|
||||
return st_ctimespec.tv_sec;
|
||||
}
|
||||
|
||||
off_t st_size;
|
||||
blkcnt_t st_blocks;
|
||||
blksize_t st_blksize;
|
||||
fflags_t st_flags;
|
||||
uint st_gen;
|
||||
int st_lspare;
|
||||
timespec st_birthtimespec;
|
||||
|
||||
byte[16 - timespec.sizeof] padding;
|
||||
}
|
||||
|
||||
enum S_IRUSR = 0000400;
|
||||
enum S_IWUSR = 0000200;
|
||||
enum S_IXUSR = 0000100;
|
||||
enum S_IRWXU = 0000700;
|
||||
|
||||
enum S_IRGRP = 0000040;
|
||||
enum S_IWGRP = 0000020;
|
||||
enum S_IXGRP = 0000010;
|
||||
enum S_IRWXG = 0000070;
|
||||
|
||||
enum S_IROTH = 0000004;
|
||||
enum S_IWOTH = 0000002;
|
||||
enum S_IXOTH = 0000001;
|
||||
enum S_IRWXO = 0000007;
|
||||
|
||||
enum S_ISUID = 0004000;
|
||||
enum S_ISGID = 0002000;
|
||||
enum S_ISVTX = 0001000;
|
||||
|
||||
private
|
||||
{
|
||||
extern (D) bool S_ISTYPE( mode_t mode, uint mask )
|
||||
{
|
||||
return ( mode & S_IFMT ) == mask;
|
||||
}
|
||||
}
|
||||
|
||||
extern (D) bool S_ISBLK( mode_t mode ) { return S_ISTYPE( mode, S_IFBLK ); }
|
||||
extern (D) bool S_ISCHR( mode_t mode ) { return S_ISTYPE( mode, S_IFCHR ); }
|
||||
extern (D) bool S_ISDIR( mode_t mode ) { return S_ISTYPE( mode, S_IFDIR ); }
|
||||
extern (D) bool S_ISFIFO( mode_t mode ) { return S_ISTYPE( mode, S_IFIFO ); }
|
||||
extern (D) bool S_ISREG( mode_t mode ) { return S_ISTYPE( mode, S_IFREG ); }
|
||||
extern (D) bool S_ISLNK( mode_t mode ) { return S_ISTYPE( mode, S_IFLNK ); }
|
||||
extern (D) bool S_ISSOCK( mode_t mode ) { return S_ISTYPE( mode, S_IFSOCK ); }
|
||||
}
|
||||
|
||||
int chmod(in char*, mode_t);
|
||||
int fchmod(int, mode_t);
|
||||
//int fstat(int, stat_t*);
|
||||
//int lstat(in char*, stat_t*);
|
||||
int mkdir(in char*, mode_t);
|
||||
int mkfifo(in char*, mode_t);
|
||||
//int stat(in char*, stat_t*);
|
||||
mode_t umask(mode_t);
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int fstat64(int, stat_t*);
|
||||
alias fstat64 fstat;
|
||||
|
||||
int lstat64(in char*, stat_t*);
|
||||
alias lstat64 lstat;
|
||||
|
||||
int stat64(in char*, stat_t*);
|
||||
alias stat64 stat;
|
||||
}
|
||||
else
|
||||
{
|
||||
int fstat(int, stat_t*);
|
||||
int lstat(in char*, stat_t*);
|
||||
int stat(in char*, stat_t*);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int fstat(int, stat_t*);
|
||||
int lstat(in char*, stat_t*);
|
||||
int stat(in char*, stat_t*);
|
||||
}
|
||||
|
||||
//
|
||||
// Typed Memory Objects (TYM)
|
||||
//
|
||||
/*
|
||||
S_TYPEISTMO(buf)
|
||||
*/
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
S_IFMT
|
||||
S_IFBLK
|
||||
S_IFCHR
|
||||
S_IFIFO
|
||||
S_IFREG
|
||||
S_IFDIR
|
||||
S_IFLNK
|
||||
S_IFSOCK
|
||||
|
||||
int mknod(in 3char*, mode_t, dev_t);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum S_IFMT = 0170000;
|
||||
enum S_IFBLK = 0060000;
|
||||
enum S_IFCHR = 0020000;
|
||||
enum S_IFIFO = 0010000;
|
||||
enum S_IFREG = 0100000;
|
||||
enum S_IFDIR = 0040000;
|
||||
enum S_IFLNK = 0120000;
|
||||
enum S_IFSOCK = 0140000;
|
||||
|
||||
int mknod(in char*, mode_t, dev_t);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum S_IFMT = 0170000;
|
||||
enum S_IFBLK = 0060000;
|
||||
enum S_IFCHR = 0020000;
|
||||
enum S_IFIFO = 0010000;
|
||||
enum S_IFREG = 0100000;
|
||||
enum S_IFDIR = 0040000;
|
||||
enum S_IFLNK = 0120000;
|
||||
enum S_IFSOCK = 0140000;
|
||||
|
||||
int mknod(in char*, mode_t, dev_t);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum S_IFMT = 0170000;
|
||||
enum S_IFBLK = 0060000;
|
||||
enum S_IFCHR = 0020000;
|
||||
enum S_IFIFO = 0010000;
|
||||
enum S_IFREG = 0100000;
|
||||
enum S_IFDIR = 0040000;
|
||||
enum S_IFLNK = 0120000;
|
||||
enum S_IFSOCK = 0140000;
|
||||
|
||||
int mknod(in char*, mode_t, dev_t);
|
||||
}
|
||||
123
druntime/import/core/sys/posix/sys/time.d
Normal file
123
druntime/import/core/sys/posix/sys/time.d
Normal file
@@ -0,0 +1,123 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.time;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for time_t, suseconds_t
|
||||
public import core.sys.posix.sys.select; // for fd_set, FD_CLR() FD_ISSET() FD_SET() FD_ZERO() FD_SETSIZE, select()
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
struct timeval
|
||||
{
|
||||
time_t tv_sec;
|
||||
suseconds_t tv_usec;
|
||||
}
|
||||
|
||||
struct itimerval
|
||||
{
|
||||
timeval it_interval;
|
||||
timeval it_value;
|
||||
}
|
||||
|
||||
ITIMER_REAL
|
||||
ITIMER_VIRTUAL
|
||||
ITIMER_PROF
|
||||
|
||||
int getitimer(int, itimerval*);
|
||||
int gettimeofday(timeval*, void*);
|
||||
int select(int, fd_set*, fd_set*, fd_set*, timeval*); (defined in core.sys.posix.sys.signal)
|
||||
int setitimer(int, in itimerval*, itimerval*);
|
||||
int utimes(in char*, in timeval[2]); // LEGACY
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct timeval
|
||||
{
|
||||
time_t tv_sec;
|
||||
suseconds_t tv_usec;
|
||||
}
|
||||
|
||||
struct itimerval
|
||||
{
|
||||
timeval it_interval;
|
||||
timeval it_value;
|
||||
}
|
||||
|
||||
enum ITIMER_REAL = 0;
|
||||
enum ITIMER_VIRTUAL = 1;
|
||||
enum ITIMER_PROF = 2;
|
||||
|
||||
int getitimer(int, itimerval*);
|
||||
int gettimeofday(timeval*, void*);
|
||||
int setitimer(int, in itimerval*, itimerval*);
|
||||
int utimes(in char*, in timeval[2]); // LEGACY
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct timeval
|
||||
{
|
||||
time_t tv_sec;
|
||||
suseconds_t tv_usec;
|
||||
}
|
||||
|
||||
struct itimerval
|
||||
{
|
||||
timeval it_interval;
|
||||
timeval it_value;
|
||||
}
|
||||
|
||||
// non-standard
|
||||
struct timezone_t
|
||||
{
|
||||
int tz_minuteswest;
|
||||
int tz_dsttime;
|
||||
}
|
||||
|
||||
int getitimer(int, itimerval*);
|
||||
int gettimeofday(timeval*, timezone_t*); // timezone_t* is normally void*
|
||||
int setitimer(int, in itimerval*, itimerval*);
|
||||
int utimes(in char*, in timeval[2]);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct timeval
|
||||
{
|
||||
time_t tv_sec;
|
||||
suseconds_t tv_usec;
|
||||
}
|
||||
|
||||
struct itimerval
|
||||
{
|
||||
timeval it_interval;
|
||||
timeval it_value;
|
||||
}
|
||||
|
||||
// non-standard
|
||||
struct timezone_t
|
||||
{
|
||||
int tz_minuteswest;
|
||||
int tz_dsttime;
|
||||
}
|
||||
|
||||
int getitimer(int, itimerval*);
|
||||
int gettimeofday(timeval*, timezone_t*); // timezone_t* is normally void*
|
||||
int setitimer(int, in itimerval*, itimerval*);
|
||||
int utimes(in char*, in timeval[2]);
|
||||
}
|
||||
429
druntime/import/core/sys/posix/sys/types.d
Normal file
429
druntime/import/core/sys/posix/sys/types.d
Normal file
@@ -0,0 +1,429 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.types;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.stdc.stdint;
|
||||
public import core.stdc.stddef; // for size_t
|
||||
public import core.stdc.time; // for clock_t, time_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
blkcnt_t
|
||||
blksize_t
|
||||
dev_t
|
||||
gid_t
|
||||
ino_t
|
||||
mode_t
|
||||
nlink_t
|
||||
off_t
|
||||
pid_t
|
||||
size_t
|
||||
ssize_t
|
||||
time_t
|
||||
uid_t
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
alias long blkcnt_t;
|
||||
alias ulong ino_t;
|
||||
alias long off_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias c_long blkcnt_t;
|
||||
alias c_ulong ino_t;
|
||||
alias c_long off_t;
|
||||
}
|
||||
alias c_long blksize_t;
|
||||
alias ulong dev_t;
|
||||
alias uint gid_t;
|
||||
alias uint mode_t;
|
||||
alias c_ulong nlink_t;
|
||||
alias int pid_t;
|
||||
//size_t (defined in core.stdc.stddef)
|
||||
alias c_long ssize_t;
|
||||
//time_t (defined in core.stdc.time)
|
||||
alias uint uid_t;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
alias long blkcnt_t;
|
||||
alias int blksize_t;
|
||||
alias int dev_t;
|
||||
alias uint gid_t;
|
||||
alias uint ino_t;
|
||||
alias ushort mode_t;
|
||||
alias ushort nlink_t;
|
||||
alias long off_t;
|
||||
alias int pid_t;
|
||||
//size_t (defined in core.stdc.stddef)
|
||||
alias size_t ssize_t;
|
||||
//time_t (defined in core.stdc.time)
|
||||
alias uint uid_t;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias long blkcnt_t;
|
||||
alias uint blksize_t;
|
||||
alias uint dev_t;
|
||||
alias uint gid_t;
|
||||
alias uint ino_t;
|
||||
alias ushort mode_t;
|
||||
alias ushort nlink_t;
|
||||
alias long off_t;
|
||||
alias int pid_t;
|
||||
//size_t (defined in core.stdc.stddef)
|
||||
alias size_t ssize_t;
|
||||
//time_t (defined in core.stdc.time)
|
||||
alias uint uid_t;
|
||||
alias uint fflags_t;
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
clock_t
|
||||
fsblkcnt_t
|
||||
fsfilcnt_t
|
||||
id_t
|
||||
key_t
|
||||
suseconds_t
|
||||
useconds_t
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
alias ulong fsblkcnt_t;
|
||||
alias ulong fsfilcnt_t;
|
||||
}
|
||||
else
|
||||
{
|
||||
alias c_ulong fsblkcnt_t;
|
||||
alias c_ulong fsfilcnt_t;
|
||||
}
|
||||
// clock_t (defined in core.stdc.time)
|
||||
alias uint id_t;
|
||||
alias int key_t;
|
||||
alias c_long suseconds_t;
|
||||
alias uint useconds_t;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
//clock_t
|
||||
alias uint fsblkcnt_t;
|
||||
alias uint fsfilcnt_t;
|
||||
alias uint id_t;
|
||||
// key_t
|
||||
alias int suseconds_t;
|
||||
alias uint useconds_t;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
//clock_t
|
||||
alias ulong fsblkcnt_t;
|
||||
alias ulong fsfilcnt_t;
|
||||
alias long id_t;
|
||||
alias c_long key_t;
|
||||
alias c_long suseconds_t;
|
||||
alias uint useconds_t;
|
||||
}
|
||||
|
||||
//
|
||||
// Thread (THR)
|
||||
//
|
||||
/*
|
||||
pthread_attr_t
|
||||
pthread_cond_t
|
||||
pthread_condattr_t
|
||||
pthread_key_t
|
||||
pthread_mutex_t
|
||||
pthread_mutexattr_t
|
||||
pthread_once_t
|
||||
pthread_rwlock_t
|
||||
pthread_rwlockattr_t
|
||||
pthread_t
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
private struct __sched_param
|
||||
{
|
||||
int __sched_priority;
|
||||
}
|
||||
|
||||
struct pthread_attr_t
|
||||
{
|
||||
int __detachstate;
|
||||
int __schedpolicy;
|
||||
__sched_param __schedparam;
|
||||
int __inheritsched;
|
||||
int __scope;
|
||||
size_t __guardsize;
|
||||
int __stackaddr_set;
|
||||
void* __stackaddr;
|
||||
size_t __stacksize;
|
||||
}
|
||||
|
||||
private alias int __atomic_lock_t;
|
||||
|
||||
private struct _pthread_fastlock
|
||||
{
|
||||
c_long __status;
|
||||
__atomic_lock_t __spinlock;
|
||||
}
|
||||
|
||||
private alias void* _pthread_descr;
|
||||
|
||||
private alias long __pthread_cond_align_t;
|
||||
|
||||
struct pthread_cond_t
|
||||
{
|
||||
_pthread_fastlock __c_lock;
|
||||
_pthread_descr __c_waiting;
|
||||
char[48 -
|
||||
_pthread_fastlock.sizeof -
|
||||
_pthread_descr.sizeof -
|
||||
__pthread_cond_align_t.sizeof]
|
||||
__padding;
|
||||
__pthread_cond_align_t __align;
|
||||
}
|
||||
|
||||
struct pthread_condattr_t
|
||||
{
|
||||
int __dummy;
|
||||
}
|
||||
|
||||
alias uint pthread_key_t;
|
||||
|
||||
struct pthread_mutex_t
|
||||
{
|
||||
int __m_reserved;
|
||||
int __m_count;
|
||||
_pthread_descr __m_owner;
|
||||
int __m_kind;
|
||||
_pthread_fastlock __m_lock;
|
||||
}
|
||||
|
||||
struct pthread_mutexattr_t
|
||||
{
|
||||
int __mutexkind;
|
||||
}
|
||||
|
||||
alias int pthread_once_t;
|
||||
|
||||
struct pthread_rwlock_t
|
||||
{
|
||||
_pthread_fastlock __rw_lock;
|
||||
int __rw_readers;
|
||||
_pthread_descr __rw_writer;
|
||||
_pthread_descr __rw_read_waiting;
|
||||
_pthread_descr __rw_write_waiting;
|
||||
int __rw_kind;
|
||||
int __rw_pshared;
|
||||
}
|
||||
|
||||
struct pthread_rwlockattr_t
|
||||
{
|
||||
int __lockkind;
|
||||
int __pshared;
|
||||
}
|
||||
|
||||
alias c_ulong pthread_t;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
version( X86_64 )
|
||||
{
|
||||
enum __PTHREAD_SIZE__ = 1168;
|
||||
enum __PTHREAD_ATTR_SIZE__ = 56;
|
||||
enum __PTHREAD_MUTEXATTR_SIZE__ = 8;
|
||||
enum __PTHREAD_MUTEX_SIZE__ = 56;
|
||||
enum __PTHREAD_CONDATTR_SIZE__ = 8;
|
||||
enum __PTHREAD_COND_SIZE__ = 40;
|
||||
enum __PTHREAD_ONCE_SIZE__ = 8;
|
||||
enum __PTHREAD_RWLOCK_SIZE__ = 192;
|
||||
enum __PTHREAD_RWLOCKATTR_SIZE__ = 16;
|
||||
}
|
||||
else version( X86 )
|
||||
{
|
||||
enum __PTHREAD_SIZE__ = 596;
|
||||
enum __PTHREAD_ATTR_SIZE__ = 36;
|
||||
enum __PTHREAD_MUTEXATTR_SIZE__ = 8;
|
||||
enum __PTHREAD_MUTEX_SIZE__ = 40;
|
||||
enum __PTHREAD_CONDATTR_SIZE__ = 4;
|
||||
enum __PTHREAD_COND_SIZE__ = 24;
|
||||
enum __PTHREAD_ONCE_SIZE__ = 4;
|
||||
enum __PTHREAD_RWLOCK_SIZE__ = 124;
|
||||
enum __PTHREAD_RWLOCKATTR_SIZE__ = 12;
|
||||
}
|
||||
|
||||
struct pthread_handler_rec
|
||||
{
|
||||
void function(void*) __routine;
|
||||
void* __arg;
|
||||
pthread_handler_rec* __next;
|
||||
}
|
||||
|
||||
struct pthread_attr_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_ATTR_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_cond_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_COND_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_condattr_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_CONDATTR_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
alias c_ulong pthread_key_t;
|
||||
|
||||
struct pthread_mutex_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_MUTEX_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_mutexattr_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_MUTEXATTR_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_once_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_ONCE_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_rwlock_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_RWLOCK_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
struct pthread_rwlockattr_t
|
||||
{
|
||||
c_long __sig;
|
||||
byte[__PTHREAD_RWLOCKATTR_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
private struct _opaque_pthread_t
|
||||
{
|
||||
c_long __sig;
|
||||
pthread_handler_rec* __cleanup_stack;
|
||||
byte[__PTHREAD_SIZE__] __opaque;
|
||||
}
|
||||
|
||||
alias _opaque_pthread_t* pthread_t;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias int lwpid_t;
|
||||
|
||||
alias void* pthread_attr_t;
|
||||
alias void* pthread_cond_t;
|
||||
alias void* pthread_condattr_t;
|
||||
alias void* pthread_key_t;
|
||||
alias void* pthread_mutex_t;
|
||||
alias void* pthread_mutexattr_t;
|
||||
alias void* pthread_once_t;
|
||||
alias void* pthread_rwlock_t;
|
||||
alias void* pthread_rwlockattr_t;
|
||||
alias void* pthread_t;
|
||||
}
|
||||
|
||||
//
|
||||
// Barrier (BAR)
|
||||
//
|
||||
/*
|
||||
pthread_barrier_t
|
||||
pthread_barrierattr_t
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct pthread_barrier_t
|
||||
{
|
||||
_pthread_fastlock __ba_lock;
|
||||
int __ba_required;
|
||||
int __ba_present;
|
||||
_pthread_descr __ba_waiting;
|
||||
}
|
||||
|
||||
struct pthread_barrierattr_t
|
||||
{
|
||||
int __pshared;
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias void* pthread_barrier_t;
|
||||
alias void* pthread_barrierattr_t;
|
||||
}
|
||||
|
||||
//
|
||||
// Spin (SPN)
|
||||
//
|
||||
/*
|
||||
pthread_spinlock_t
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
alias int pthread_spinlock_t; // volatile
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
//struct pthread_spinlock_t;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
alias void* pthread_spinlock_t;
|
||||
}
|
||||
|
||||
//
|
||||
// Timer (TMR)
|
||||
//
|
||||
/*
|
||||
clockid_t
|
||||
timer_t
|
||||
*/
|
||||
|
||||
//
|
||||
// Trace (TRC)
|
||||
//
|
||||
/*
|
||||
trace_attr_t
|
||||
trace_event_id_t
|
||||
trace_event_set_t
|
||||
trace_id_t
|
||||
*/
|
||||
70
druntime/import/core/sys/posix/sys/uio.d
Normal file
70
druntime/import/core/sys/posix/sys/uio.d
Normal file
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.uio;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for ssize_t, size_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct iovec
|
||||
{
|
||||
void* iov_base;
|
||||
size_t iov_len;
|
||||
}
|
||||
|
||||
ssize_t // from core.sys.posix.sys.types
|
||||
size_t // from core.sys.posix.sys.types
|
||||
|
||||
ssize_t readv(int, in iovec*, int);
|
||||
ssize_t writev(int, in iovec*, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct iovec
|
||||
{
|
||||
void* iov_base;
|
||||
size_t iov_len;
|
||||
}
|
||||
|
||||
ssize_t readv(int, in iovec*, int);
|
||||
ssize_t writev(int, in iovec*, int);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct iovec
|
||||
{
|
||||
void* iov_base;
|
||||
size_t iov_len;
|
||||
}
|
||||
|
||||
ssize_t readv(int, in iovec*, int);
|
||||
ssize_t writev(int, in iovec*, int);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct iovec
|
||||
{
|
||||
void* iov_base;
|
||||
size_t iov_len;
|
||||
}
|
||||
|
||||
ssize_t readv(int, in iovec*, int);
|
||||
ssize_t writev(int, in iovec*, int);
|
||||
}
|
||||
141
druntime/import/core/sys/posix/sys/wait.d
Normal file
141
druntime/import/core/sys/posix/sys/wait.d
Normal file
@@ -0,0 +1,141 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.sys.wait;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for id_t, pid_t
|
||||
public import core.sys.posix.signal; // for siginfo_t (XSI)
|
||||
//public import core.sys.posix.resource; // for rusage (XSI)
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
WNOHANG
|
||||
WUNTRACED
|
||||
|
||||
WEXITSTATUS
|
||||
WIFCONTINUED
|
||||
WIFEXITED
|
||||
WIFSIGNALED
|
||||
WIFSTOPPED
|
||||
WSTOPSIG
|
||||
WTERMSIG
|
||||
|
||||
pid_t wait(int*);
|
||||
pid_t waitpid(pid_t, int*, int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum WNOHANG = 1;
|
||||
enum WUNTRACED = 2;
|
||||
|
||||
private
|
||||
{
|
||||
enum __W_CONTINUED = 0xFFFF;
|
||||
|
||||
extern (D) int __WTERMSIG( int status ) { return status & 0x7F; }
|
||||
}
|
||||
|
||||
//
|
||||
// NOTE: These macros assume __USE_BSD is not defined in the relevant
|
||||
// C headers as the parameter definition there is different and
|
||||
// much more complicated.
|
||||
//
|
||||
extern (D) int WEXITSTATUS( int status ) { return ( status & 0xFF00 ) >> 8; }
|
||||
extern (D) int WIFCONTINUED( int status ) { return status == __W_CONTINUED; }
|
||||
extern (D) bool WIFEXITED( int status ) { return __WTERMSIG( status ) == 0; }
|
||||
extern (D) bool WIFSIGNALED( int status )
|
||||
{
|
||||
return ( cast(byte) ( ( status & 0x7F ) + 1 ) >> 1 ) > 0;
|
||||
}
|
||||
extern (D) bool WIFSTOPPED( int status ) { return ( status & 0xFF ) == 0x7F; }
|
||||
extern (D) int WSTOPSIG( int status ) { return WEXITSTATUS( status ); }
|
||||
extern (D) int WTERMSIG( int status ) { return status & 0x7F; }
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum WNOHANG = 1;
|
||||
enum WUNTRACED = 2;
|
||||
|
||||
private
|
||||
{
|
||||
enum _WSTOPPED = 0177;
|
||||
}
|
||||
|
||||
extern (D) int _WSTATUS(int status) { return (status & 0177); }
|
||||
extern (D) int WEXITSTATUS( int status ) { return (status >> 8); }
|
||||
extern (D) int WIFCONTINUED( int status ) { return status == 0x13; }
|
||||
extern (D) bool WIFEXITED( int status ) { return _WSTATUS(status) == 0; }
|
||||
extern (D) bool WIFSIGNALED( int status )
|
||||
{
|
||||
return _WSTATUS( status ) != _WSTOPPED && _WSTATUS( status ) != 0;
|
||||
}
|
||||
extern (D) bool WIFSTOPPED( int status ) { return _WSTATUS( status ) == _WSTOPPED; }
|
||||
extern (D) int WSTOPSIG( int status ) { return status >> 8; }
|
||||
extern (D) int WTERMSIG( int status ) { return _WSTATUS( status ); }
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum WNOHANG = 1;
|
||||
enum WUNTRACED = 2;
|
||||
enum WCONTINUED = 4;
|
||||
|
||||
private
|
||||
{
|
||||
enum _WSTOPPED = 0177;
|
||||
}
|
||||
|
||||
extern (D) int _WSTATUS(int status) { return (status & 0177); }
|
||||
extern (D) int WEXITSTATUS( int status ) { return (status >> 8); }
|
||||
extern (D) int WIFCONTINUED( int status ) { return status == 0x13; }
|
||||
extern (D) bool WIFEXITED( int status ) { return _WSTATUS(status) == 0; }
|
||||
extern (D) bool WIFSIGNALED( int status )
|
||||
{
|
||||
return _WSTATUS( status ) != _WSTOPPED && _WSTATUS( status ) != 0;
|
||||
}
|
||||
extern (D) bool WIFSTOPPED( int status ) { return _WSTATUS( status ) == _WSTOPPED; }
|
||||
extern (D) int WSTOPSIG( int status ) { return status >> 8; }
|
||||
extern (D) int WTERMSIG( int status ) { return _WSTATUS( status ); }
|
||||
}
|
||||
else
|
||||
{
|
||||
static assert( false );
|
||||
}
|
||||
|
||||
pid_t wait(int*);
|
||||
pid_t waitpid(pid_t, int*, int);
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
WEXITED
|
||||
WSTOPPED
|
||||
WCONTINUED
|
||||
WNOHANG
|
||||
WNOWAIT
|
||||
|
||||
enum idtype_t
|
||||
{
|
||||
P_ALL,
|
||||
P_PID,
|
||||
P_PGID
|
||||
}
|
||||
|
||||
int waitid(idtype_t, id_t, siginfo_t*, int);
|
||||
*/
|
||||
528
druntime/import/core/sys/posix/termios.d
Normal file
528
druntime/import/core/sys/posix/termios.d
Normal file
@@ -0,0 +1,528 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.termios;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for pid_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
cc_t
|
||||
speed_t
|
||||
tcflag_t
|
||||
|
||||
NCCS
|
||||
|
||||
struct termios
|
||||
{
|
||||
tcflag_t c_iflag;
|
||||
tcflag_t c_oflag;
|
||||
tcflag_t c_cflag;
|
||||
tcflag_t c_lflag;
|
||||
cc_t[NCCS] c_cc;
|
||||
}
|
||||
|
||||
VEOF
|
||||
VEOL
|
||||
VERASE
|
||||
VINTR
|
||||
VKILL
|
||||
VMIN
|
||||
VQUIT
|
||||
VSTART
|
||||
VSTOP
|
||||
VSUSP
|
||||
VTIME
|
||||
|
||||
BRKINT
|
||||
ICRNL
|
||||
IGNBRK
|
||||
IGNCR
|
||||
IGNPAR
|
||||
INLCR
|
||||
INPCK
|
||||
ISTRIP
|
||||
IXOFF
|
||||
IXON
|
||||
PARMRK
|
||||
|
||||
OPOST
|
||||
|
||||
B0
|
||||
B50
|
||||
B75
|
||||
B110
|
||||
B134
|
||||
B150
|
||||
B200
|
||||
B300
|
||||
B600
|
||||
B1200
|
||||
B1800
|
||||
B2400
|
||||
B4800
|
||||
B9600
|
||||
B19200
|
||||
B38400
|
||||
|
||||
CSIZE
|
||||
CS5
|
||||
CS6
|
||||
CS7
|
||||
CS8
|
||||
CSTOPB
|
||||
CREAD
|
||||
PARENB
|
||||
PARODD
|
||||
HUPCL
|
||||
CLOCAL
|
||||
|
||||
ECHO
|
||||
ECHOE
|
||||
ECHOK
|
||||
ECHONL
|
||||
ICANON
|
||||
IEXTEN
|
||||
ISIG
|
||||
NOFLSH
|
||||
TOSTOP
|
||||
|
||||
TCSANOW
|
||||
TCSADRAIN
|
||||
TCSAFLUSH
|
||||
|
||||
TCIFLUSH
|
||||
TCIOFLUSH
|
||||
TCOFLUSH
|
||||
|
||||
TCIOFF
|
||||
TCION
|
||||
TCOOFF
|
||||
TCOON
|
||||
|
||||
speed_t cfgetispeed(in termios*);
|
||||
speed_t cfgetospeed(in termios*);
|
||||
int cfsetispeed(termios*, speed_t);
|
||||
int cfsetospeed(termios*, speed_t);
|
||||
int tcdrain(int);
|
||||
int tcflow(int, int);
|
||||
int tcflush(int, int);
|
||||
int tcgetattr(int, termios*);
|
||||
int tcsendbreak(int, int);
|
||||
int tcsetattr(int, int, in termios*);
|
||||
*/
|
||||
|
||||
version( OSX )
|
||||
{
|
||||
alias ubyte cc_t;
|
||||
alias uint speed_t;
|
||||
alias uint tcflag_t;
|
||||
|
||||
enum NCCS = 20;
|
||||
|
||||
struct termios
|
||||
{
|
||||
tcflag_t c_iflag;
|
||||
tcflag_t c_oflag;
|
||||
tcflag_t c_cflag;
|
||||
tcflag_t c_lflag;
|
||||
cc_t[NCCS] c_cc;
|
||||
speed_t c_ispeed;
|
||||
speed_t c_ospeed;
|
||||
}
|
||||
|
||||
enum VEOF = 0;
|
||||
enum VEOL = 1;
|
||||
enum VERASE = 3;
|
||||
enum VINTR = 8;
|
||||
enum VKILL = 5;
|
||||
enum VMIN = 16;
|
||||
enum VQUIT = 9;
|
||||
enum VSTART = 12;
|
||||
enum VSTOP = 13;
|
||||
enum VSUSP = 10;
|
||||
enum VTIME = 17;
|
||||
|
||||
enum BRKINT = 0x0000002;
|
||||
enum ICRNL = 0x0000100;
|
||||
enum IGNBRK = 0x0000001;
|
||||
enum IGNCR = 0x0000080;
|
||||
enum IGNPAR = 0x0000004;
|
||||
enum INLCR = 0x0000040;
|
||||
enum INPCK = 0x0000010;
|
||||
enum ISTRIP = 0x0000020;
|
||||
enum IXOFF = 0x0000400;
|
||||
enum IXON = 0x0000200;
|
||||
enum PARMRK = 0x0000008;
|
||||
|
||||
enum OPOST = 0x0000001;
|
||||
|
||||
enum B0 = 0;
|
||||
enum B50 = 50;
|
||||
enum B75 = 75;
|
||||
enum B110 = 110;
|
||||
enum B134 = 134;
|
||||
enum B150 = 150;
|
||||
enum B200 = 200;
|
||||
enum B300 = 300;
|
||||
enum B600 = 600;
|
||||
enum B1200 = 1200;
|
||||
enum B1800 = 1800;
|
||||
enum B2400 = 2400;
|
||||
enum B4800 = 4800;
|
||||
enum B9600 = 9600;
|
||||
enum B19200 = 19200;
|
||||
enum B38400 = 38400;
|
||||
|
||||
enum CSIZE = 0x0000300;
|
||||
enum CS5 = 0x0000000;
|
||||
enum CS6 = 0x0000100;
|
||||
enum CS7 = 0x0000200;
|
||||
enum CS8 = 0x0000300;
|
||||
enum CSTOPB = 0x0000400;
|
||||
enum CREAD = 0x0000800;
|
||||
enum PARENB = 0x0001000;
|
||||
enum PARODD = 0x0002000;
|
||||
enum HUPCL = 0x0004000;
|
||||
enum CLOCAL = 0x0008000;
|
||||
|
||||
enum ECHO = 0x00000008;
|
||||
enum ECHOE = 0x00000002;
|
||||
enum ECHOK = 0x00000004;
|
||||
enum ECHONL = 0x00000010;
|
||||
enum ICANON = 0x00000100;
|
||||
enum IEXTEN = 0x00000400;
|
||||
enum ISIG = 0x00000080;
|
||||
enum NOFLSH = 0x80000000;
|
||||
enum TOSTOP = 0x00400000;
|
||||
|
||||
enum TCSANOW = 0;
|
||||
enum TCSADRAIN = 1;
|
||||
enum TCSAFLUSH = 2;
|
||||
|
||||
enum TCIFLUSH = 1;
|
||||
enum TCOFLUSH = 2;
|
||||
enum TCIOFLUSH = 3;
|
||||
|
||||
enum TCIOFF = 3;
|
||||
enum TCION = 4;
|
||||
enum TCOOFF = 1;
|
||||
enum TCOON = 2;
|
||||
|
||||
speed_t cfgetispeed(in termios*);
|
||||
speed_t cfgetospeed(in termios*);
|
||||
int cfsetispeed(termios*, speed_t);
|
||||
int cfsetospeed(termios*, speed_t);
|
||||
int tcdrain(int);
|
||||
int tcflow(int, int);
|
||||
int tcflush(int, int);
|
||||
int tcgetattr(int, termios*);
|
||||
int tcsendbreak(int, int);
|
||||
int tcsetattr(int, int, in termios*);
|
||||
|
||||
}
|
||||
else version( linux )
|
||||
{
|
||||
alias ubyte cc_t;
|
||||
alias uint speed_t;
|
||||
alias uint tcflag_t;
|
||||
|
||||
enum NCCS = 32;
|
||||
|
||||
struct termios
|
||||
{
|
||||
tcflag_t c_iflag;
|
||||
tcflag_t c_oflag;
|
||||
tcflag_t c_cflag;
|
||||
tcflag_t c_lflag;
|
||||
cc_t c_line;
|
||||
cc_t[NCCS] c_cc;
|
||||
speed_t c_ispeed;
|
||||
speed_t c_ospeed;
|
||||
}
|
||||
|
||||
enum VEOF = 4;
|
||||
enum VEOL = 11;
|
||||
enum VERASE = 2;
|
||||
enum VINTR = 0;
|
||||
enum VKILL = 3;
|
||||
enum VMIN = 6;
|
||||
enum VQUIT = 1;
|
||||
enum VSTART = 8;
|
||||
enum VSTOP = 9;
|
||||
enum VSUSP = 10;
|
||||
enum VTIME = 5;
|
||||
|
||||
enum BRKINT = 0000002;
|
||||
enum ICRNL = 0000400;
|
||||
enum IGNBRK = 0000001;
|
||||
enum IGNCR = 0000200;
|
||||
enum IGNPAR = 0000004;
|
||||
enum INLCR = 0000100;
|
||||
enum INPCK = 0000020;
|
||||
enum ISTRIP = 0000040;
|
||||
enum IXOFF = 0010000;
|
||||
enum IXON = 0002000;
|
||||
enum PARMRK = 0000010;
|
||||
|
||||
enum OPOST = 0000001;
|
||||
|
||||
enum B0 = 0000000;
|
||||
enum B50 = 0000001;
|
||||
enum B75 = 0000002;
|
||||
enum B110 = 0000003;
|
||||
enum B134 = 0000004;
|
||||
enum B150 = 0000005;
|
||||
enum B200 = 0000006;
|
||||
enum B300 = 0000007;
|
||||
enum B600 = 0000010;
|
||||
enum B1200 = 0000011;
|
||||
enum B1800 = 0000012;
|
||||
enum B2400 = 0000013;
|
||||
enum B4800 = 0000014;
|
||||
enum B9600 = 0000015;
|
||||
enum B19200 = 0000016;
|
||||
enum B38400 = 0000017;
|
||||
|
||||
enum CSIZE = 0000060;
|
||||
enum CS5 = 0000000;
|
||||
enum CS6 = 0000020;
|
||||
enum CS7 = 0000040;
|
||||
enum CS8 = 0000060;
|
||||
enum CSTOPB = 0000100;
|
||||
enum CREAD = 0000200;
|
||||
enum PARENB = 0000400;
|
||||
enum PARODD = 0001000;
|
||||
enum HUPCL = 0002000;
|
||||
enum CLOCAL = 0004000;
|
||||
|
||||
enum ECHO = 0000010;
|
||||
enum ECHOE = 0000020;
|
||||
enum ECHOK = 0000040;
|
||||
enum ECHONL = 0000100;
|
||||
enum ICANON = 0000002;
|
||||
enum IEXTEN = 0100000;
|
||||
enum ISIG = 0000001;
|
||||
enum NOFLSH = 0000200;
|
||||
enum TOSTOP = 0000400;
|
||||
|
||||
enum TCSANOW = 0;
|
||||
enum TCSADRAIN = 1;
|
||||
enum TCSAFLUSH = 2;
|
||||
|
||||
enum TCIFLUSH = 0;
|
||||
enum TCOFLUSH = 1;
|
||||
enum TCIOFLUSH = 2;
|
||||
|
||||
enum TCIOFF = 2;
|
||||
enum TCION = 3;
|
||||
enum TCOOFF = 0;
|
||||
enum TCOON = 1;
|
||||
|
||||
speed_t cfgetispeed(in termios*);
|
||||
speed_t cfgetospeed(in termios*);
|
||||
int cfsetispeed(termios*, speed_t);
|
||||
int cfsetospeed(termios*, speed_t);
|
||||
int tcdrain(int);
|
||||
int tcflow(int, int);
|
||||
int tcflush(int, int);
|
||||
int tcgetattr(int, termios*);
|
||||
int tcsendbreak(int, int);
|
||||
int tcsetattr(int, int, in termios*);
|
||||
}
|
||||
else version ( freebsd )
|
||||
{
|
||||
alias ubyte cc_t;
|
||||
alias uint speed_t;
|
||||
alias uint tcflag_t;
|
||||
|
||||
enum NCCS = 20;
|
||||
|
||||
struct termios
|
||||
{
|
||||
tcflag_t c_iflag;
|
||||
tcflag_t c_oflag;
|
||||
tcflag_t c_cflag;
|
||||
tcflag_t c_lflag;
|
||||
cc_t[NCCS] c_cc;
|
||||
speed_t c_ispeed;
|
||||
speed_t c_ospeed;
|
||||
}
|
||||
|
||||
enum VEOF = 0;
|
||||
enum VEOL = 1;
|
||||
enum VERASE = 3;
|
||||
enum VINTR = 8;
|
||||
enum VKILL = 5;
|
||||
enum VMIN = 16;
|
||||
enum VQUIT = 9;
|
||||
enum VSTART = 12;
|
||||
enum VSTOP = 13;
|
||||
enum VSUSP = 10;
|
||||
enum VTIME = 17;
|
||||
|
||||
enum BRKINT = 0x0000002;
|
||||
enum ICRNL = 0x0000100;
|
||||
enum IGNBRK = 0x0000001;
|
||||
enum IGNCR = 0x0000080;
|
||||
enum IGNPAR = 0x0000004;
|
||||
enum INLCR = 0x0000040;
|
||||
enum INPCK = 0x0000010;
|
||||
enum ISTRIP = 0x0000020;
|
||||
enum IXOFF = 0x0000400;
|
||||
enum IXON = 0x0000200;
|
||||
enum PARMRK = 0x0000008;
|
||||
|
||||
enum OPOST = 0x0000001;
|
||||
|
||||
enum B0 = 0;
|
||||
enum B50 = 50;
|
||||
enum B75 = 75;
|
||||
enum B110 = 110;
|
||||
enum B134 = 134;
|
||||
enum B150 = 150;
|
||||
enum B200 = 200;
|
||||
enum B300 = 300;
|
||||
enum B600 = 600;
|
||||
enum B1200 = 1200;
|
||||
enum B1800 = 1800;
|
||||
enum B2400 = 2400;
|
||||
enum B4800 = 4800;
|
||||
enum B9600 = 9600;
|
||||
enum B19200 = 19200;
|
||||
enum B38400 = 38400;
|
||||
|
||||
enum CSIZE = 0x0000300;
|
||||
enum CS5 = 0x0000000;
|
||||
enum CS6 = 0x0000100;
|
||||
enum CS7 = 0x0000200;
|
||||
enum CS8 = 0x0000300;
|
||||
enum CSTOPB = 0x0000400;
|
||||
enum CREAD = 0x0000800;
|
||||
enum PARENB = 0x0001000;
|
||||
enum PARODD = 0x0002000;
|
||||
enum HUPCL = 0x0004000;
|
||||
enum CLOCAL = 0x0008000;
|
||||
|
||||
enum ECHO = 0x00000008;
|
||||
enum ECHOE = 0x00000002;
|
||||
enum ECHOK = 0x00000004;
|
||||
enum ECHONL = 0x00000010;
|
||||
enum ICANON = 0x00000100;
|
||||
enum IEXTEN = 0x00000400;
|
||||
enum ISIG = 0x00000080;
|
||||
enum NOFLSH = 0x80000000;
|
||||
enum TOSTOP = 0x00400000;
|
||||
|
||||
enum TCSANOW = 0;
|
||||
enum TCSADRAIN = 1;
|
||||
enum TCSAFLUSH = 2;
|
||||
|
||||
enum TCIFLUSH = 1;
|
||||
enum TCOFLUSH = 2;
|
||||
enum TCIOFLUSH = 3;
|
||||
|
||||
enum TCIOFF = 3;
|
||||
enum TCION = 4;
|
||||
enum TCOOFF = 1;
|
||||
enum TCOON = 2;
|
||||
|
||||
speed_t cfgetispeed(in termios*);
|
||||
speed_t cfgetospeed(in termios*);
|
||||
int cfsetispeed(termios*, speed_t);
|
||||
int cfsetospeed(termios*, speed_t);
|
||||
int tcdrain(int);
|
||||
int tcflow(int, int);
|
||||
int tcflush(int, int);
|
||||
int tcgetattr(int, termios*);
|
||||
int tcsendbreak(int, int);
|
||||
int tcsetattr(int, int, in termios*);
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
IXANY
|
||||
|
||||
ONLCR
|
||||
OCRNL
|
||||
ONOCR
|
||||
ONLRET
|
||||
OFILL
|
||||
NLDLY
|
||||
NL0
|
||||
NL1
|
||||
CRDLY
|
||||
CR0
|
||||
CR1
|
||||
CR2
|
||||
CR3
|
||||
TABDLY
|
||||
TAB0
|
||||
TAB1
|
||||
TAB2
|
||||
TAB3
|
||||
BSDLY
|
||||
BS0
|
||||
BS1
|
||||
VTDLY
|
||||
VT0
|
||||
VT1
|
||||
FFDLY
|
||||
FF0
|
||||
FF1
|
||||
|
||||
pid_t tcgetsid(int);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum IXANY = 0004000;
|
||||
|
||||
enum ONLCR = 0000004;
|
||||
enum OCRNL = 0000010;
|
||||
enum ONOCR = 0000020;
|
||||
enum ONLRET = 0000040;
|
||||
enum OFILL = 0000100;
|
||||
enum NLDLY = 0000400;
|
||||
enum NL0 = 0000000;
|
||||
enum NL1 = 0000400;
|
||||
enum CRDLY = 0003000;
|
||||
enum CR0 = 0000000;
|
||||
enum CR1 = 0001000;
|
||||
enum CR2 = 0002000;
|
||||
enum CR3 = 0003000;
|
||||
enum TABDLY = 0014000;
|
||||
enum TAB0 = 0000000;
|
||||
enum TAB1 = 0004000;
|
||||
enum TAB2 = 0010000;
|
||||
enum TAB3 = 0014000;
|
||||
enum BSDLY = 0020000;
|
||||
enum BS0 = 0000000;
|
||||
enum BS1 = 0020000;
|
||||
enum VTDLY = 0040000;
|
||||
enum VT0 = 0000000;
|
||||
enum VT1 = 0040000;
|
||||
enum FFDLY = 0100000;
|
||||
enum FF0 = 0000000;
|
||||
enum FF1 = 0100000;
|
||||
|
||||
pid_t tcgetsid(int);
|
||||
}
|
||||
270
druntime/import/core/sys/posix/time.d
Normal file
270
druntime/import/core/sys/posix/time.d
Normal file
@@ -0,0 +1,270 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.time;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.stdc.time;
|
||||
public import core.sys.posix.sys.types;
|
||||
public import core.sys.posix.signal; // for sigevent
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required (defined in core.stdc.time)
|
||||
//
|
||||
/*
|
||||
char* asctime(in tm*);
|
||||
clock_t clock();
|
||||
char* ctime(in time_t*);
|
||||
double difftime(time_t, time_t);
|
||||
tm* gmtime(in time_t*);
|
||||
tm* localtime(in time_t*);
|
||||
time_t mktime(tm*);
|
||||
size_t strftime(char*, size_t, in char*, in tm*);
|
||||
time_t time(time_t*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
time_t timegm(tm*); // non-standard
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
time_t timegm(tm*); // non-standard
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
time_t timegm(tm*); // non-standard
|
||||
}
|
||||
|
||||
//
|
||||
// C Extension (CX)
|
||||
// (defined in core.stdc.time)
|
||||
//
|
||||
/*
|
||||
char* tzname[];
|
||||
void tzset();
|
||||
*/
|
||||
|
||||
//
|
||||
// Process CPU-Time Clocks (CPT)
|
||||
//
|
||||
/*
|
||||
int clock_getcpuclockid(pid_t, clockid_t*);
|
||||
*/
|
||||
|
||||
//
|
||||
// Clock Selection (CS)
|
||||
//
|
||||
/*
|
||||
int clock_nanosleep(clockid_t, int, in timespec*, timespec*);
|
||||
*/
|
||||
|
||||
//
|
||||
// Monotonic Clock (MON)
|
||||
//
|
||||
/*
|
||||
CLOCK_MONOTONIC
|
||||
*/
|
||||
|
||||
//
|
||||
// Timer (TMR)
|
||||
//
|
||||
/*
|
||||
CLOCK_PROCESS_CPUTIME_ID (TMR|CPT)
|
||||
CLOCK_THREAD_CPUTIME_ID (TMR|TCT)
|
||||
|
||||
NOTE: timespec must be defined in core.sys.posix.signal to break
|
||||
a circular import.
|
||||
|
||||
struct timespec
|
||||
{
|
||||
time_t tv_sec;
|
||||
int tv_nsec;
|
||||
}
|
||||
|
||||
struct itimerspec
|
||||
{
|
||||
timespec it_interval;
|
||||
timespec it_value;
|
||||
}
|
||||
|
||||
CLOCK_REALTIME
|
||||
TIMER_ABSTIME
|
||||
|
||||
clockid_t
|
||||
timer_t
|
||||
|
||||
int clock_getres(clockid_t, timespec*);
|
||||
int clock_gettime(clockid_t, timespec*);
|
||||
int clock_settime(clockid_t, in timespec*);
|
||||
int nanosleep(in timespec*, timespec*);
|
||||
int timer_create(clockid_t, sigevent*, timer_t*);
|
||||
int timer_delete(timer_t);
|
||||
int timer_gettime(timer_t, itimerspec*);
|
||||
int timer_getoverrun(timer_t);
|
||||
int timer_settime(timer_t, int, in itimerspec*, itimerspec*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum CLOCK_PROCESS_CPUTIME_ID = 2; // (TMR|CPT)
|
||||
enum CLOCK_THREAD_CPUTIME_ID = 3; // (TMR|TCT)
|
||||
|
||||
// NOTE: See above for why this is commented out.
|
||||
//
|
||||
//struct timespec
|
||||
//{
|
||||
// time_t tv_sec;
|
||||
// c_long tv_nsec;
|
||||
//}
|
||||
|
||||
struct itimerspec
|
||||
{
|
||||
timespec it_interval;
|
||||
timespec it_value;
|
||||
}
|
||||
|
||||
enum CLOCK_REALTIME = 0;
|
||||
enum TIMER_ABSTIME = 0x01;
|
||||
|
||||
alias int clockid_t;
|
||||
alias int timer_t;
|
||||
|
||||
int clock_getres(clockid_t, timespec*);
|
||||
//int clock_gettime(clockid_t, timespec*);
|
||||
//int clock_settime(clockid_t, in timespec*);
|
||||
int nanosleep(in timespec*, timespec*);
|
||||
int timer_create(clockid_t, sigevent*, timer_t*);
|
||||
int timer_delete(timer_t);
|
||||
int timer_gettime(timer_t, itimerspec*);
|
||||
int timer_getoverrun(timer_t);
|
||||
int timer_settime(timer_t, int, in itimerspec*, itimerspec*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
int nanosleep(in timespec*, timespec*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum CLOCK_PROCESS_CPUTIME_ID = 2; // (TMR|CPT)
|
||||
enum CLOCK_THREAD_CPUTIME_ID = 3; // (TMR|TCT)
|
||||
|
||||
// NOTE: See above for why this is commented out.
|
||||
//
|
||||
//struct timespec
|
||||
//{
|
||||
// time_t tv_sec;
|
||||
// c_long tv_nsec;
|
||||
//}
|
||||
|
||||
struct itimerspec
|
||||
{
|
||||
timespec it_interval;
|
||||
timespec it_value;
|
||||
}
|
||||
|
||||
enum CLOCK_REALTIME = 0;
|
||||
enum TIMER_ABSTIME = 0x01;
|
||||
|
||||
//alias int clockid_t;
|
||||
alias int timer_t;
|
||||
|
||||
int clock_getres(clockid_t, timespec*);
|
||||
int clock_gettime(clockid_t, timespec*);
|
||||
int clock_settime(clockid_t, in timespec*);
|
||||
int nanosleep(in timespec*, timespec*);
|
||||
int timer_create(clockid_t, sigevent*, timer_t*);
|
||||
int timer_delete(timer_t);
|
||||
int timer_gettime(timer_t, itimerspec*);
|
||||
int timer_getoverrun(timer_t);
|
||||
int timer_settime(timer_t, int, in itimerspec*, itimerspec*);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Thread-Safe Functions (TSF)
|
||||
//
|
||||
/*
|
||||
char* asctime_r(in tm*, char*);
|
||||
char* ctime_r(in time_t*, char*);
|
||||
tm* gmtime_r(in time_t*, tm*);
|
||||
tm* localtime_r(in time_t*, tm*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
char* asctime_r(in tm*, char*);
|
||||
char* ctime_r(in time_t*, char*);
|
||||
tm* gmtime_r(in time_t*, tm*);
|
||||
tm* localtime_r(in time_t*, tm*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
char* asctime_r(in tm*, char*);
|
||||
char* ctime_r(in time_t*, char*);
|
||||
tm* gmtime_r(in time_t*, tm*);
|
||||
tm* localtime_r(in time_t*, tm*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
char* asctime_r(in tm*, char*);
|
||||
char* ctime_r(in time_t*, char*);
|
||||
tm* gmtime_r(in time_t*, tm*);
|
||||
tm* localtime_r(in time_t*, tm*);
|
||||
}
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
getdate_err
|
||||
|
||||
int daylight;
|
||||
int timezone;
|
||||
|
||||
tm* getdate(in char*);
|
||||
char* strptime(in char*, in char*, tm*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
extern __gshared int daylight;
|
||||
extern __gshared c_long timezone;
|
||||
|
||||
tm* getdate(in char*);
|
||||
char* strptime(in char*, in char*, tm*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
extern __gshared c_long timezone;
|
||||
|
||||
tm* getdate(in char*);
|
||||
char* strptime(in char*, in char*, tm*);
|
||||
}
|
||||
else version( FreeBSD )
|
||||
{
|
||||
extern __gshared c_long timezone;
|
||||
|
||||
//tm* getdate(in char*);
|
||||
char* strptime(in char*, in char*, tm*);
|
||||
}
|
||||
else version( Solaris )
|
||||
{
|
||||
extern __gshared c_long timezone;
|
||||
|
||||
//tm* getdate(in char*);
|
||||
char* strptime(in char*, in char*, tm*);
|
||||
}
|
||||
|
||||
160
druntime/import/core/sys/posix/ucontext.d
Normal file
160
druntime/import/core/sys/posix/ucontext.d
Normal file
@@ -0,0 +1,160 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.ucontext;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.signal; // for sigset_t, stack_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
mcontext_t
|
||||
|
||||
struct ucontext_t
|
||||
{
|
||||
ucontext_t* uc_link;
|
||||
sigset_t uc_sigmask;
|
||||
stack_t uc_stack;
|
||||
mcontext_t uc_mcontext;
|
||||
}
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
|
||||
version( X86_64 )
|
||||
{
|
||||
private
|
||||
{
|
||||
struct _libc_fpxreg
|
||||
{
|
||||
ushort[4] significand;
|
||||
ushort exponent;
|
||||
ushort[3] padding;
|
||||
}
|
||||
|
||||
struct _libc_xmmreg
|
||||
{
|
||||
uint[4] element;
|
||||
}
|
||||
|
||||
struct _libc_fpstate
|
||||
{
|
||||
ushort cwd;
|
||||
ushort swd;
|
||||
ushort ftw;
|
||||
ushort fop;
|
||||
ulong rip;
|
||||
ulong rdp;
|
||||
uint mxcsr;
|
||||
uint mxcr_mask;
|
||||
_libc_fpxreg[8] _st;
|
||||
_libc_xmmreg[16] _xmm;
|
||||
uint[24] padding;
|
||||
}
|
||||
|
||||
enum NGREG = 23;
|
||||
|
||||
alias c_long greg_t;
|
||||
alias greg_t[NGREG] gregset_t;
|
||||
alias _libc_fpstate* fpregset_t;
|
||||
}
|
||||
|
||||
struct mcontext_t
|
||||
{
|
||||
gregset_t gregs;
|
||||
fpregset_t fpregs;
|
||||
c_ulong[8] __reserved1;
|
||||
}
|
||||
|
||||
struct ucontext_t
|
||||
{
|
||||
c_ulong uc_flags;
|
||||
ucontext_t* uc_link;
|
||||
stack_t uc_stack;
|
||||
mcontext_t uc_mcontext;
|
||||
sigset_t uc_sigmask;
|
||||
_libc_fpstate __fpregs_mem;
|
||||
}
|
||||
}
|
||||
else version( X86 )
|
||||
{
|
||||
private
|
||||
{
|
||||
struct _libc_fpreg
|
||||
{
|
||||
ushort[4] significand;
|
||||
ushort exponent;
|
||||
}
|
||||
|
||||
struct _libc_fpstate
|
||||
{
|
||||
c_ulong cw;
|
||||
c_ulong sw;
|
||||
c_ulong tag;
|
||||
c_ulong ipoff;
|
||||
c_ulong cssel;
|
||||
c_ulong dataoff;
|
||||
c_ulong datasel;
|
||||
_libc_fpreg[8] _st;
|
||||
c_ulong status;
|
||||
}
|
||||
|
||||
enum NGREG = 19;
|
||||
|
||||
alias int greg_t;
|
||||
alias greg_t[NGREG] gregset_t;
|
||||
alias _libc_fpstate* fpregset_t;
|
||||
}
|
||||
|
||||
struct mcontext_t
|
||||
{
|
||||
gregset_t gregs;
|
||||
fpregset_t fpregs;
|
||||
c_ulong oldmask;
|
||||
c_ulong cr2;
|
||||
}
|
||||
|
||||
struct ucontext_t
|
||||
{
|
||||
c_ulong uc_flags;
|
||||
ucontext_t* uc_link;
|
||||
stack_t uc_stack;
|
||||
mcontext_t uc_mcontext;
|
||||
sigset_t uc_sigmask;
|
||||
_libc_fpstate __fpregs_mem;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Obsolescent (OB)
|
||||
//
|
||||
/*
|
||||
int getcontext(ucontext_t*);
|
||||
void makecontext(ucontext_t*, void function(), int, ...);
|
||||
int setcontext(in ucontext_t*);
|
||||
int swapcontext(ucontext_t*, in ucontext_t*);
|
||||
*/
|
||||
|
||||
static if( is( ucontext_t ) )
|
||||
{
|
||||
int getcontext(ucontext_t*);
|
||||
void makecontext(ucontext_t*, void function(), int, ...);
|
||||
int setcontext(in ucontext_t*);
|
||||
int swapcontext(ucontext_t*, in ucontext_t*);
|
||||
}
|
||||
599
druntime/import/core/sys/posix/unistd.d
Normal file
599
druntime/import/core/sys/posix/unistd.d
Normal file
@@ -0,0 +1,599 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.unistd;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
private import core.stdc.stddef;
|
||||
public import core.sys.posix.inttypes; // for intptr_t
|
||||
public import core.sys.posix.sys.types; // for size_t, ssize_t, uid_t, gid_t, off_t, pid_t, useconds_t
|
||||
|
||||
extern (C):
|
||||
|
||||
enum STDIN_FILENO = 0;
|
||||
enum STDOUT_FILENO = 1;
|
||||
enum STDERR_FILENO = 2;
|
||||
|
||||
char* optarg;
|
||||
int optind;
|
||||
int opterr;
|
||||
int optopt;
|
||||
|
||||
int access(in char*, int);
|
||||
uint alarm(uint);
|
||||
int chdir(in char*);
|
||||
int chown(in char*, uid_t, gid_t);
|
||||
int close(int);
|
||||
size_t confstr(int, char*, size_t);
|
||||
int dup(int);
|
||||
int dup2(int, int);
|
||||
int execl(in char*, in char*, ...);
|
||||
int execle(in char*, in char*, ...);
|
||||
int execlp(in char*, in char*, ...);
|
||||
int execv(in char*, in char**);
|
||||
int execve(in char*, in char**, in char**);
|
||||
int execvp(in char*, in char**);
|
||||
void _exit(int);
|
||||
int fchown(int, uid_t, gid_t);
|
||||
pid_t fork();
|
||||
c_long fpathconf(int, int);
|
||||
//int ftruncate(int, off_t);
|
||||
char* getcwd(char*, size_t);
|
||||
gid_t getegid();
|
||||
uid_t geteuid();
|
||||
gid_t getgid();
|
||||
int getgroups(int, gid_t *);
|
||||
int gethostname(char*, size_t);
|
||||
char* getlogin();
|
||||
int getlogin_r(char*, size_t);
|
||||
int getopt(int, in char**, in char*);
|
||||
pid_t getpgrp();
|
||||
pid_t getpid();
|
||||
pid_t getppid();
|
||||
uid_t getuid();
|
||||
int isatty(int);
|
||||
int link(in char*, in char*);
|
||||
//off_t lseek(int, off_t, int);
|
||||
c_long pathconf(in char*, int);
|
||||
int pause();
|
||||
int pipe(int[2]);
|
||||
ssize_t read(int, void*, size_t);
|
||||
ssize_t readlink(in char*, char*, size_t);
|
||||
int rmdir(in char*);
|
||||
int setegid(gid_t);
|
||||
int seteuid(uid_t);
|
||||
int setgid(gid_t);
|
||||
int setpgid(pid_t, pid_t);
|
||||
pid_t setsid();
|
||||
int setuid(uid_t);
|
||||
uint sleep(uint);
|
||||
int symlink(in char*, in char*);
|
||||
c_long sysconf(int);
|
||||
pid_t tcgetpgrp(int);
|
||||
int tcsetpgrp(int, pid_t);
|
||||
char* ttyname(int);
|
||||
int ttyname_r(int, char*, size_t);
|
||||
int unlink(in char*);
|
||||
ssize_t write(int, in void*, size_t);
|
||||
|
||||
version( linux )
|
||||
{
|
||||
static if( __USE_FILE_OFFSET64 )
|
||||
{
|
||||
off_t lseek64(int, off_t, int);
|
||||
alias lseek64 lseek;
|
||||
}
|
||||
else
|
||||
{
|
||||
off_t lseek(int, off_t, int);
|
||||
}
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int ftruncate64(int, off_t);
|
||||
alias ftruncate64 ftruncate;
|
||||
}
|
||||
else
|
||||
{
|
||||
int ftruncate(int, off_t);
|
||||
}
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
off_t lseek(int, off_t, int);
|
||||
int ftruncate(int, off_t);
|
||||
}
|
||||
else
|
||||
{
|
||||
off_t lseek(int, off_t, int);
|
||||
int ftruncate(int, off_t);
|
||||
}
|
||||
|
||||
version( linux )
|
||||
{
|
||||
enum F_OK = 0;
|
||||
enum R_OK = 4;
|
||||
enum W_OK = 2;
|
||||
enum X_OK = 1;
|
||||
|
||||
enum F_ULOCK = 0;
|
||||
enum F_LOCK = 1;
|
||||
enum F_TLOCK = 2;
|
||||
enum F_TEST = 3;
|
||||
|
||||
enum
|
||||
{
|
||||
_CS_PATH,
|
||||
|
||||
_CS_V6_WIDTH_RESTRICTED_ENVS,
|
||||
|
||||
_CS_GNU_LIBC_VERSION,
|
||||
_CS_GNU_LIBPTHREAD_VERSION,
|
||||
|
||||
_CS_LFS_CFLAGS = 1000,
|
||||
_CS_LFS_LDFLAGS,
|
||||
_CS_LFS_LIBS,
|
||||
_CS_LFS_LINTFLAGS,
|
||||
_CS_LFS64_CFLAGS,
|
||||
_CS_LFS64_LDFLAGS,
|
||||
_CS_LFS64_LIBS,
|
||||
_CS_LFS64_LINTFLAGS,
|
||||
|
||||
_CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
|
||||
_CS_XBS5_ILP32_OFF32_LDFLAGS,
|
||||
_CS_XBS5_ILP32_OFF32_LIBS,
|
||||
_CS_XBS5_ILP32_OFF32_LINTFLAGS,
|
||||
_CS_XBS5_ILP32_OFFBIG_CFLAGS,
|
||||
_CS_XBS5_ILP32_OFFBIG_LDFLAGS,
|
||||
_CS_XBS5_ILP32_OFFBIG_LIBS,
|
||||
_CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
|
||||
_CS_XBS5_LP64_OFF64_CFLAGS,
|
||||
_CS_XBS5_LP64_OFF64_LDFLAGS,
|
||||
_CS_XBS5_LP64_OFF64_LIBS,
|
||||
_CS_XBS5_LP64_OFF64_LINTFLAGS,
|
||||
_CS_XBS5_LPBIG_OFFBIG_CFLAGS,
|
||||
_CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
|
||||
_CS_XBS5_LPBIG_OFFBIG_LIBS,
|
||||
_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
|
||||
|
||||
_CS_POSIX_V6_ILP32_OFF32_CFLAGS,
|
||||
_CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
|
||||
_CS_POSIX_V6_ILP32_OFF32_LIBS,
|
||||
_CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
|
||||
_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
|
||||
_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
|
||||
_CS_POSIX_V6_ILP32_OFFBIG_LIBS,
|
||||
_CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
|
||||
_CS_POSIX_V6_LP64_OFF64_CFLAGS,
|
||||
_CS_POSIX_V6_LP64_OFF64_LDFLAGS,
|
||||
_CS_POSIX_V6_LP64_OFF64_LIBS,
|
||||
_CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
|
||||
_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
|
||||
_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
|
||||
_CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
|
||||
_CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
_PC_LINK_MAX,
|
||||
_PC_MAX_CANON,
|
||||
_PC_MAX_INPUT,
|
||||
_PC_NAME_MAX,
|
||||
_PC_PATH_MAX,
|
||||
_PC_PIPE_BUF,
|
||||
_PC_CHOWN_RESTRICTED,
|
||||
_PC_NO_TRUNC,
|
||||
_PC_VDISABLE,
|
||||
_PC_SYNC_IO,
|
||||
_PC_ASYNC_IO,
|
||||
_PC_PRIO_IO,
|
||||
_PC_SOCK_MAXBUF,
|
||||
_PC_FILESIZEBITS,
|
||||
_PC_REC_INCR_XFER_SIZE,
|
||||
_PC_REC_MAX_XFER_SIZE,
|
||||
_PC_REC_MIN_XFER_SIZE,
|
||||
_PC_REC_XFER_ALIGN,
|
||||
_PC_ALLOC_SIZE_MIN,
|
||||
_PC_SYMLINK_MAX,
|
||||
_PC_2_SYMLINKS
|
||||
}
|
||||
|
||||
enum
|
||||
{
|
||||
_SC_ARG_MAX,
|
||||
_SC_CHILD_MAX,
|
||||
_SC_CLK_TCK,
|
||||
_SC_NGROUPS_MAX,
|
||||
_SC_OPEN_MAX,
|
||||
_SC_STREAM_MAX,
|
||||
_SC_TZNAME_MAX,
|
||||
_SC_JOB_CONTROL,
|
||||
_SC_SAVED_IDS,
|
||||
_SC_REALTIME_SIGNALS,
|
||||
_SC_PRIORITY_SCHEDULING,
|
||||
_SC_TIMERS,
|
||||
_SC_ASYNCHRONOUS_IO,
|
||||
_SC_PRIORITIZED_IO,
|
||||
_SC_SYNCHRONIZED_IO,
|
||||
_SC_FSYNC,
|
||||
_SC_MAPPED_FILES,
|
||||
_SC_MEMLOCK,
|
||||
_SC_MEMLOCK_RANGE,
|
||||
_SC_MEMORY_PROTECTION,
|
||||
_SC_MESSAGE_PASSING,
|
||||
_SC_SEMAPHORES,
|
||||
_SC_SHARED_MEMORY_OBJECTS,
|
||||
_SC_AIO_LISTIO_MAX,
|
||||
_SC_AIO_MAX,
|
||||
_SC_AIO_PRIO_DELTA_MAX,
|
||||
_SC_DELAYTIMER_MAX,
|
||||
_SC_MQ_OPEN_MAX,
|
||||
_SC_MQ_PRIO_MAX,
|
||||
_SC_VERSION,
|
||||
_SC_PAGESIZE,
|
||||
_SC_PAGE_SIZE = _SC_PAGESIZE,
|
||||
_SC_RTSIG_MAX,
|
||||
_SC_SEM_NSEMS_MAX,
|
||||
_SC_SEM_VALUE_MAX,
|
||||
_SC_SIGQUEUE_MAX,
|
||||
_SC_TIMER_MAX,
|
||||
|
||||
_SC_BC_BASE_MAX,
|
||||
_SC_BC_DIM_MAX,
|
||||
_SC_BC_SCALE_MAX,
|
||||
_SC_BC_STRING_MAX,
|
||||
_SC_COLL_WEIGHTS_MAX,
|
||||
_SC_EQUIV_CLASS_MAX,
|
||||
_SC_EXPR_NEST_MAX,
|
||||
_SC_LINE_MAX,
|
||||
_SC_RE_DUP_MAX,
|
||||
_SC_CHARCLASS_NAME_MAX,
|
||||
|
||||
_SC_2_VERSION,
|
||||
_SC_2_C_BIND,
|
||||
_SC_2_C_DEV,
|
||||
_SC_2_FORT_DEV,
|
||||
_SC_2_FORT_RUN,
|
||||
_SC_2_SW_DEV,
|
||||
_SC_2_LOCALEDEF,
|
||||
|
||||
_SC_PII,
|
||||
_SC_PII_XTI,
|
||||
_SC_PII_SOCKET,
|
||||
_SC_PII_INTERNET,
|
||||
_SC_PII_OSI,
|
||||
_SC_POLL,
|
||||
_SC_SELECT,
|
||||
_SC_UIO_MAXIOV,
|
||||
_SC_IOV_MAX = _SC_UIO_MAXIOV,
|
||||
_SC_PII_INTERNET_STREAM,
|
||||
_SC_PII_INTERNET_DGRAM,
|
||||
_SC_PII_OSI_COTS,
|
||||
_SC_PII_OSI_CLTS,
|
||||
_SC_PII_OSI_M,
|
||||
_SC_T_IOV_MAX,
|
||||
|
||||
_SC_THREADS,
|
||||
_SC_THREAD_SAFE_FUNCTIONS,
|
||||
_SC_GETGR_R_SIZE_MAX,
|
||||
_SC_GETPW_R_SIZE_MAX,
|
||||
_SC_LOGIN_NAME_MAX,
|
||||
_SC_TTY_NAME_MAX,
|
||||
_SC_THREAD_DESTRUCTOR_ITERATIONS,
|
||||
_SC_THREAD_KEYS_MAX,
|
||||
_SC_THREAD_STACK_MIN,
|
||||
_SC_THREAD_THREADS_MAX,
|
||||
_SC_THREAD_ATTR_STACKADDR,
|
||||
_SC_THREAD_ATTR_STACKSIZE,
|
||||
_SC_THREAD_PRIORITY_SCHEDULING,
|
||||
_SC_THREAD_PRIO_INHERIT,
|
||||
_SC_THREAD_PRIO_PROTECT,
|
||||
_SC_THREAD_PROCESS_SHARED,
|
||||
|
||||
_SC_NPROCESSORS_CONF,
|
||||
_SC_NPROCESSORS_ONLN,
|
||||
_SC_PHYS_PAGES,
|
||||
_SC_AVPHYS_PAGES,
|
||||
_SC_ATEXIT_MAX,
|
||||
_SC_PASS_MAX,
|
||||
|
||||
_SC_XOPEN_VERSION,
|
||||
_SC_XOPEN_XCU_VERSION,
|
||||
_SC_XOPEN_UNIX,
|
||||
_SC_XOPEN_CRYPT,
|
||||
_SC_XOPEN_ENH_I18N,
|
||||
_SC_XOPEN_SHM,
|
||||
|
||||
_SC_2_CHAR_TERM,
|
||||
_SC_2_C_VERSION,
|
||||
_SC_2_UPE,
|
||||
|
||||
_SC_XOPEN_XPG2,
|
||||
_SC_XOPEN_XPG3,
|
||||
_SC_XOPEN_XPG4,
|
||||
|
||||
_SC_CHAR_BIT,
|
||||
_SC_CHAR_MAX,
|
||||
_SC_CHAR_MIN,
|
||||
_SC_INT_MAX,
|
||||
_SC_INT_MIN,
|
||||
_SC_LONG_BIT,
|
||||
_SC_WORD_BIT,
|
||||
_SC_MB_LEN_MAX,
|
||||
_SC_NZERO,
|
||||
_SC_SSIZE_MAX,
|
||||
_SC_SCHAR_MAX,
|
||||
_SC_SCHAR_MIN,
|
||||
_SC_SHRT_MAX,
|
||||
_SC_SHRT_MIN,
|
||||
_SC_UCHAR_MAX,
|
||||
_SC_UINT_MAX,
|
||||
_SC_ULONG_MAX,
|
||||
_SC_USHRT_MAX,
|
||||
|
||||
_SC_NL_ARGMAX,
|
||||
_SC_NL_LANGMAX,
|
||||
_SC_NL_MSGMAX,
|
||||
_SC_NL_NMAX,
|
||||
_SC_NL_SETMAX,
|
||||
_SC_NL_TEXTMAX,
|
||||
|
||||
_SC_XBS5_ILP32_OFF32,
|
||||
_SC_XBS5_ILP32_OFFBIG,
|
||||
_SC_XBS5_LP64_OFF64,
|
||||
_SC_XBS5_LPBIG_OFFBIG,
|
||||
|
||||
_SC_XOPEN_LEGACY,
|
||||
_SC_XOPEN_REALTIME,
|
||||
_SC_XOPEN_REALTIME_THREADS,
|
||||
|
||||
_SC_ADVISORY_INFO,
|
||||
_SC_BARRIERS,
|
||||
_SC_BASE,
|
||||
_SC_C_LANG_SUPPORT,
|
||||
_SC_C_LANG_SUPPORT_R,
|
||||
_SC_CLOCK_SELECTION,
|
||||
_SC_CPUTIME,
|
||||
_SC_THREAD_CPUTIME,
|
||||
_SC_DEVICE_IO,
|
||||
_SC_DEVICE_SPECIFIC,
|
||||
_SC_DEVICE_SPECIFIC_R,
|
||||
_SC_FD_MGMT,
|
||||
_SC_FIFO,
|
||||
_SC_PIPE,
|
||||
_SC_FILE_ATTRIBUTES,
|
||||
_SC_FILE_LOCKING,
|
||||
_SC_FILE_SYSTEM,
|
||||
_SC_MONOTONIC_CLOCK,
|
||||
_SC_MULTI_PROCESS,
|
||||
_SC_SINGLE_PROCESS,
|
||||
_SC_NETWORKING,
|
||||
_SC_READER_WRITER_LOCKS,
|
||||
_SC_SPIN_LOCKS,
|
||||
_SC_REGEXP,
|
||||
_SC_REGEX_VERSION,
|
||||
_SC_SHELL,
|
||||
_SC_SIGNALS,
|
||||
_SC_SPAWN,
|
||||
_SC_SPORADIC_SERVER,
|
||||
_SC_THREAD_SPORADIC_SERVER,
|
||||
_SC_SYSTEM_DATABASE,
|
||||
_SC_SYSTEM_DATABASE_R,
|
||||
_SC_TIMEOUTS,
|
||||
_SC_TYPED_MEMORY_OBJECTS,
|
||||
_SC_USER_GROUPS,
|
||||
_SC_USER_GROUPS_R,
|
||||
_SC_2_PBS,
|
||||
_SC_2_PBS_ACCOUNTING,
|
||||
_SC_2_PBS_LOCATE,
|
||||
_SC_2_PBS_MESSAGE,
|
||||
_SC_2_PBS_TRACK,
|
||||
_SC_SYMLOOP_MAX,
|
||||
_SC_STREAMS,
|
||||
_SC_2_PBS_CHECKPOINT,
|
||||
|
||||
_SC_V6_ILP32_OFF32,
|
||||
_SC_V6_ILP32_OFFBIG,
|
||||
_SC_V6_LP64_OFF64,
|
||||
_SC_V6_LPBIG_OFFBIG,
|
||||
|
||||
_SC_HOST_NAME_MAX,
|
||||
_SC_TRACE,
|
||||
_SC_TRACE_EVENT_FILTER,
|
||||
_SC_TRACE_INHERIT,
|
||||
_SC_TRACE_LOG,
|
||||
|
||||
_SC_LEVEL1_ICACHE_SIZE,
|
||||
_SC_LEVEL1_ICACHE_ASSOC,
|
||||
_SC_LEVEL1_ICACHE_LINESIZE,
|
||||
_SC_LEVEL1_DCACHE_SIZE,
|
||||
_SC_LEVEL1_DCACHE_ASSOC,
|
||||
_SC_LEVEL1_DCACHE_LINESIZE,
|
||||
_SC_LEVEL2_CACHE_SIZE,
|
||||
_SC_LEVEL2_CACHE_ASSOC,
|
||||
_SC_LEVEL2_CACHE_LINESIZE,
|
||||
_SC_LEVEL3_CACHE_SIZE,
|
||||
_SC_LEVEL3_CACHE_ASSOC,
|
||||
_SC_LEVEL3_CACHE_LINESIZE,
|
||||
_SC_LEVEL4_CACHE_SIZE,
|
||||
_SC_LEVEL4_CACHE_ASSOC,
|
||||
_SC_LEVEL4_CACHE_LINESIZE,
|
||||
|
||||
_SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
|
||||
_SC_RAW_SOCKETS
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
enum F_OK = 0;
|
||||
enum R_OK = 4;
|
||||
enum W_OK = 2;
|
||||
enum X_OK = 1;
|
||||
|
||||
enum F_ULOCK = 0;
|
||||
enum F_LOCK = 1;
|
||||
enum F_TLOCK = 2;
|
||||
enum F_TEST = 3;
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
enum F_OK = 0;
|
||||
enum R_OK = 0x04;
|
||||
enum W_OK = 0x02;
|
||||
enum X_OK = 0x01;
|
||||
|
||||
enum F_ULOCK = 0;
|
||||
enum F_LOCK = 1;
|
||||
enum F_TLOCK = 2;
|
||||
enum F_TEST = 3;
|
||||
}
|
||||
|
||||
//
|
||||
// File Synchronization (FSC)
|
||||
//
|
||||
/*
|
||||
int fsync(int);
|
||||
*/
|
||||
|
||||
//
|
||||
// Synchronized I/O (SIO)
|
||||
//
|
||||
/*
|
||||
int fdatasync(int);
|
||||
*/
|
||||
|
||||
//
|
||||
// XOpen (XSI)
|
||||
//
|
||||
/*
|
||||
char* crypt(in char*, in char*);
|
||||
char* ctermid(char*);
|
||||
void encrypt(char[64], int);
|
||||
int fchdir(int);
|
||||
c_long gethostid();
|
||||
pid_t getpgid(pid_t);
|
||||
pid_t getsid(pid_t);
|
||||
char* getwd(char*); // LEGACY
|
||||
int lchown(in char*, uid_t, gid_t);
|
||||
int lockf(int, int, off_t);
|
||||
int nice(int);
|
||||
ssize_t pread(int, void*, size_t, off_t);
|
||||
ssize_t pwrite(int, in void*, size_t, off_t);
|
||||
pid_t setpgrp();
|
||||
int setregid(gid_t, gid_t);
|
||||
int setreuid(uid_t, uid_t);
|
||||
void swab(in void*, void*, ssize_t);
|
||||
void sync();
|
||||
int truncate(in char*, off_t);
|
||||
useconds_t ualarm(useconds_t, useconds_t);
|
||||
int usleep(useconds_t);
|
||||
pid_t vfork();
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
char* crypt(in char*, in char*);
|
||||
char* ctermid(char*);
|
||||
void encrypt(char[64], int);
|
||||
int fchdir(int);
|
||||
c_long gethostid();
|
||||
pid_t getpgid(pid_t);
|
||||
pid_t getsid(pid_t);
|
||||
char* getwd(char*); // LEGACY
|
||||
int lchown(in char*, uid_t, gid_t);
|
||||
//int lockf(int, int, off_t);
|
||||
int nice(int);
|
||||
//ssize_t pread(int, void*, size_t, off_t);
|
||||
//ssize_t pwrite(int, in void*, size_t, off_t);
|
||||
pid_t setpgrp();
|
||||
int setregid(gid_t, gid_t);
|
||||
int setreuid(uid_t, uid_t);
|
||||
void swab(in void*, void*, ssize_t);
|
||||
void sync();
|
||||
//int truncate(in char*, off_t);
|
||||
useconds_t ualarm(useconds_t, useconds_t);
|
||||
int usleep(useconds_t);
|
||||
pid_t vfork();
|
||||
|
||||
static if( __USE_LARGEFILE64 )
|
||||
{
|
||||
int lockf64(int, int, off_t);
|
||||
alias lockf64 lockf;
|
||||
|
||||
ssize_t pread64(int, void*, size_t, off_t);
|
||||
alias pread64 pread;
|
||||
|
||||
ssize_t pwrite64(int, in void*, size_t, off_t);
|
||||
alias pwrite64 pwrite;
|
||||
|
||||
int truncate64(in char*, off_t);
|
||||
alias truncate64 truncate;
|
||||
}
|
||||
else
|
||||
{
|
||||
int lockf(int, int, off_t);
|
||||
ssize_t pread(int, void*, size_t, off_t);
|
||||
ssize_t pwrite(int, in void*, size_t, off_t);
|
||||
int truncate(in char*, off_t);
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
char* crypt(in char*, in char*);
|
||||
char* ctermid(char*);
|
||||
void encrypt(char[64], int);
|
||||
int fchdir(int);
|
||||
c_long gethostid();
|
||||
pid_t getpgid(pid_t);
|
||||
pid_t getsid(pid_t);
|
||||
char* getwd(char*); // LEGACY
|
||||
int lchown(in char*, uid_t, gid_t);
|
||||
int lockf(int, int, off_t);
|
||||
int nice(int);
|
||||
ssize_t pread(int, void*, size_t, off_t);
|
||||
ssize_t pwrite(int, in void*, size_t, off_t);
|
||||
pid_t setpgrp();
|
||||
int setregid(gid_t, gid_t);
|
||||
int setreuid(uid_t, uid_t);
|
||||
void swab(in void*, void*, ssize_t);
|
||||
void sync();
|
||||
int truncate(in char*, off_t);
|
||||
useconds_t ualarm(useconds_t, useconds_t);
|
||||
int usleep(useconds_t);
|
||||
pid_t vfork();
|
||||
}
|
||||
else version (freebsd)
|
||||
{
|
||||
char* crypt(in char*, in char*);
|
||||
//char* ctermid(char*);
|
||||
void encrypt(char*, int);
|
||||
int fchdir(int);
|
||||
c_long gethostid();
|
||||
int getpgid(pid_t);
|
||||
int getsid(pid_t);
|
||||
char* getwd(char*); // LEGACY
|
||||
int lchown(in char*, uid_t, gid_t);
|
||||
int lockf(int, int, off_t);
|
||||
int nice(int);
|
||||
ssize_t pread(int, void*, size_t, off_t);
|
||||
ssize_t pwrite(int, in void*, size_t, off_t);
|
||||
int setpgrp(pid_t, pid_t);
|
||||
int setregid(gid_t, gid_t);
|
||||
int setreuid(uid_t, uid_t);
|
||||
void swab(in void*, void*, ssize_t);
|
||||
void sync();
|
||||
int truncate(in char*, off_t);
|
||||
useconds_t ualarm(useconds_t, useconds_t);
|
||||
int usleep(useconds_t);
|
||||
pid_t vfork();
|
||||
}
|
||||
63
druntime/import/core/sys/posix/utime.d
Normal file
63
druntime/import/core/sys/posix/utime.d
Normal file
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* D header file for POSIX.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sys.posix.utime;
|
||||
|
||||
private import core.sys.posix.config;
|
||||
public import core.sys.posix.sys.types; // for time_t
|
||||
|
||||
extern (C):
|
||||
|
||||
//
|
||||
// Required
|
||||
//
|
||||
/*
|
||||
struct utimbuf
|
||||
{
|
||||
time_t actime;
|
||||
time_t modtime;
|
||||
}
|
||||
|
||||
int utime(in char*, in utimbuf*);
|
||||
*/
|
||||
|
||||
version( linux )
|
||||
{
|
||||
struct utimbuf
|
||||
{
|
||||
time_t actime;
|
||||
time_t modtime;
|
||||
}
|
||||
|
||||
int utime(in char*, in utimbuf*);
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
struct utimbuf
|
||||
{
|
||||
time_t actime;
|
||||
time_t modtime;
|
||||
}
|
||||
|
||||
int utime(in char*, in utimbuf*);
|
||||
}
|
||||
else version( freebsd )
|
||||
{
|
||||
struct utimbuf
|
||||
{
|
||||
time_t actime;
|
||||
time_t modtime;
|
||||
}
|
||||
|
||||
int utime(in char*, in utimbuf*);
|
||||
}
|
||||
3181
druntime/import/core/sys/windows/windows.d
Normal file
3181
druntime/import/core/sys/windows/windows.d
Normal file
File diff suppressed because it is too large
Load Diff
268
druntime/import/object.di
Normal file
268
druntime/import/object.di
Normal file
@@ -0,0 +1,268 @@
|
||||
/**
|
||||
* Contains all implicitly declared types and variables.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2000 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Sean Kelly
|
||||
*
|
||||
* Copyright Digital Mars 2000 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module object;
|
||||
|
||||
alias typeof(int.sizeof) size_t;
|
||||
alias typeof(cast(void*)0 - cast(void*)0) ptrdiff_t;
|
||||
|
||||
alias size_t hash_t;
|
||||
alias bool equals_t;
|
||||
|
||||
alias immutable(char)[] string;
|
||||
alias immutable(wchar)[] wstring;
|
||||
alias immutable(dchar)[] dstring;
|
||||
|
||||
class Object
|
||||
{
|
||||
string toString();
|
||||
hash_t toHash();
|
||||
int opCmp(Object o);
|
||||
equals_t opEquals(Object o);
|
||||
|
||||
interface Monitor
|
||||
{
|
||||
void lock();
|
||||
void unlock();
|
||||
}
|
||||
|
||||
static Object factory(string classname);
|
||||
}
|
||||
|
||||
struct Interface
|
||||
{
|
||||
ClassInfo classinfo;
|
||||
void*[] vtbl;
|
||||
ptrdiff_t offset; // offset to Interface 'this' from Object 'this'
|
||||
}
|
||||
|
||||
class ClassInfo : Object
|
||||
{
|
||||
byte[] init; // class static initializer
|
||||
string name; // class name
|
||||
void*[] vtbl; // virtual function pointer table
|
||||
Interface[] interfaces;
|
||||
ClassInfo base;
|
||||
void* destructor;
|
||||
void(*classInvariant)(Object);
|
||||
uint flags;
|
||||
// 1: // is IUnknown or is derived from IUnknown
|
||||
// 2: // has no possible pointers into GC memory
|
||||
// 4: // has offTi[] member
|
||||
// 8: // has constructors
|
||||
// 16: // has xgetMembers member
|
||||
// 32: // has typeinfo member
|
||||
void* deallocator;
|
||||
OffsetTypeInfo[] offTi;
|
||||
void* defaultConstructor;
|
||||
const(MemberInfo[]) function(string) xgetMembers;
|
||||
TypeInfo typeinfo;
|
||||
|
||||
static ClassInfo find(in char[] classname);
|
||||
Object create();
|
||||
const(MemberInfo[]) getMembers(in char[] classname);
|
||||
}
|
||||
|
||||
struct OffsetTypeInfo
|
||||
{
|
||||
size_t offset;
|
||||
TypeInfo ti;
|
||||
}
|
||||
|
||||
class TypeInfo
|
||||
{
|
||||
hash_t getHash(in void* p);
|
||||
equals_t equals(in void* p1, in void* p2);
|
||||
int compare(in void* p1, in void* p2);
|
||||
size_t tsize();
|
||||
void swap(void* p1, void* p2);
|
||||
TypeInfo next();
|
||||
void[] init();
|
||||
uint flags();
|
||||
// 1: // has possible pointers into GC memory
|
||||
OffsetTypeInfo[] offTi();
|
||||
void destroy(void* p);
|
||||
void postblit(void* p);
|
||||
}
|
||||
|
||||
class TypeInfo_Typedef : TypeInfo
|
||||
{
|
||||
TypeInfo base;
|
||||
string name;
|
||||
void[] m_init;
|
||||
}
|
||||
|
||||
class TypeInfo_Enum : TypeInfo_Typedef
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
class TypeInfo_Pointer : TypeInfo
|
||||
{
|
||||
TypeInfo m_next;
|
||||
}
|
||||
|
||||
class TypeInfo_Array : TypeInfo
|
||||
{
|
||||
TypeInfo value;
|
||||
}
|
||||
|
||||
class TypeInfo_StaticArray : TypeInfo
|
||||
{
|
||||
TypeInfo value;
|
||||
size_t len;
|
||||
}
|
||||
|
||||
class TypeInfo_AssociativeArray : TypeInfo
|
||||
{
|
||||
TypeInfo value;
|
||||
TypeInfo key;
|
||||
}
|
||||
|
||||
class TypeInfo_Function : TypeInfo
|
||||
{
|
||||
TypeInfo next;
|
||||
}
|
||||
|
||||
class TypeInfo_Delegate : TypeInfo
|
||||
{
|
||||
TypeInfo next;
|
||||
}
|
||||
|
||||
class TypeInfo_Class : TypeInfo
|
||||
{
|
||||
ClassInfo info;
|
||||
}
|
||||
|
||||
class TypeInfo_Interface : TypeInfo
|
||||
{
|
||||
ClassInfo info;
|
||||
}
|
||||
|
||||
class TypeInfo_Struct : TypeInfo
|
||||
{
|
||||
string name;
|
||||
void[] m_init;
|
||||
|
||||
uint function(in void*) xtoHash;
|
||||
equals_t function(in void*, in void*) xopEquals;
|
||||
int function(in void*, in void*) xopCmp;
|
||||
string function(in void*) xtoString;
|
||||
|
||||
uint m_flags;
|
||||
|
||||
const(MemberInfo[]) function(in char[]) xgetMembers;
|
||||
void function(void*) xdtor;
|
||||
void function(void*) xpostblit;
|
||||
}
|
||||
|
||||
class TypeInfo_Tuple : TypeInfo
|
||||
{
|
||||
TypeInfo[] elements;
|
||||
}
|
||||
|
||||
class TypeInfo_Const : TypeInfo
|
||||
{
|
||||
TypeInfo next;
|
||||
}
|
||||
|
||||
class TypeInfo_Invariant : TypeInfo_Const
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
class TypeInfo_Shared : TypeInfo_Const
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
abstract class MemberInfo
|
||||
{
|
||||
string name();
|
||||
}
|
||||
|
||||
class MemberInfo_field : MemberInfo
|
||||
{
|
||||
this(string name, TypeInfo ti, size_t offset);
|
||||
|
||||
override string name();
|
||||
TypeInfo typeInfo();
|
||||
size_t offset();
|
||||
}
|
||||
|
||||
class MemberInfo_function : MemberInfo
|
||||
{
|
||||
enum
|
||||
{
|
||||
Virtual = 1,
|
||||
Member = 2,
|
||||
Static = 4,
|
||||
}
|
||||
|
||||
this(string name, TypeInfo ti, void* fp, uint flags);
|
||||
|
||||
override string name();
|
||||
TypeInfo typeInfo();
|
||||
void* fp();
|
||||
uint flags();
|
||||
}
|
||||
|
||||
class ModuleInfo
|
||||
{
|
||||
string name;
|
||||
ModuleInfo[] importedModules;
|
||||
ClassInfo[] localClasses;
|
||||
uint flags;
|
||||
|
||||
void function() ctor;
|
||||
void function() dtor;
|
||||
void function() unitTest;
|
||||
|
||||
void* xgetMembers;
|
||||
void function() ictor;
|
||||
void*[4] reserved;
|
||||
|
||||
static int opApply(int delegate(inout ModuleInfo));
|
||||
}
|
||||
|
||||
class Throwable : Object
|
||||
{
|
||||
interface TraceInfo
|
||||
{
|
||||
int opApply(int delegate(inout char[]));
|
||||
string toString();
|
||||
}
|
||||
|
||||
string msg;
|
||||
string file;
|
||||
size_t line;
|
||||
TraceInfo info;
|
||||
Throwable next;
|
||||
|
||||
this(string msg, Throwable next = null);
|
||||
this(string msg, string file, size_t line, Throwable next = null);
|
||||
override string toString();
|
||||
}
|
||||
|
||||
|
||||
class Exception : Throwable
|
||||
{
|
||||
this(string msg, Throwable next = null);
|
||||
this(string msg, string file, size_t line, Throwable next = null);
|
||||
}
|
||||
|
||||
|
||||
class Error : Throwable
|
||||
{
|
||||
this(string msg, Throwable next = null);
|
||||
this(string msg, string file, size_t line, Throwable next = null);
|
||||
}
|
||||
32
druntime/import/std/c/stdarg.di
Normal file
32
druntime/import/std/c/stdarg.di
Normal file
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* These functions are built-in intrinsics to the compiler.
|
||||
*
|
||||
* Copyright: Public Domain
|
||||
* License: Public Domain
|
||||
* Authors: David Friedman
|
||||
*/
|
||||
module std.c.stdarg;
|
||||
|
||||
version( GNU )
|
||||
{
|
||||
private import gcc.builtins;
|
||||
alias __builtin_va_list va_list;
|
||||
alias __builtin_va_end va_end;
|
||||
alias __builtin_va_copy va_copy;
|
||||
}
|
||||
|
||||
template va_start(T)
|
||||
{
|
||||
void va_start( out va_list ap, inout T parmn )
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
template va_arg(T)
|
||||
{
|
||||
T va_arg( inout va_list ap )
|
||||
{
|
||||
return T.init;
|
||||
}
|
||||
}
|
||||
176
druntime/import/std/intrinsic.di
Normal file
176
druntime/import/std/intrinsic.di
Normal file
@@ -0,0 +1,176 @@
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* Copyright: Public Domain
|
||||
* License: Public Domain
|
||||
* Authors: Walter Bright
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
pure nothrow 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
|
||||
*/
|
||||
pure nothrow int bsr( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Tests the bit.
|
||||
*/
|
||||
pure nothrow int bt( in uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and complements the bit.
|
||||
*/
|
||||
nothrow int btc( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and resets (sets to 0) the bit.
|
||||
*/
|
||||
nothrow 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>
|
||||
*/
|
||||
nothrow 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.
|
||||
*/
|
||||
pure nothrow uint bswap( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Reads I/O port at port_address.
|
||||
*/
|
||||
nothrow ubyte inp( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
nothrow ushort inpw( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
nothrow uint inpl( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* Writes and returns value to I/O port at port_address.
|
||||
*/
|
||||
nothrow ubyte outp( uint port_address, ubyte value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
nothrow ushort outpw( uint port_address, ushort value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
nothrow uint outpl( uint port_address, uint value );
|
||||
32
druntime/import/std/stdarg.di
Normal file
32
druntime/import/std/stdarg.di
Normal file
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* These functions are built-in intrinsics to the compiler.
|
||||
*
|
||||
* Copyright: Public Domain
|
||||
* License: Public Domain
|
||||
* Authors: David Friedman
|
||||
*/
|
||||
module std.stdarg;
|
||||
|
||||
version( GNU )
|
||||
{
|
||||
private import gcc.builtins;
|
||||
alias __builtin_va_list va_list;
|
||||
alias __builtin_va_end va_end;
|
||||
alias __builtin_va_copy va_copy;
|
||||
}
|
||||
|
||||
template va_start(T)
|
||||
{
|
||||
void va_start( out va_list ap, inout T parmn )
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
template va_arg(T)
|
||||
{
|
||||
T va_arg( inout va_list ap )
|
||||
{
|
||||
return T.init;
|
||||
}
|
||||
}
|
||||
5
druntime/src/build-dmd.bat
Normal file
5
druntime/src/build-dmd.bat
Normal file
@@ -0,0 +1,5 @@
|
||||
@echo off
|
||||
set OLDHOME=%HOME%
|
||||
set HOME=%CD%
|
||||
make clean all -fdmd-win32.mak
|
||||
set HOME=%OLDHOME%
|
||||
19
druntime/src/build-dmd.sh
Normal file
19
druntime/src/build-dmd.sh
Normal file
@@ -0,0 +1,19 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
OLDHOME=$HOME
|
||||
export HOME=`pwd`
|
||||
|
||||
goerror(){
|
||||
export HOME=$OLDHOME
|
||||
echo "="
|
||||
echo "= *** Error ***"
|
||||
echo "="
|
||||
exit 1
|
||||
}
|
||||
|
||||
make clean -fdmd-posix.mak || goerror
|
||||
make -fdmd-posix.mak || goerror
|
||||
chmod 644 ../import/core/*.di || goerror
|
||||
chmod 644 ../import/core/sync/*.di || goerror
|
||||
|
||||
export HOME=$OLDHOME
|
||||
19
druntime/src/build-ldc.sh
Executable file
19
druntime/src/build-ldc.sh
Executable file
@@ -0,0 +1,19 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
OLDHOME=$HOME
|
||||
export HOME=`pwd`
|
||||
|
||||
goerror(){
|
||||
export HOME=$OLDHOME
|
||||
echo "="
|
||||
echo "= *** Error ***"
|
||||
echo "="
|
||||
exit 1
|
||||
}
|
||||
|
||||
make clean -fldc-posix.mak || goerror
|
||||
make -fldc-posix.mak || goerror
|
||||
chmod 644 ../import/core/*.di || goerror
|
||||
chmod 644 ../import/core/sync/*.di || goerror
|
||||
|
||||
export HOME=$OLDHOME
|
||||
286
druntime/src/common/core/bitmanip.d
Normal file
286
druntime/src/common/core/bitmanip.d
Normal file
@@ -0,0 +1,286 @@
|
||||
/**
|
||||
* This module contains a collection of bit-level operations.
|
||||
*
|
||||
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
|
||||
* License: BSD Style, see LICENSE
|
||||
* Authors: Walter Bright, Don Clugston, Sean Kelly
|
||||
*/
|
||||
module core.bitmanip;
|
||||
|
||||
|
||||
version( DDoc )
|
||||
{
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
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 core.bitmanip;
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
int bsr( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Tests the bit.
|
||||
*/
|
||||
int bt( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and complements the bit.
|
||||
*/
|
||||
int btc( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and resets (sets to 0) the bit.
|
||||
*/
|
||||
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 core.bitmanip;
|
||||
|
||||
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>
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
uint bswap( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Reads I/O port at port_address.
|
||||
*/
|
||||
ubyte inp( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort inpw( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint inpl( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* Writes and returns value to I/O port at port_address.
|
||||
*/
|
||||
ubyte outp( uint port_address, ubyte value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort outpw( uint port_address, ushort value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint outpl( uint port_address, uint value );
|
||||
}
|
||||
else
|
||||
{
|
||||
public import std.intrinsic;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the number of set bits in a 32-bit integer.
|
||||
*/
|
||||
int popcnt( uint x )
|
||||
{
|
||||
// Avoid branches, and the potential for cache misses which
|
||||
// could be incurred with a table lookup.
|
||||
|
||||
// We need to mask alternate bits to prevent the
|
||||
// sum from overflowing.
|
||||
// add neighbouring bits. Each bit is 0 or 1.
|
||||
x = x - ((x>>1) & 0x5555_5555);
|
||||
// now each two bits of x is a number 00,01 or 10.
|
||||
// now add neighbouring pairs
|
||||
x = ((x&0xCCCC_CCCC)>>2) + (x&0x3333_3333);
|
||||
// now each nibble holds 0000-0100. Adding them won't
|
||||
// overflow any more, so we don't need to mask any more
|
||||
|
||||
// Now add the nibbles, then the bytes, then the words
|
||||
// We still need to mask to prevent double-counting.
|
||||
// Note that if we used a rotate instead of a shift, we
|
||||
// wouldn't need the masks, and could just divide the sum
|
||||
// by 8 to account for the double-counting.
|
||||
// On some CPUs, it may be faster to perform a multiply.
|
||||
|
||||
x += (x>>4);
|
||||
x &= 0x0F0F_0F0F;
|
||||
x += (x>>8);
|
||||
x &= 0x00FF_00FF;
|
||||
x += (x>>16);
|
||||
x &= 0xFFFF;
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
debug( UnitTest )
|
||||
{
|
||||
unittest
|
||||
{
|
||||
assert( popcnt( 0 ) == 0 );
|
||||
assert( popcnt( 7 ) == 3 );
|
||||
assert( popcnt( 0xAA )== 4 );
|
||||
assert( popcnt( 0x8421_1248 ) == 8 );
|
||||
assert( popcnt( 0xFFFF_FFFF ) == 32 );
|
||||
assert( popcnt( 0xCCCC_CCCC ) == 16 );
|
||||
assert( popcnt( 0x7777_7777 ) == 24 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reverses the order of bits in a 32-bit integer.
|
||||
*/
|
||||
uint bitswap( uint x )
|
||||
{
|
||||
|
||||
version( D_InlineAsm_X86 )
|
||||
{
|
||||
asm
|
||||
{
|
||||
// Author: Tiago Gasiba.
|
||||
mov EDX, EAX;
|
||||
shr EAX, 1;
|
||||
and EDX, 0x5555_5555;
|
||||
and EAX, 0x5555_5555;
|
||||
shl EDX, 1;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 2;
|
||||
and EDX, 0x3333_3333;
|
||||
and EAX, 0x3333_3333;
|
||||
shl EDX, 2;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 4;
|
||||
and EDX, 0x0f0f_0f0f;
|
||||
and EAX, 0x0f0f_0f0f;
|
||||
shl EDX, 4;
|
||||
or EAX, EDX;
|
||||
bswap EAX;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// swap odd and even bits
|
||||
x = ((x >> 1) & 0x5555_5555) | ((x & 0x5555_5555) << 1);
|
||||
// swap consecutive pairs
|
||||
x = ((x >> 2) & 0x3333_3333) | ((x & 0x3333_3333) << 2);
|
||||
// swap nibbles
|
||||
x = ((x >> 4) & 0x0F0F_0F0F) | ((x & 0x0F0F_0F0F) << 4);
|
||||
// swap bytes
|
||||
x = ((x >> 8) & 0x00FF_00FF) | ((x & 0x00FF_00FF) << 8);
|
||||
// swap 2-byte long pairs
|
||||
x = ( x >> 16 ) | ( x << 16);
|
||||
return x;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
debug( UnitTest )
|
||||
{
|
||||
unittest
|
||||
{
|
||||
assert( bitswap( 0x8000_0100 ) == 0x0080_0001 );
|
||||
}
|
||||
}
|
||||
290
druntime/src/common/core/bitop.d
Normal file
290
druntime/src/common/core/bitop.d
Normal file
@@ -0,0 +1,290 @@
|
||||
/**
|
||||
* This module contains a collection of bit-level operations.
|
||||
*
|
||||
* Copyright: Copyright Don Clugston 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Don Clugston, Sean Kelly, Walter Bright
|
||||
*
|
||||
* Copyright Don Clugston 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.bitop;
|
||||
|
||||
|
||||
version( D_Ddoc )
|
||||
{
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
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 core.bitop;
|
||||
*
|
||||
* 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
|
||||
*/
|
||||
int bsr( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Tests the bit.
|
||||
*/
|
||||
int bt( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and complements the bit.
|
||||
*/
|
||||
int btc( uint* p, uint bitnum );
|
||||
|
||||
|
||||
/**
|
||||
* Tests and resets (sets to 0) the bit.
|
||||
*/
|
||||
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 core.bitop;
|
||||
|
||||
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>
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
uint bswap( uint v );
|
||||
|
||||
|
||||
/**
|
||||
* Reads I/O port at port_address.
|
||||
*/
|
||||
ubyte inp( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort inpw( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint inpl( uint port_address );
|
||||
|
||||
|
||||
/**
|
||||
* Writes and returns value to I/O port at port_address.
|
||||
*/
|
||||
ubyte outp( uint port_address, ubyte value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
ushort outpw( uint port_address, ushort value );
|
||||
|
||||
|
||||
/**
|
||||
* ditto
|
||||
*/
|
||||
uint outpl( uint port_address, uint value );
|
||||
}
|
||||
else
|
||||
{
|
||||
public import std.intrinsic;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Calculates the number of set bits in a 32-bit integer.
|
||||
*/
|
||||
int popcnt( uint x )
|
||||
{
|
||||
// Avoid branches, and the potential for cache misses which
|
||||
// could be incurred with a table lookup.
|
||||
|
||||
// We need to mask alternate bits to prevent the
|
||||
// sum from overflowing.
|
||||
// add neighbouring bits. Each bit is 0 or 1.
|
||||
x = x - ((x>>1) & 0x5555_5555);
|
||||
// now each two bits of x is a number 00,01 or 10.
|
||||
// now add neighbouring pairs
|
||||
x = ((x&0xCCCC_CCCC)>>2) + (x&0x3333_3333);
|
||||
// now each nibble holds 0000-0100. Adding them won't
|
||||
// overflow any more, so we don't need to mask any more
|
||||
|
||||
// Now add the nibbles, then the bytes, then the words
|
||||
// We still need to mask to prevent double-counting.
|
||||
// Note that if we used a rotate instead of a shift, we
|
||||
// wouldn't need the masks, and could just divide the sum
|
||||
// by 8 to account for the double-counting.
|
||||
// On some CPUs, it may be faster to perform a multiply.
|
||||
|
||||
x += (x>>4);
|
||||
x &= 0x0F0F_0F0F;
|
||||
x += (x>>8);
|
||||
x &= 0x00FF_00FF;
|
||||
x += (x>>16);
|
||||
x &= 0xFFFF;
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
debug( UnitTest )
|
||||
{
|
||||
unittest
|
||||
{
|
||||
assert( popcnt( 0 ) == 0 );
|
||||
assert( popcnt( 7 ) == 3 );
|
||||
assert( popcnt( 0xAA )== 4 );
|
||||
assert( popcnt( 0x8421_1248 ) == 8 );
|
||||
assert( popcnt( 0xFFFF_FFFF ) == 32 );
|
||||
assert( popcnt( 0xCCCC_CCCC ) == 16 );
|
||||
assert( popcnt( 0x7777_7777 ) == 24 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reverses the order of bits in a 32-bit integer.
|
||||
*/
|
||||
uint bitswap( uint x )
|
||||
{
|
||||
|
||||
version( D_InlineAsm_X86 )
|
||||
{
|
||||
asm
|
||||
{
|
||||
// Author: Tiago Gasiba.
|
||||
mov EDX, EAX;
|
||||
shr EAX, 1;
|
||||
and EDX, 0x5555_5555;
|
||||
and EAX, 0x5555_5555;
|
||||
shl EDX, 1;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 2;
|
||||
and EDX, 0x3333_3333;
|
||||
and EAX, 0x3333_3333;
|
||||
shl EDX, 2;
|
||||
or EAX, EDX;
|
||||
mov EDX, EAX;
|
||||
shr EAX, 4;
|
||||
and EDX, 0x0f0f_0f0f;
|
||||
and EAX, 0x0f0f_0f0f;
|
||||
shl EDX, 4;
|
||||
or EAX, EDX;
|
||||
bswap EAX;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// swap odd and even bits
|
||||
x = ((x >> 1) & 0x5555_5555) | ((x & 0x5555_5555) << 1);
|
||||
// swap consecutive pairs
|
||||
x = ((x >> 2) & 0x3333_3333) | ((x & 0x3333_3333) << 2);
|
||||
// swap nibbles
|
||||
x = ((x >> 4) & 0x0F0F_0F0F) | ((x & 0x0F0F_0F0F) << 4);
|
||||
// swap bytes
|
||||
x = ((x >> 8) & 0x00FF_00FF) | ((x & 0x00FF_00FF) << 8);
|
||||
// swap 2-byte long pairs
|
||||
x = ( x >> 16 ) | ( x << 16);
|
||||
return x;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
debug( UnitTest )
|
||||
{
|
||||
unittest
|
||||
{
|
||||
assert( bitswap( 0x8000_0100 ) == 0x0080_0001 );
|
||||
}
|
||||
}
|
||||
279
druntime/src/common/core/exception.d
Normal file
279
druntime/src/common/core/exception.d
Normal file
@@ -0,0 +1,279 @@
|
||||
/**
|
||||
* The exception module defines all system-level exceptions and provides a
|
||||
* mechanism to alter system-level error handling.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.exception;
|
||||
|
||||
|
||||
private
|
||||
{
|
||||
alias void function( string file, size_t line, string msg = null ) assertHandlerType;
|
||||
|
||||
// Note that this is set on a per-thread basis (should it be global?)
|
||||
assertHandlerType assertHandler = null;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on a range error.
|
||||
*/
|
||||
class RangeError : Error
|
||||
{
|
||||
this( string file, size_t line )
|
||||
{
|
||||
super( "Range violation", file, line );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on an assert error.
|
||||
*/
|
||||
class AssertError : Error
|
||||
{
|
||||
this( string file, size_t line )
|
||||
{
|
||||
super( "Assertion failure", file, line );
|
||||
}
|
||||
|
||||
this( string msg, string file, size_t line )
|
||||
{
|
||||
super( msg, file, line );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on finalize error.
|
||||
*/
|
||||
class FinalizeError : Error
|
||||
{
|
||||
ClassInfo info;
|
||||
|
||||
this( ClassInfo c, Exception e = null )
|
||||
{
|
||||
super( "Finalization error", e );
|
||||
info = c;
|
||||
}
|
||||
|
||||
override string toString()
|
||||
{
|
||||
return "An exception was thrown while finalizing an instance of class " ~ info.name;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on hidden function error.
|
||||
*/
|
||||
class HiddenFuncError : Error
|
||||
{
|
||||
this( ClassInfo ci )
|
||||
{
|
||||
super( "Hidden method called for " ~ ci.name );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on an out of memory error.
|
||||
*/
|
||||
class OutOfMemoryError : Error
|
||||
{
|
||||
this( string file, size_t line )
|
||||
{
|
||||
super( "Memory allocation failed", file, line );
|
||||
}
|
||||
|
||||
override string toString()
|
||||
{
|
||||
return msg ? super.toString() : "Memory allocation failed";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on a switch error.
|
||||
*/
|
||||
class SwitchError : Error
|
||||
{
|
||||
this( string file, size_t line )
|
||||
{
|
||||
super( "No appropriate switch clause found", file, line );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Thrown on a unicode conversion error.
|
||||
*/
|
||||
class UnicodeException : Exception
|
||||
{
|
||||
size_t idx;
|
||||
|
||||
this( string msg, size_t idx )
|
||||
{
|
||||
super( msg );
|
||||
this.idx = idx;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Overrides
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Overrides the default assert hander with a user-supplied version.
|
||||
*
|
||||
* Params:
|
||||
* h = The new assert handler. Set to null to use the default handler.
|
||||
*/
|
||||
void setAssertHandler( assertHandlerType h )
|
||||
{
|
||||
assertHandler = h;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Overridable Callbacks
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A callback for assert errors in D. The user-supplied assert handler will
|
||||
* be called if one has been supplied, otherwise an AssertError will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* file = The name of the file that signaled this error.
|
||||
* line = The line number on which this error occurred.
|
||||
*/
|
||||
extern (C) void onAssertError( string file, size_t line )
|
||||
{
|
||||
if( assertHandler is null )
|
||||
throw new AssertError( file, line );
|
||||
assertHandler( file, line );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for assert errors in D. The user-supplied assert handler will
|
||||
* be called if one has been supplied, otherwise an AssertError will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* file = The name of the file that signaled this error.
|
||||
* line = The line number on which this error occurred.
|
||||
* msg = An error message supplied by the user.
|
||||
*/
|
||||
extern (C) void onAssertErrorMsg( string file, size_t line, string msg )
|
||||
{
|
||||
if( assertHandler is null )
|
||||
throw new AssertError( msg, file, line );
|
||||
assertHandler( file, line, msg );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Internal Error Callbacks
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A callback for array bounds errors in D. A RangeError will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* file = The name of the file that signaled this error.
|
||||
* line = The line number on which this error occurred.
|
||||
*
|
||||
* Throws:
|
||||
* RangeError.
|
||||
*/
|
||||
extern (C) void onRangeError( string file, size_t line )
|
||||
{
|
||||
throw new RangeError( file, line );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for finalize errors in D. A FinalizeError will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* e = The exception thrown during finalization.
|
||||
*
|
||||
* Throws:
|
||||
* FinalizeError.
|
||||
*/
|
||||
extern (C) void onFinalizeError( ClassInfo info, Exception ex )
|
||||
{
|
||||
throw new FinalizeError( info, ex );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for hidden function errors in D. A HiddenFuncError will be
|
||||
* thrown.
|
||||
*
|
||||
* Throws:
|
||||
* HiddenFuncError.
|
||||
*/
|
||||
extern (C) void onHiddenFuncError( Object o )
|
||||
{
|
||||
throw new HiddenFuncError( o.classinfo );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for out of memory errors in D. An OutOfMemoryError will be
|
||||
* thrown.
|
||||
*
|
||||
* Throws:
|
||||
* OutOfMemoryError.
|
||||
*/
|
||||
extern (C) void onOutOfMemoryError()
|
||||
{
|
||||
// NOTE: Since an out of memory condition exists, no allocation must occur
|
||||
// while generating this object.
|
||||
throw cast(OutOfMemoryError) cast(void*) OutOfMemoryError.classinfo.init;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for switch errors in D. A SwitchError will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* file = The name of the file that signaled this error.
|
||||
* line = The line number on which this error occurred.
|
||||
*
|
||||
* Throws:
|
||||
* SwitchError.
|
||||
*/
|
||||
extern (C) void onSwitchError( string file, size_t line )
|
||||
{
|
||||
throw new SwitchError( file, line );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A callback for unicode errors in D. A UnicodeException will be thrown.
|
||||
*
|
||||
* Params:
|
||||
* msg = Information about the error.
|
||||
* idx = String index where this error was detected.
|
||||
*
|
||||
* Throws:
|
||||
* UnicodeException.
|
||||
*/
|
||||
extern (C) void onUnicodeError( string msg, size_t idx )
|
||||
{
|
||||
throw new UnicodeException( msg, idx );
|
||||
}
|
||||
452
druntime/src/common/core/memory.d
Normal file
452
druntime/src/common/core/memory.d
Normal file
@@ -0,0 +1,452 @@
|
||||
/**
|
||||
* The memory module provides an interface to the garbage collector and to
|
||||
* any other OS or API-level memory management facilities.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.memory;
|
||||
|
||||
|
||||
private
|
||||
{
|
||||
extern (C) void gc_init();
|
||||
extern (C) void gc_term();
|
||||
|
||||
extern (C) void gc_enable();
|
||||
extern (C) void gc_disable();
|
||||
extern (C) void gc_collect();
|
||||
extern (C) void gc_minimize();
|
||||
|
||||
extern (C) uint gc_getAttr( void* p );
|
||||
extern (C) uint gc_setAttr( void* p, uint a );
|
||||
extern (C) uint gc_clrAttr( void* p, uint a );
|
||||
|
||||
extern (C) void* gc_malloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void* gc_calloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void* gc_realloc( void* p, size_t sz, uint ba = 0 );
|
||||
extern (C) size_t gc_extend( void* p, size_t mx, size_t sz );
|
||||
extern (C) size_t gc_reserve( size_t sz );
|
||||
extern (C) void gc_free( void* p );
|
||||
|
||||
extern (C) void* gc_addrOf( void* p );
|
||||
extern (C) size_t gc_sizeOf( void* p );
|
||||
|
||||
struct BlkInfo_
|
||||
{
|
||||
void* base;
|
||||
size_t size;
|
||||
uint attr;
|
||||
}
|
||||
|
||||
extern (C) BlkInfo_ gc_query( void* p );
|
||||
|
||||
extern (C) void gc_addRoot( void* p );
|
||||
extern (C) void gc_addRange( void* p, size_t sz );
|
||||
|
||||
extern (C) void gc_removeRoot( void* p );
|
||||
extern (C) void gc_removeRange( void* p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* This struct encapsulates all garbage collection functionality for the D
|
||||
* programming language.
|
||||
*/
|
||||
struct GC
|
||||
{
|
||||
/**
|
||||
* Enables automatic garbage collection behavior if collections have
|
||||
* previously been suspended by a call to disable. This function is
|
||||
* reentrant, and must be called once for every call to disable before
|
||||
* automatic collections are enabled.
|
||||
*/
|
||||
static void enable()
|
||||
{
|
||||
gc_enable();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Disables automatic garbage collections performed to minimize the
|
||||
* process footprint. Collections may continue to occur in instances
|
||||
* where the implementation deems necessary for correct program behavior,
|
||||
* such as during an out of memory condition. This function is reentrant,
|
||||
* but enable must be called once for each call to disable.
|
||||
*/
|
||||
static void disable()
|
||||
{
|
||||
gc_disable();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Begins a full collection. While the meaning of this may change based
|
||||
* on the garbage collector implementation, typical behavior is to scan
|
||||
* all stack segments for roots, mark accessible memory blocks as alive,
|
||||
* and then to reclaim free space. This action may need to suspend all
|
||||
* running threads for at least part of the collection process.
|
||||
*/
|
||||
static void collect()
|
||||
{
|
||||
gc_collect();
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicates that the managed memory space be minimized by returning free
|
||||
* physical memory to the operating system. The amount of free memory
|
||||
* returned depends on the allocator design and on program behavior.
|
||||
*/
|
||||
static void minimize()
|
||||
{
|
||||
gc_minimize();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Elements for a bit field representing memory block attributes. These
|
||||
* are manipulated via the getAttr, setAttr, clrAttr functions.
|
||||
*/
|
||||
enum BlkAttr : uint
|
||||
{
|
||||
FINALIZE = 0b0000_0001, /// Finalize the data in this block on collect.
|
||||
NO_SCAN = 0b0000_0010, /// Do not scan through this block on collect.
|
||||
NO_MOVE = 0b0000_0100 /// Do not move this memory block on collect.
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Contains aggregate information about a block of managed memory. The
|
||||
* purpose of this struct is to support a more efficient query style in
|
||||
* instances where detailed information is needed.
|
||||
*
|
||||
* base = A pointer to the base of the block in question.
|
||||
* size = The size of the block, calculated from base.
|
||||
* attr = Attribute bits set on the memory block.
|
||||
*/
|
||||
alias BlkInfo_ BlkInfo;
|
||||
|
||||
|
||||
/**
|
||||
* Returns a bit field representing all block attributes set for the memory
|
||||
* referenced by p. If p references memory not originally allocated by
|
||||
* this garbage collector, points to the interior of a memory block, or if
|
||||
* p is null, zero will be returned.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
*
|
||||
* Returns:
|
||||
* A bit field containing any bits set for the memory block referenced by
|
||||
* p or zero on error.
|
||||
*/
|
||||
static uint getAttr( void* p )
|
||||
{
|
||||
return gc_getAttr( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the specified bits for the memory references by p. If p references
|
||||
* memory not originally allocated by this garbage collector, points to the
|
||||
* interior of a memory block, or if p is null, no action will be
|
||||
* performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
* a = A bit field containing any bits to set for this memory block.
|
||||
*
|
||||
* The result of a call to getAttr after the specified bits have been
|
||||
* set.
|
||||
*/
|
||||
static uint setAttr( void* p, uint a )
|
||||
{
|
||||
return gc_setAttr( p, a );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Clears the specified bits for the memory references by p. If p
|
||||
* references memory not originally allocated by this garbage collector,
|
||||
* points to the interior of a memory block, or if p is null, no action
|
||||
* will be performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
* a = A bit field containing any bits to clear for this memory block.
|
||||
*
|
||||
* Returns:
|
||||
* The result of a call to getAttr after the specified bits have been
|
||||
* cleared.
|
||||
*/
|
||||
static uint clrAttr( void* p, uint a )
|
||||
{
|
||||
return gc_clrAttr( p, a );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Requests an aligned block of managed memory from the garbage collector.
|
||||
* This memory may be deleted at will with a call to free, or it may be
|
||||
* discarded and cleaned up automatically during a collection run. If
|
||||
* allocation fails, this function will call onOutOfMemory which is
|
||||
* expected to throw an OutOfMemoryException.
|
||||
*
|
||||
* Params:
|
||||
* sz = The desired allocation size in bytes.
|
||||
* ba = A bitmask of the attributes to set on this block.
|
||||
*
|
||||
* Returns:
|
||||
* A reference to the allocated memory or null if insufficient memory
|
||||
* is available.
|
||||
*
|
||||
* Throws:
|
||||
* OutOfMemoryException on allocation failure.
|
||||
*/
|
||||
static void* malloc( size_t sz, uint ba = 0 )
|
||||
{
|
||||
return gc_malloc( sz, ba );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Requests an aligned block of managed memory from the garbage collector,
|
||||
* which is initialized with all bits set to zero. This memory may be
|
||||
* deleted at will with a call to free, or it may be discarded and cleaned
|
||||
* up automatically during a collection run. If allocation fails, this
|
||||
* function will call onOutOfMemory which is expected to throw an
|
||||
* OutOfMemoryException.
|
||||
*
|
||||
* Params:
|
||||
* sz = The desired allocation size in bytes.
|
||||
* ba = A bitmask of the attributes to set on this block.
|
||||
*
|
||||
* Returns:
|
||||
* A reference to the allocated memory or null if insufficient memory
|
||||
* is available.
|
||||
*
|
||||
* Throws:
|
||||
* OutOfMemoryException on allocation failure.
|
||||
*/
|
||||
static void* calloc( size_t sz, uint ba = 0 )
|
||||
{
|
||||
return gc_calloc( sz, ba );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* If sz is zero, the memory referenced by p will be deallocated as if
|
||||
* by a call to free. A new memory block of size sz will then be
|
||||
* allocated as if by a call to malloc, or the implementation may instead
|
||||
* resize the memory block in place. The contents of the new memory block
|
||||
* will be the same as the contents of the old memory block, up to the
|
||||
* lesser of the new and old sizes. Note that existing memory will only
|
||||
* be freed by realloc if sz is equal to zero. The garbage collector is
|
||||
* otherwise expected to later reclaim the memory block if it is unused.
|
||||
* If allocation fails, this function will call onOutOfMemory which is
|
||||
* expected to throw an OutOfMemoryException. If p references memory not
|
||||
* originally allocated by this garbage collector, or if it points to the
|
||||
* interior of a memory block, no action will be taken. If ba is zero
|
||||
* (the default) and p references the head of a valid, known memory block
|
||||
* then any bits set on the current block will be set on the new block if a
|
||||
* reallocation is required. If ba is not zero and p references the head
|
||||
* of a valid, known memory block then the bits in ba will replace those on
|
||||
* the current memory block and will also be set on the new block if a
|
||||
* reallocation is required.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
* sz = The desired allocation size in bytes.
|
||||
* ba = A bitmask of the attributes to set on this block.
|
||||
*
|
||||
* Returns:
|
||||
* A reference to the allocated memory on success or null if sz is
|
||||
* zero. On failure, the original value of p is returned.
|
||||
*
|
||||
* Throws:
|
||||
* OutOfMemoryException on allocation failure.
|
||||
*/
|
||||
static void* realloc( void* p, size_t sz, uint ba = 0 )
|
||||
{
|
||||
return gc_realloc( p, sz, ba );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Requests that the managed memory block referenced by p be extended in
|
||||
* place by at least mx bytes, with a desired extension of sz bytes. If an
|
||||
* extension of the required size is not possible, if p references memory
|
||||
* not originally allocated by this garbage collector, or if p points to
|
||||
* the interior of a memory block, no action will be taken.
|
||||
*
|
||||
* Params:
|
||||
* mx = The minimum extension size in bytes.
|
||||
* sz = The desired extension size in bytes.
|
||||
*
|
||||
* Returns:
|
||||
* The size in bytes of the extended memory block referenced by p or zero
|
||||
* if no extension occurred.
|
||||
*/
|
||||
static size_t extend( void* p, size_t mx, size_t sz )
|
||||
{
|
||||
return gc_extend( p, mx, sz );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Requests that at least sz bytes of memory be obtained from the operating
|
||||
* system and marked as free.
|
||||
*
|
||||
* Params:
|
||||
* sz = The desired size in bytes.
|
||||
*
|
||||
* Returns:
|
||||
* The actual number of bytes reserved or zero on error.
|
||||
*/
|
||||
static size_t reserve( size_t sz )
|
||||
{
|
||||
return gc_reserve( sz );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Deallocates the memory referenced by p. If p is null, no action
|
||||
* occurs. If p references memory not originally allocated by this
|
||||
* garbage collector, or if it points to the interior of a memory block,
|
||||
* no action will be taken. The block will not be finalized regardless
|
||||
* of whether the FINALIZE attribute is set. If finalization is desired,
|
||||
* use delete instead.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
*/
|
||||
static void free( void* p )
|
||||
{
|
||||
gc_free( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the base address of the memory block containing p. This value
|
||||
* is useful to determine whether p is an interior pointer, and the result
|
||||
* may be passed to routines such as sizeOf which may otherwise fail. If p
|
||||
* references memory not originally allocated by this garbage collector, if
|
||||
* p is null, or if the garbage collector does not support this operation,
|
||||
* null will be returned.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root or the interior of a valid memory block or to
|
||||
* null.
|
||||
*
|
||||
* Returns:
|
||||
* The base address of the memory block referenced by p or null on error.
|
||||
*/
|
||||
static void* addrOf( void* p )
|
||||
{
|
||||
return gc_addrOf( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the true size of the memory block referenced by p. This value
|
||||
* represents the maximum number of bytes for which a call to realloc may
|
||||
* resize the existing block in place. If p references memory not
|
||||
* originally allocated by this garbage collector, points to the interior
|
||||
* of a memory block, or if p is null, zero will be returned.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root of a valid memory block or to null.
|
||||
*
|
||||
* Returns:
|
||||
* The size in bytes of the memory block referenced by p or zero on error.
|
||||
*/
|
||||
static size_t sizeOf( void* p )
|
||||
{
|
||||
return gc_sizeOf( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns aggregate information about the memory block containing p. If p
|
||||
* references memory not originally allocated by this garbage collector, if
|
||||
* p is null, or if the garbage collector does not support this operation,
|
||||
* BlkInfo.init will be returned. Typically, support for this operation
|
||||
* is dependent on support for addrOf.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to the root or the interior of a valid memory block or to
|
||||
* null.
|
||||
*
|
||||
* Returns:
|
||||
* Information regarding the memory block referenced by p or BlkInfo.init
|
||||
* on error.
|
||||
*/
|
||||
static BlkInfo query( void* p )
|
||||
{
|
||||
return gc_query( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Adds the memory address referenced by p to an internal list of roots to
|
||||
* be scanned during a collection. If p is null, no operation is
|
||||
* performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to a valid memory address or to null.
|
||||
*/
|
||||
static void addRoot( void* p )
|
||||
{
|
||||
gc_addRoot( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Adds the memory block referenced by p and of size sz to an internal list
|
||||
* of ranges to be scanned during a collection. If p is null, no operation
|
||||
* is performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to a valid memory address or to null.
|
||||
* sz = The size in bytes of the block to add. If sz is zero then the
|
||||
* no operation will occur. If p is null then sz must be zero.
|
||||
*/
|
||||
static void addRange( void* p, size_t sz )
|
||||
{
|
||||
gc_addRange( p, sz );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Removes the memory block referenced by p from an internal list of roots
|
||||
* to be scanned during a collection. If p is null or does not represent
|
||||
* a value previously passed to add(void*) then no operation is performed.
|
||||
*
|
||||
* p = A pointer to a valid memory address or to null.
|
||||
*/
|
||||
static void removeRoot( void* p )
|
||||
{
|
||||
gc_removeRoot( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Removes the memory block referenced by p from an internal list of ranges
|
||||
* to be scanned during a collection. If p is null or does not represent
|
||||
* a value previously passed to add(void*, size_t) then no operation is
|
||||
* performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A pointer to a valid memory address or to null.
|
||||
*/
|
||||
static void removeRange( void* p )
|
||||
{
|
||||
gc_removeRange( p );
|
||||
}
|
||||
}
|
||||
211
druntime/src/common/core/runtime.d
Normal file
211
druntime/src/common/core/runtime.d
Normal file
@@ -0,0 +1,211 @@
|
||||
/**
|
||||
* The runtime module exposes information specific to the D runtime code.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.runtime;
|
||||
|
||||
|
||||
private
|
||||
{
|
||||
extern (C) bool rt_isHalting();
|
||||
|
||||
alias bool function() ModuleUnitTester;
|
||||
alias bool function(Object) CollectHandler;
|
||||
alias Exception.TraceInfo function( void* ptr = null ) TraceHandler;
|
||||
|
||||
extern (C) void rt_setCollectHandler( CollectHandler h );
|
||||
extern (C) void rt_setTraceHandler( TraceHandler h );
|
||||
|
||||
alias void delegate( Throwable ) ExceptionHandler;
|
||||
extern (C) bool rt_init( ExceptionHandler dg = null );
|
||||
extern (C) bool rt_term( ExceptionHandler dg = null );
|
||||
|
||||
extern (C) void* rt_loadLibrary( in char[] name );
|
||||
extern (C) bool rt_unloadLibrary( void* ptr );
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Runtime
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This struct encapsulates all functionality related to the underlying runtime
|
||||
* module for the calling context.
|
||||
*/
|
||||
struct Runtime
|
||||
{
|
||||
/**
|
||||
* Initializes the runtime. This call is to be used in instances where the
|
||||
* standard program initialization process is not executed. This is most
|
||||
* often in shared libraries or in libraries linked to a C program.
|
||||
*
|
||||
* Params:
|
||||
* dg = A delegate which will receive any exception thrown during the
|
||||
* initialization process or null if such exceptions should be
|
||||
* discarded.
|
||||
*
|
||||
* Returns:
|
||||
* true if initialization succeeds and false if initialization fails.
|
||||
*/
|
||||
static bool initialize( ExceptionHandler dg = null )
|
||||
{
|
||||
return rt_init( dg );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Terminates the runtime. This call is to be used in instances where the
|
||||
* standard program termination process will not be not executed. This is
|
||||
* most often in shared libraries or in libraries linked to a C program.
|
||||
*
|
||||
* Params:
|
||||
* dg = A delegate which will receive any exception thrown during the
|
||||
* termination process or null if such exceptions should be
|
||||
* discarded.
|
||||
*
|
||||
* Returns:
|
||||
* true if termination succeeds and false if termination fails.
|
||||
*/
|
||||
static bool terminate( ExceptionHandler dg = null )
|
||||
{
|
||||
return rt_term( dg );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns true if the runtime is halting. Under normal circumstances,
|
||||
* this will be set between the time that normal application code has
|
||||
* exited and before module dtors are called.
|
||||
*
|
||||
* Returns:
|
||||
* true if the runtime is halting.
|
||||
*/
|
||||
static bool isHalting()
|
||||
{
|
||||
return rt_isHalting();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Locates a dynamic library with the supplied library name and dynamically
|
||||
* loads it into the caller's address space. If the library contains a D
|
||||
* runtime it will be integrated with the current runtime.
|
||||
*
|
||||
* Params:
|
||||
* name = The name of the dynamic library to load.
|
||||
*
|
||||
* Returns:
|
||||
* A reference to the library or null on error.
|
||||
*/
|
||||
static void* loadLibrary( in char[] name )
|
||||
{
|
||||
return rt_loadLibrary( name );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Unloads the dynamic library referenced by p. If this library contains a
|
||||
* D runtime then any necessary finalization or cleanup of that runtime
|
||||
* will be performed.
|
||||
*
|
||||
* Params:
|
||||
* p = A reference to the library to unload.
|
||||
*/
|
||||
static bool unloadLibrary( void* p )
|
||||
{
|
||||
return rt_unloadLibrary( p );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Overrides the default trace mechanism with s user-supplied version. A
|
||||
* trace represents the context from which an exception was thrown, and the
|
||||
* trace handler will be called when this occurs. The pointer supplied to
|
||||
* this routine indicates the base address from which tracing should occur.
|
||||
* If the supplied pointer is null then the trace routine should determine
|
||||
* an appropriate calling context from which to begin the trace.
|
||||
*
|
||||
* Params:
|
||||
* h = The new trace handler. Set to null to use the default handler.
|
||||
*/
|
||||
static void traceHandler( TraceHandler h )
|
||||
{
|
||||
rt_setTraceHandler( h );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Overrides the default collect hander with a user-supplied version. This
|
||||
* routine will be called for each resource object that is finalized in a
|
||||
* non-deterministic manner--typically during a garbage collection cycle.
|
||||
* If the supplied routine returns true then the object's dtor will called
|
||||
* as normal, but if the routine returns false than the dtor will not be
|
||||
* called. The default behavior is for all object dtors to be called.
|
||||
*
|
||||
* Params:
|
||||
* h = The new collect handler. Set to null to use the default handler.
|
||||
*/
|
||||
static void collectHandler( CollectHandler h )
|
||||
{
|
||||
rt_setCollectHandler( h );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Overrides the default module unit tester with a user-supplied version.
|
||||
* This routine will be called once on program initialization. The return
|
||||
* value of this routine indicates to the runtime whether the body of the
|
||||
* program will be executed.
|
||||
*
|
||||
* Params:
|
||||
* h = The new unit tester. Set to null to use the default unit tester.
|
||||
*/
|
||||
static void moduleUnitTester( ModuleUnitTester h )
|
||||
{
|
||||
sm_moduleUnitTester = h;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
// Unit tests should only be run in single-threaded
|
||||
__gshared ModuleUnitTester sm_moduleUnitTester = null;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Overridable Callbacks
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This routine is called by the runtime to run module unit tests on startup.
|
||||
* The user-supplied unit tester will be called if one has been supplied,
|
||||
* otherwise all unit tests will be run in sequence.
|
||||
*
|
||||
* Returns:
|
||||
* true if execution should continue after testing is complete and false if
|
||||
* not. Default behavior is to return true.
|
||||
*/
|
||||
extern (C) bool runModuleUnitTests()
|
||||
{
|
||||
if( Runtime.sm_moduleUnitTester is null )
|
||||
{
|
||||
foreach( m; ModuleInfo )
|
||||
{
|
||||
if( m.unitTest )
|
||||
m.unitTest();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return Runtime.sm_moduleUnitTester();
|
||||
}
|
||||
26
druntime/src/common/core/stdc/errno.c
Normal file
26
druntime/src/common/core/stdc/errno.c
Normal file
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
* This file contains wrapper functions for macro-defined C rouines.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <errno.h>
|
||||
|
||||
|
||||
int getErrno()
|
||||
{
|
||||
return errno;
|
||||
}
|
||||
|
||||
|
||||
int setErrno( int val )
|
||||
{
|
||||
errno = val;
|
||||
return val;
|
||||
}
|
||||
153
druntime/src/common/core/sync/barrier.d
Normal file
153
druntime/src/common/core/sync/barrier.d
Normal file
@@ -0,0 +1,153 @@
|
||||
/**
|
||||
* The barrier module provides a primitive for synchronizing the progress of
|
||||
* a group of threads.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.barrier;
|
||||
|
||||
|
||||
public import core.sync.exception;
|
||||
private import core.sync.condition;
|
||||
private import core.sync.mutex;
|
||||
|
||||
version( Win32 )
|
||||
{
|
||||
private import core.sys.windows.windows;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
private import core.stdc.errno;
|
||||
private import core.sys.posix.pthread;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Barrier
|
||||
//
|
||||
// void wait();
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class represents a barrier across which threads may only travel in
|
||||
* groups of a specific size.
|
||||
*/
|
||||
class Barrier
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a barrier object which releases threads in groups of limit
|
||||
* in size.
|
||||
*
|
||||
* Params:
|
||||
* limit = The number of waiting threads to release in unison.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
this( uint limit )
|
||||
in
|
||||
{
|
||||
assert( limit > 0 );
|
||||
}
|
||||
body
|
||||
{
|
||||
m_lock = new Mutex;
|
||||
m_cond = new Condition( m_lock );
|
||||
m_group = 0;
|
||||
m_limit = limit;
|
||||
m_count = limit;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// General Actions
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Wait for the pre-determined number of threads and then proceed.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void wait()
|
||||
{
|
||||
synchronized( m_lock )
|
||||
{
|
||||
uint group = m_group;
|
||||
|
||||
if( --m_count == 0 )
|
||||
{
|
||||
m_group++;
|
||||
m_count = m_limit;
|
||||
m_cond.notifyAll();
|
||||
}
|
||||
while( group == m_group )
|
||||
m_cond.wait();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
Mutex m_lock;
|
||||
Condition m_cond;
|
||||
uint m_group;
|
||||
uint m_limit;
|
||||
uint m_count;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
version( unittest )
|
||||
{
|
||||
private import core.thread;
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
int numThreads = 10;
|
||||
auto barrier = new Barrier( numThreads );
|
||||
auto synInfo = new Object;
|
||||
int numReady = 0;
|
||||
int numPassed = 0;
|
||||
|
||||
void threadFn()
|
||||
{
|
||||
synchronized( synInfo )
|
||||
{
|
||||
++numReady;
|
||||
}
|
||||
barrier.wait();
|
||||
synchronized( synInfo )
|
||||
{
|
||||
++numPassed;
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numThreads; ++i )
|
||||
{
|
||||
group.create( &threadFn );
|
||||
}
|
||||
group.joinAll();
|
||||
assert( numReady == numThreads && numPassed == numThreads );
|
||||
}
|
||||
}
|
||||
573
druntime/src/common/core/sync/condition.d
Normal file
573
druntime/src/common/core/sync/condition.d
Normal file
@@ -0,0 +1,573 @@
|
||||
/**
|
||||
* The condition module provides a primitive for synchronized condition
|
||||
* checking.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.condition;
|
||||
|
||||
|
||||
public import core.sync.exception;
|
||||
public import core.sync.mutex;
|
||||
|
||||
version( Win32 )
|
||||
{
|
||||
private import core.sync.semaphore;
|
||||
private import core.sys.windows.windows;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
private import core.sync.config;
|
||||
private import core.stdc.errno;
|
||||
private import core.sys.posix.pthread;
|
||||
private import core.sys.posix.time;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Condition
|
||||
//
|
||||
// void wait();
|
||||
// void notify();
|
||||
// void notifyAll();
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class represents a condition variable as concieved by C.A.R. Hoare. As
|
||||
* per Mesa type monitors however, "signal" has been replaced with "notify" to
|
||||
* indicate that control is not transferred to the waiter when a notification
|
||||
* is sent.
|
||||
*/
|
||||
class Condition
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a condition object which is associated with the supplied
|
||||
* mutex object.
|
||||
*
|
||||
* Params:
|
||||
* m = The mutex with which this condition will be associated.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
this( Mutex m )
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
m_blockLock = CreateSemaphoreA( null, 1, 1, null );
|
||||
if( m_blockLock == m_blockLock.init )
|
||||
throw new SyncException( "Unable to initialize condition" );
|
||||
scope(failure) CloseHandle( m_blockLock );
|
||||
|
||||
m_blockQueue = CreateSemaphoreA( null, 0, int.max, null );
|
||||
if( m_blockQueue == m_blockQueue.init )
|
||||
throw new SyncException( "Unable to initialize condition" );
|
||||
scope(failure) CloseHandle( m_blockQueue );
|
||||
|
||||
InitializeCriticalSection( &m_unblockLock );
|
||||
m_assocMutex = m;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
m_mutexAddr = m.handleAddr();
|
||||
|
||||
int rc = pthread_cond_init( &m_hndl, null );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to initialize condition" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
~this()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
BOOL rc = CloseHandle( m_blockLock );
|
||||
assert( rc, "Unable to destroy condition" );
|
||||
rc = CloseHandle( m_blockQueue );
|
||||
assert( rc, "Unable to destroy condition" );
|
||||
DeleteCriticalSection( &m_unblockLock );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_cond_destroy( &m_hndl );
|
||||
assert( !rc, "Unable to destroy condition" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// General Actions
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Wait until notified.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void wait()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
timedWait( INFINITE );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_cond_wait( &m_hndl, m_mutexAddr );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to wait for condition" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Suspends the calling thread until a notification occurs or until the
|
||||
* supplied time period has elapsed.
|
||||
*
|
||||
* Params:
|
||||
* period = The time to wait, in 100 nanosecond intervals. This value may
|
||||
* be adjusted to equal to the maximum wait period supported by
|
||||
* the target platform if it is too large.
|
||||
*
|
||||
* In:
|
||||
* period must be non-negative.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*
|
||||
* Returns:
|
||||
* true if notified before the timeout and false if not.
|
||||
*/
|
||||
bool wait( long period )
|
||||
in
|
||||
{
|
||||
assert( period >= 0 );
|
||||
}
|
||||
body
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
enum : uint
|
||||
{
|
||||
TICKS_PER_MILLI = 10_000,
|
||||
MAX_WAIT_MILLIS = uint.max - 1
|
||||
}
|
||||
|
||||
period /= TICKS_PER_MILLI;
|
||||
if( period > MAX_WAIT_MILLIS )
|
||||
period = MAX_WAIT_MILLIS;
|
||||
return timedWait( cast(uint) period );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
timespec t = void;
|
||||
mktspec( t, period );
|
||||
|
||||
int rc = pthread_cond_timedwait( &m_hndl, m_mutexAddr, &t );
|
||||
if( !rc )
|
||||
return true;
|
||||
if( rc == ETIMEDOUT )
|
||||
return false;
|
||||
throw new SyncException( "Unable to wait for condition" );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Notifies one waiter.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void notify()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
notify( false );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_cond_signal( &m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to notify condition" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Notifies all waiters.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void notifyAll()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
notify( true );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_cond_broadcast( &m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to notify condition" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
version( Win32 )
|
||||
{
|
||||
bool timedWait( DWORD timeout )
|
||||
{
|
||||
int numSignalsLeft;
|
||||
int numWaitersGone;
|
||||
DWORD rc;
|
||||
|
||||
rc = WaitForSingleObject( m_blockLock, INFINITE );
|
||||
assert( rc == WAIT_OBJECT_0 );
|
||||
|
||||
m_numWaitersBlocked++;
|
||||
|
||||
rc = ReleaseSemaphore( m_blockLock, 1, null );
|
||||
assert( rc );
|
||||
|
||||
m_assocMutex.unlock();
|
||||
scope(failure) m_assocMutex.lock();
|
||||
|
||||
rc = WaitForSingleObject( m_blockQueue, timeout );
|
||||
assert( rc == WAIT_OBJECT_0 || rc == WAIT_TIMEOUT );
|
||||
bool timedOut = (rc == WAIT_TIMEOUT);
|
||||
|
||||
EnterCriticalSection( &m_unblockLock );
|
||||
scope(failure) LeaveCriticalSection( &m_unblockLock );
|
||||
|
||||
if( (numSignalsLeft = m_numWaitersToUnblock) != 0 )
|
||||
{
|
||||
if ( timedOut )
|
||||
{
|
||||
// timeout (or canceled)
|
||||
if( m_numWaitersBlocked != 0 )
|
||||
{
|
||||
m_numWaitersBlocked--;
|
||||
// do not unblock next waiter below (already unblocked)
|
||||
numSignalsLeft = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// spurious wakeup pending!!
|
||||
m_numWaitersGone = 1;
|
||||
}
|
||||
}
|
||||
if( --m_numWaitersToUnblock == 0 )
|
||||
{
|
||||
if( m_numWaitersBlocked != 0 )
|
||||
{
|
||||
// open the gate
|
||||
rc = ReleaseSemaphore( m_blockLock, 1, null );
|
||||
assert( rc );
|
||||
// do not open the gate below again
|
||||
numSignalsLeft = 0;
|
||||
}
|
||||
else if( (numWaitersGone = m_numWaitersGone) != 0 )
|
||||
{
|
||||
m_numWaitersGone = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if( ++m_numWaitersGone == int.max / 2 )
|
||||
{
|
||||
// timeout/canceled or spurious event :-)
|
||||
rc = WaitForSingleObject( m_blockLock, INFINITE );
|
||||
assert( rc == WAIT_OBJECT_0 );
|
||||
// something is going on here - test of timeouts?
|
||||
m_numWaitersBlocked -= m_numWaitersGone;
|
||||
rc = ReleaseSemaphore( m_blockLock, 1, null );
|
||||
assert( rc == WAIT_OBJECT_0 );
|
||||
m_numWaitersGone = 0;
|
||||
}
|
||||
|
||||
LeaveCriticalSection( &m_unblockLock );
|
||||
|
||||
if( numSignalsLeft == 1 )
|
||||
{
|
||||
// better now than spurious later (same as ResetEvent)
|
||||
for( ; numWaitersGone > 0; --numWaitersGone )
|
||||
{
|
||||
rc = WaitForSingleObject( m_blockQueue, INFINITE );
|
||||
assert( rc == WAIT_OBJECT_0 );
|
||||
}
|
||||
// open the gate
|
||||
rc = ReleaseSemaphore( m_blockLock, 1, null );
|
||||
assert( rc );
|
||||
}
|
||||
else if( numSignalsLeft != 0 )
|
||||
{
|
||||
// unblock next waiter
|
||||
rc = ReleaseSemaphore( m_blockQueue, 1, null );
|
||||
assert( rc );
|
||||
}
|
||||
m_assocMutex.lock();
|
||||
return !timedOut;
|
||||
}
|
||||
|
||||
|
||||
void notify( bool all )
|
||||
{
|
||||
DWORD rc;
|
||||
|
||||
EnterCriticalSection( &m_unblockLock );
|
||||
scope(failure) LeaveCriticalSection( &m_unblockLock );
|
||||
|
||||
if( m_numWaitersToUnblock != 0 )
|
||||
{
|
||||
if( m_numWaitersBlocked == 0 )
|
||||
{
|
||||
LeaveCriticalSection( &m_unblockLock );
|
||||
return;
|
||||
}
|
||||
if( all )
|
||||
{
|
||||
m_numWaitersToUnblock += m_numWaitersBlocked;
|
||||
m_numWaitersBlocked = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_numWaitersToUnblock++;
|
||||
m_numWaitersBlocked--;
|
||||
}
|
||||
LeaveCriticalSection( &m_unblockLock );
|
||||
}
|
||||
else if( m_numWaitersBlocked > m_numWaitersGone )
|
||||
{
|
||||
rc = WaitForSingleObject( m_blockLock, INFINITE );
|
||||
assert( rc == WAIT_OBJECT_0 );
|
||||
if( 0 != m_numWaitersGone )
|
||||
{
|
||||
m_numWaitersBlocked -= m_numWaitersGone;
|
||||
m_numWaitersGone = 0;
|
||||
}
|
||||
if( all )
|
||||
{
|
||||
m_numWaitersToUnblock = m_numWaitersBlocked;
|
||||
m_numWaitersBlocked = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_numWaitersToUnblock = 1;
|
||||
m_numWaitersBlocked--;
|
||||
}
|
||||
LeaveCriticalSection( &m_unblockLock );
|
||||
rc = ReleaseSemaphore( m_blockQueue, 1, null );
|
||||
assert( rc );
|
||||
}
|
||||
else
|
||||
{
|
||||
LeaveCriticalSection( &m_unblockLock );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// NOTE: This implementation uses Algorithm 8c as described here:
|
||||
// http://groups.google.com/group/comp.programming.threads/
|
||||
// browse_frm/thread/1692bdec8040ba40/e7a5f9d40e86503a
|
||||
HANDLE m_blockLock; // auto-reset event (now semaphore)
|
||||
HANDLE m_blockQueue; // auto-reset event (now semaphore)
|
||||
Mutex m_assocMutex; // external mutex/CS
|
||||
CRITICAL_SECTION m_unblockLock; // internal mutex/CS
|
||||
int m_numWaitersGone = 0;
|
||||
int m_numWaitersBlocked = 0;
|
||||
int m_numWaitersToUnblock = 0;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
pthread_cond_t m_hndl;
|
||||
pthread_mutex_t* m_mutexAddr;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
version( unittest )
|
||||
{
|
||||
private import core.thread;
|
||||
private import core.sync.mutex;
|
||||
private import core.sync.semaphore;
|
||||
|
||||
|
||||
void testNotify()
|
||||
{
|
||||
auto mutex = new Mutex;
|
||||
auto condReady = new Condition( mutex );
|
||||
auto semDone = new Semaphore;
|
||||
auto synLoop = new Object;
|
||||
int numWaiters = 10;
|
||||
int numTries = 10;
|
||||
int numReady = 0;
|
||||
int numTotal = 0;
|
||||
int numDone = 0;
|
||||
int numPost = 0;
|
||||
|
||||
void waiter()
|
||||
{
|
||||
for( int i = 0; i < numTries; ++i )
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
while( numReady < 1 )
|
||||
{
|
||||
condReady.wait();
|
||||
}
|
||||
--numReady;
|
||||
++numTotal;
|
||||
}
|
||||
|
||||
synchronized( synLoop )
|
||||
{
|
||||
++numDone;
|
||||
}
|
||||
semDone.wait();
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numWaiters; ++i )
|
||||
group.create( &waiter );
|
||||
|
||||
for( int i = 0; i < numTries; ++i )
|
||||
{
|
||||
for( int j = 0; j < numWaiters; ++j )
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
++numReady;
|
||||
condReady.notify();
|
||||
}
|
||||
}
|
||||
while( true )
|
||||
{
|
||||
synchronized( synLoop )
|
||||
{
|
||||
if( numDone >= numWaiters )
|
||||
break;
|
||||
}
|
||||
Thread.yield();
|
||||
}
|
||||
for( int j = 0; j < numWaiters; ++j )
|
||||
{
|
||||
semDone.notify();
|
||||
}
|
||||
}
|
||||
|
||||
group.joinAll();
|
||||
assert( numTotal == numWaiters * numTries );
|
||||
}
|
||||
|
||||
|
||||
void testNotifyAll()
|
||||
{
|
||||
auto mutex = new Mutex;
|
||||
auto condReady = new Condition( mutex );
|
||||
int numWaiters = 10;
|
||||
int numReady = 0;
|
||||
int numDone = 0;
|
||||
bool alert = false;
|
||||
|
||||
void waiter()
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
++numReady;
|
||||
while( !alert )
|
||||
condReady.wait();
|
||||
++numDone;
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numWaiters; ++i )
|
||||
group.create( &waiter );
|
||||
|
||||
while( true )
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
if( numReady >= numWaiters )
|
||||
{
|
||||
alert = true;
|
||||
condReady.notifyAll();
|
||||
break;
|
||||
}
|
||||
}
|
||||
Thread.yield();
|
||||
}
|
||||
group.joinAll();
|
||||
assert( numReady == numWaiters && numDone == numWaiters );
|
||||
}
|
||||
|
||||
|
||||
void testWaitTimeout()
|
||||
{
|
||||
auto mutex = new Mutex;
|
||||
auto condReady = new Condition( mutex );
|
||||
bool waiting = false;
|
||||
bool alertedOne = true;
|
||||
bool alertedTwo = true;
|
||||
|
||||
void waiter()
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
waiting = true;
|
||||
alertedOne = condReady.wait( 10_000_000 ); // 1s
|
||||
alertedTwo = condReady.wait( 10_000_000 ); // 1s
|
||||
}
|
||||
}
|
||||
|
||||
auto thread = new Thread( &waiter );
|
||||
thread.start();
|
||||
|
||||
while( true )
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
if( waiting )
|
||||
{
|
||||
condReady.notify();
|
||||
break;
|
||||
}
|
||||
}
|
||||
Thread.yield();
|
||||
}
|
||||
thread.join();
|
||||
assert( waiting && alertedOne && !alertedTwo );
|
||||
}
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
testNotify();
|
||||
testNotifyAll();
|
||||
testWaitTimeout();
|
||||
}
|
||||
}
|
||||
72
druntime/src/common/core/sync/config.d
Normal file
72
druntime/src/common/core/sync/config.d
Normal file
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* The config module contains utility routines and configuration information
|
||||
* specific to this package.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.config;
|
||||
|
||||
|
||||
version( Posix )
|
||||
{
|
||||
private import core.sys.posix.time;
|
||||
private import core.sys.posix.sys.time;
|
||||
|
||||
|
||||
void mktspec( inout timespec t, long delta = 0 )
|
||||
{
|
||||
static if( is( typeof( clock_gettime ) ) )
|
||||
{
|
||||
clock_gettime( CLOCK_REALTIME, &t );
|
||||
}
|
||||
else
|
||||
{
|
||||
timeval tv;
|
||||
|
||||
gettimeofday( &tv, null );
|
||||
(cast(byte*) &t)[0 .. t.sizeof] = 0;
|
||||
t.tv_sec = cast(typeof(t.tv_sec)) tv.tv_sec;
|
||||
t.tv_nsec = cast(typeof(t.tv_nsec)) tv.tv_usec * 1_000;
|
||||
}
|
||||
mvtspec( t, delta );
|
||||
}
|
||||
|
||||
|
||||
void mvtspec( inout timespec t, long delta )
|
||||
{
|
||||
if( delta == 0 )
|
||||
return;
|
||||
|
||||
enum : uint
|
||||
{
|
||||
NANOS_PER_TICK = 100,
|
||||
TICKS_PER_SECOND = 10_000_000,
|
||||
NANOS_PER_SECOND = NANOS_PER_TICK * TICKS_PER_SECOND,
|
||||
}
|
||||
|
||||
if( t.tv_sec.max - t.tv_sec < delta / TICKS_PER_SECOND )
|
||||
{
|
||||
t.tv_sec = t.tv_sec.max;
|
||||
t.tv_nsec = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t.tv_sec += cast(typeof(t.tv_sec)) (delta / TICKS_PER_SECOND);
|
||||
long ns = (delta % TICKS_PER_SECOND) * NANOS_PER_TICK;
|
||||
if( NANOS_PER_SECOND - t.tv_nsec > ns )
|
||||
{
|
||||
t.tv_nsec = cast(typeof(t.tv_nsec)) ns;
|
||||
return;
|
||||
}
|
||||
t.tv_sec += 1;
|
||||
t.tv_nsec += cast(typeof(t.tv_nsec)) (ns - NANOS_PER_SECOND);
|
||||
}
|
||||
}
|
||||
}
|
||||
26
druntime/src/common/core/sync/exception.d
Normal file
26
druntime/src/common/core/sync/exception.d
Normal file
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
* The barrier module provides a primitive for synchronizing the progress of
|
||||
* a group of threads.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.exception;
|
||||
|
||||
|
||||
/**
|
||||
* Base class for synchronization exceptions.
|
||||
*/
|
||||
class SyncException : Exception
|
||||
{
|
||||
this( string msg )
|
||||
{
|
||||
super( msg );
|
||||
}
|
||||
}
|
||||
268
druntime/src/common/core/sync/mutex.d
Normal file
268
druntime/src/common/core/sync/mutex.d
Normal file
@@ -0,0 +1,268 @@
|
||||
/**
|
||||
* The mutex module provides a primitive for maintaining mutually exclusive
|
||||
* access.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.mutex;
|
||||
|
||||
|
||||
public import core.sync.exception;
|
||||
|
||||
version( Win32 )
|
||||
{
|
||||
private import core.sys.windows.windows;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
private import core.sys.posix.pthread;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Mutex
|
||||
//
|
||||
// void lock();
|
||||
// void unlock();
|
||||
// bool tryLock();
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class represents a general purpose, recursive mutex.
|
||||
*/
|
||||
class Mutex :
|
||||
Object.Monitor
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a mutex object.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
this()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
InitializeCriticalSection( &m_hndl );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_mutex_init( &m_hndl, &sm_attr );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to initialize mutex" );
|
||||
}
|
||||
m_proxy.link = this;
|
||||
// NOTE: With DMD this can be "this.__monitor = &m_proxy".
|
||||
(cast(void**) this)[1] = &m_proxy;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a mutex object and sets it as the monitor for o.
|
||||
*
|
||||
* In:
|
||||
* o must not already have a monitor.
|
||||
*/
|
||||
this( Object o )
|
||||
in
|
||||
{
|
||||
// NOTE: With DMD this can be "o.__monitor is null".
|
||||
assert( (cast(void**) o)[1] is null );
|
||||
}
|
||||
body
|
||||
{
|
||||
this();
|
||||
// NOTE: With DMD this can be "o.__monitor = &m_proxy".
|
||||
(cast(void**) o)[1] = &m_proxy;
|
||||
}
|
||||
|
||||
|
||||
~this()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
DeleteCriticalSection( &m_hndl );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_mutex_destroy( &m_hndl );
|
||||
assert( !rc, "Unable to destroy mutex" );
|
||||
}
|
||||
(cast(void**) this)[1] = null;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// General Actions
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* If this lock is not already held by the caller, the lock is acquired,
|
||||
* then the internal counter is incremented by one.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void lock()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
EnterCriticalSection( &m_hndl );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_mutex_lock( &m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to lock mutex" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Decrements the internal lock count by one. If this brings the count to
|
||||
* zero, the lock is released.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void unlock()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
LeaveCriticalSection( &m_hndl );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = pthread_mutex_unlock( &m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to unlock mutex" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* If the lock is held by another caller, the method returns. Otherwise,
|
||||
* the lock is acquired if it is not already held, and then the internal
|
||||
* counter is incremented by one.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*
|
||||
* Returns:
|
||||
* true if the lock was acquired and false if not.
|
||||
*/
|
||||
bool tryLock()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
return TryEnterCriticalSection( &m_hndl ) != 0;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
return pthread_mutex_trylock( &m_hndl ) == 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
version( Posix )
|
||||
{
|
||||
static this()
|
||||
{
|
||||
int rc = pthread_mutexattr_init( &sm_attr );
|
||||
assert( !rc );
|
||||
|
||||
rc = pthread_mutexattr_settype( &sm_attr, PTHREAD_MUTEX_RECURSIVE );
|
||||
assert( !rc );
|
||||
}
|
||||
|
||||
|
||||
static ~this()
|
||||
{
|
||||
int rc = pthread_mutexattr_destroy( &sm_attr );
|
||||
assert( !rc );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
version( Win32 )
|
||||
{
|
||||
CRITICAL_SECTION m_hndl;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
__gshared pthread_mutexattr_t sm_attr;
|
||||
|
||||
pthread_mutex_t m_hndl;
|
||||
}
|
||||
|
||||
struct MonitorProxy
|
||||
{
|
||||
Object.Monitor link;
|
||||
}
|
||||
|
||||
MonitorProxy m_proxy;
|
||||
|
||||
|
||||
package:
|
||||
version( Posix )
|
||||
{
|
||||
pthread_mutex_t* handleAddr()
|
||||
{
|
||||
return &m_hndl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
version( unittest )
|
||||
{
|
||||
private import core.thread;
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
auto mutex = new Mutex;
|
||||
int numThreads = 10;
|
||||
int numTries = 1000;
|
||||
int lockCount = 0;
|
||||
|
||||
void testFn()
|
||||
{
|
||||
for( int i = 0; i < numTries; ++i )
|
||||
{
|
||||
synchronized( mutex )
|
||||
{
|
||||
++lockCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numThreads; ++i )
|
||||
group.create( &testFn );
|
||||
|
||||
group.joinAll();
|
||||
assert( lockCount == numThreads * numTries );
|
||||
}
|
||||
}
|
||||
512
druntime/src/common/core/sync/rwmutex.d
Normal file
512
druntime/src/common/core/sync/rwmutex.d
Normal file
@@ -0,0 +1,512 @@
|
||||
/**
|
||||
* The read/write mutex module provides a primitive for maintaining shared read
|
||||
* access and mutually exclusive write access.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.rwmutex;
|
||||
|
||||
|
||||
public import core.sync.exception;
|
||||
private import core.sync.condition;
|
||||
private import core.sync.mutex;
|
||||
|
||||
version( Win32 )
|
||||
{
|
||||
private import core.sys.windows.windows;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
private import core.sys.posix.pthread;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ReadWriteMutex
|
||||
//
|
||||
// Reader reader();
|
||||
// Writer writer();
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class represents a mutex that allows any number of readers to enter,
|
||||
* but when a writer enters, all other readers and writers are blocked.
|
||||
*
|
||||
* Please note that this mutex is not recursive and is intended to guard access
|
||||
* to data only. Also, no deadlock checking is in place because doing so would
|
||||
* require dynamic memory allocation, which would reduce performance by an
|
||||
* unacceptable amount. As a result, any attempt to recursively acquire this
|
||||
* mutex may well deadlock the caller, particularly if a write lock is acquired
|
||||
* while holding a read lock, or vice-versa. In practice, this should not be
|
||||
* an issue however, because it is uncommon to call deeply into unknown code
|
||||
* while holding a lock that simply protects data.
|
||||
*/
|
||||
class ReadWriteMutex
|
||||
{
|
||||
/**
|
||||
* Defines the policy used by this mutex. Currently, two policies are
|
||||
* defined.
|
||||
*
|
||||
* The first will queue writers until no readers hold the mutex, then
|
||||
* pass the writers through one at a time. If a reader acquires the mutex
|
||||
* while there are still writers queued, the reader will take precedence.
|
||||
*
|
||||
* The second will queue readers if there are any writers queued. Writers
|
||||
* are passed through one at a time, and once there are no writers present,
|
||||
* all queued readers will be alerted.
|
||||
*
|
||||
* Future policies may offer a more even balance between reader and writer
|
||||
* precedence.
|
||||
*/
|
||||
enum Policy
|
||||
{
|
||||
PREFER_READERS, /// Readers get preference. This may starve writers.
|
||||
PREFER_WRITERS /// Writers get preference. This may starve readers.
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a read/write mutex object with the supplied policy.
|
||||
*
|
||||
* Params:
|
||||
* policy = The policy to use.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
this( Policy policy = Policy.PREFER_WRITERS )
|
||||
{
|
||||
m_commonMutex = new Mutex;
|
||||
if( !m_commonMutex )
|
||||
throw new SyncException( "Unable to initialize mutex" );
|
||||
scope(failure) delete m_commonMutex;
|
||||
|
||||
m_readerQueue = new Condition( m_commonMutex );
|
||||
if( !m_readerQueue )
|
||||
throw new SyncException( "Unable to initialize mutex" );
|
||||
scope(failure) delete m_readerQueue;
|
||||
|
||||
m_writerQueue = new Condition( m_commonMutex );
|
||||
if( !m_writerQueue )
|
||||
throw new SyncException( "Unable to initialize mutex" );
|
||||
scope(failure) delete m_writerQueue;
|
||||
|
||||
m_policy = policy;
|
||||
m_reader = new Reader;
|
||||
m_writer = new Writer;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// General Properties
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Gets the policy for the associated mutex.
|
||||
*
|
||||
* Returns:
|
||||
* The policy used by this mutex.
|
||||
*/
|
||||
Policy policy()
|
||||
{
|
||||
return m_policy;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Reader/Writer Handles
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Gets an object representing the reader lock for the associated mutex.
|
||||
*
|
||||
* Returns:
|
||||
* A reader sub-mutex.
|
||||
*/
|
||||
Reader reader()
|
||||
{
|
||||
return m_reader;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Gets an object representing the writer lock for the associated mutex.
|
||||
*
|
||||
* Returns:
|
||||
* A writer sub-mutex.
|
||||
*/
|
||||
Writer writer()
|
||||
{
|
||||
return m_writer;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Reader
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class can be considered a mutex in its own right, and is used to
|
||||
* negotiate a read lock for the enclosing mutex.
|
||||
*/
|
||||
class Reader :
|
||||
Object.Monitor
|
||||
{
|
||||
/**
|
||||
* Initializes a read/write mutex reader proxy object.
|
||||
*/
|
||||
this()
|
||||
{
|
||||
m_proxy.link = this;
|
||||
(cast(void**) this)[1] = &m_proxy;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Acquires a read lock on the enclosing mutex.
|
||||
*/
|
||||
void lock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
++m_numQueuedReaders;
|
||||
scope(exit) --m_numQueuedReaders;
|
||||
|
||||
while( shouldQueueReader() )
|
||||
m_readerQueue.wait();
|
||||
++m_numActiveReaders;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Releases a read lock on the enclosing mutex.
|
||||
*/
|
||||
void unlock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
if( --m_numActiveReaders < 1 )
|
||||
{
|
||||
if( m_numQueuedWriters > 0 )
|
||||
m_writerQueue.notify();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Attempts to acquire a read lock on the enclosing mutex. If one can
|
||||
* be obtained without blocking, the lock is acquired and true is
|
||||
* returned. If not, the lock is not acquired and false is returned.
|
||||
*
|
||||
* Returns:
|
||||
* true if the lock was acquired and false if not.
|
||||
*/
|
||||
bool tryLock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
if( shouldQueueReader() )
|
||||
return false;
|
||||
++m_numActiveReaders;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
bool shouldQueueReader()
|
||||
{
|
||||
if( m_numActiveWriters > 0 )
|
||||
return true;
|
||||
|
||||
switch( m_policy )
|
||||
{
|
||||
case Policy.PREFER_WRITERS:
|
||||
return m_numQueuedWriters > 0;
|
||||
|
||||
case Policy.PREFER_READERS:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
struct MonitorProxy
|
||||
{
|
||||
Object.Monitor link;
|
||||
}
|
||||
|
||||
MonitorProxy m_proxy;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Writer
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class can be considered a mutex in its own right, and is used to
|
||||
* negotiate a write lock for the enclosing mutex.
|
||||
*/
|
||||
class Writer :
|
||||
Object.Monitor
|
||||
{
|
||||
/**
|
||||
* Initializes a read/write mutex writer proxy object.
|
||||
*/
|
||||
this()
|
||||
{
|
||||
m_proxy.link = this;
|
||||
(cast(void**) this)[1] = &m_proxy;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Acquires a write lock on the enclosing mutex.
|
||||
*/
|
||||
void lock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
++m_numQueuedWriters;
|
||||
scope(exit) --m_numQueuedWriters;
|
||||
|
||||
while( shouldQueueWriter() )
|
||||
m_writerQueue.wait();
|
||||
++m_numActiveWriters;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Releases a write lock on the enclosing mutex.
|
||||
*/
|
||||
void unlock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
if( --m_numActiveWriters < 1 )
|
||||
{
|
||||
switch( m_policy )
|
||||
{
|
||||
default:
|
||||
case Policy.PREFER_READERS:
|
||||
if( m_numQueuedReaders > 0 )
|
||||
m_readerQueue.notifyAll();
|
||||
else if( m_numQueuedWriters > 0 )
|
||||
m_writerQueue.notify();
|
||||
break;
|
||||
case Policy.PREFER_WRITERS:
|
||||
if( m_numQueuedWriters > 0 )
|
||||
m_writerQueue.notify();
|
||||
else if( m_numQueuedReaders > 0 )
|
||||
m_readerQueue.notifyAll();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Attempts to acquire a write lock on the enclosing mutex. If one can
|
||||
* be obtained without blocking, the lock is acquired and true is
|
||||
* returned. If not, the lock is not acquired and false is returned.
|
||||
*
|
||||
* Returns:
|
||||
* true if the lock was acquired and false if not.
|
||||
*/
|
||||
bool tryLock()
|
||||
{
|
||||
synchronized( m_commonMutex )
|
||||
{
|
||||
if( shouldQueueWriter() )
|
||||
return false;
|
||||
++m_numActiveWriters;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
bool shouldQueueWriter()
|
||||
{
|
||||
if( m_numActiveWriters > 0 ||
|
||||
m_numActiveReaders > 0 )
|
||||
return true;
|
||||
switch( m_policy )
|
||||
{
|
||||
case Policy.PREFER_READERS:
|
||||
return m_numQueuedReaders > 0;
|
||||
|
||||
case Policy.PREFER_WRITERS:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
struct MonitorProxy
|
||||
{
|
||||
Object.Monitor link;
|
||||
}
|
||||
|
||||
MonitorProxy m_proxy;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
Policy m_policy;
|
||||
Reader m_reader;
|
||||
Writer m_writer;
|
||||
|
||||
Mutex m_commonMutex;
|
||||
Condition m_readerQueue;
|
||||
Condition m_writerQueue;
|
||||
|
||||
int m_numQueuedReaders;
|
||||
int m_numActiveReaders;
|
||||
int m_numQueuedWriters;
|
||||
int m_numActiveWriters;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
version( unittest )
|
||||
{
|
||||
static if( !is( typeof( Thread ) ) )
|
||||
private import core.thread;
|
||||
|
||||
|
||||
void testRead( ReadWriteMutex.Policy policy )
|
||||
{
|
||||
auto mutex = new ReadWriteMutex( policy );
|
||||
auto synInfo = new Object;
|
||||
int numThreads = 10;
|
||||
int numReaders = 0;
|
||||
int maxReaders = 0;
|
||||
|
||||
void readerFn()
|
||||
{
|
||||
synchronized( mutex.reader() )
|
||||
{
|
||||
synchronized( synInfo )
|
||||
{
|
||||
if( ++numReaders > maxReaders )
|
||||
maxReaders = numReaders;
|
||||
}
|
||||
Thread.sleep( 100_000 ); // 1ms
|
||||
synchronized( synInfo )
|
||||
{
|
||||
--numReaders;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numThreads; ++i )
|
||||
{
|
||||
group.create( &readerFn );
|
||||
}
|
||||
group.joinAll();
|
||||
assert( numReaders < 1 && maxReaders > 1 );
|
||||
}
|
||||
|
||||
|
||||
void testReadWrite( ReadWriteMutex.Policy policy )
|
||||
{
|
||||
auto mutex = new ReadWriteMutex( policy );
|
||||
auto synInfo = new Object;
|
||||
int numThreads = 10;
|
||||
int numReaders = 0;
|
||||
int numWriters = 0;
|
||||
int maxReaders = 0;
|
||||
int maxWriters = 0;
|
||||
int numTries = 20;
|
||||
|
||||
void readerFn()
|
||||
{
|
||||
for( int i = 0; i < numTries; ++i )
|
||||
{
|
||||
synchronized( mutex.reader() )
|
||||
{
|
||||
synchronized( synInfo )
|
||||
{
|
||||
if( ++numReaders > maxReaders )
|
||||
maxReaders = numReaders;
|
||||
}
|
||||
Thread.sleep( 100_000 ); // 1ms
|
||||
synchronized( synInfo )
|
||||
{
|
||||
--numReaders;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void writerFn()
|
||||
{
|
||||
for( int i = 0; i < numTries; ++i )
|
||||
{
|
||||
synchronized( mutex.writer() )
|
||||
{
|
||||
synchronized( synInfo )
|
||||
{
|
||||
if( ++numWriters > maxWriters )
|
||||
maxWriters = numWriters;
|
||||
}
|
||||
Thread.sleep( 100_000 ); // 1ms
|
||||
synchronized( synInfo )
|
||||
{
|
||||
--numWriters;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numThreads; ++i )
|
||||
{
|
||||
group.create( &readerFn );
|
||||
group.create( &writerFn );
|
||||
}
|
||||
group.joinAll();
|
||||
assert( numReaders < 1 && maxReaders > 1 &&
|
||||
numWriters < 1 && maxWriters < 2 );
|
||||
}
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
testRead( ReadWriteMutex.Policy.PREFER_READERS );
|
||||
testRead( ReadWriteMutex.Policy.PREFER_WRITERS );
|
||||
testReadWrite( ReadWriteMutex.Policy.PREFER_READERS );
|
||||
testReadWrite( ReadWriteMutex.Policy.PREFER_WRITERS );
|
||||
}
|
||||
}
|
||||
506
druntime/src/common/core/sync/semaphore.d
Normal file
506
druntime/src/common/core/sync/semaphore.d
Normal file
@@ -0,0 +1,506 @@
|
||||
/**
|
||||
* The semaphore module provides a general use semaphore for synchronization.
|
||||
*
|
||||
* Copyright: Copyright Sean Kelly 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Sean Kelly
|
||||
*
|
||||
* Copyright Sean Kelly 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.sync.semaphore;
|
||||
|
||||
|
||||
public import core.sync.exception;
|
||||
|
||||
version( Win32 )
|
||||
{
|
||||
private import core.sys.windows.windows;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
private import core.sync.config;
|
||||
private import core.stdc.errno;
|
||||
private import core.sys.posix.time;
|
||||
private import core.sys.osx.mach.semaphore;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
private import core.sync.config;
|
||||
private import core.stdc.errno;
|
||||
private import core.sys.posix.pthread;
|
||||
private import core.sys.posix.semaphore;
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Semaphore
|
||||
//
|
||||
// void wait();
|
||||
// void notify();
|
||||
// bool tryWait();
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* This class represents a general counting semaphore as concieved by Edsger
|
||||
* Dijkstra. As per Mesa type monitors however, "signal" has been replaced
|
||||
* with "notify" to indicate that control is not transferred to the waiter when
|
||||
* a notification is sent.
|
||||
*/
|
||||
class Semaphore
|
||||
{
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// Initialization
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Initializes a semaphore object with the specified initial count.
|
||||
*
|
||||
* Params:
|
||||
* count = The initial count for the semaphore.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
this( uint count = 0 )
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
m_hndl = CreateSemaphoreA( null, count, int.max, null );
|
||||
if( m_hndl == m_hndl.init )
|
||||
throw new SyncException( "Unable to create semaphore" );
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
auto rc = semaphore_create( mach_task_self(), &m_hndl, SYNC_POLICY_FIFO, count );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to create semaphore" );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = sem_init( &m_hndl, 0, count );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to create semaphore" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
~this()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
BOOL rc = CloseHandle( m_hndl );
|
||||
assert( rc, "Unable to destroy semaphore" );
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
auto rc = semaphore_destroy( mach_task_self(), m_hndl );
|
||||
assert( !rc, "Unable to destroy semaphore" );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = sem_destroy( &m_hndl );
|
||||
assert( !rc, "Unable to destroy semaphore" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
// General Actions
|
||||
////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* Wait until the current count is above zero, then atomically decrement
|
||||
* the count by one and return.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void wait()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
DWORD rc = WaitForSingleObject( m_hndl, INFINITE );
|
||||
if( rc != WAIT_OBJECT_0 )
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
while( true )
|
||||
{
|
||||
auto rc = semaphore_wait( m_hndl );
|
||||
if( !rc )
|
||||
return;
|
||||
if( rc == KERN_ABORTED && errno == EINTR )
|
||||
continue;
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
while( true )
|
||||
{
|
||||
if( !sem_wait( &m_hndl ) )
|
||||
return;
|
||||
if( errno != EINTR )
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Suspends the calling thread until the current count moves above zero or
|
||||
* until the supplied time period has elapsed. If the count moves above
|
||||
* zero in this interval, then atomically decrement the count by one and
|
||||
* return true. Otherwise, return false.
|
||||
*
|
||||
*
|
||||
* Params:
|
||||
* period = The time to wait, in 100 nanosecond intervals. This value may
|
||||
* be adjusted to equal to the maximum wait period supported by
|
||||
* the target platform if it is too large.
|
||||
*
|
||||
* In:
|
||||
* period must be non-negative.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*
|
||||
* Returns:
|
||||
* true if notified before the timeout and false if not.
|
||||
*/
|
||||
bool wait( long period )
|
||||
in
|
||||
{
|
||||
assert( period >= 0 );
|
||||
}
|
||||
body
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
enum : uint
|
||||
{
|
||||
TICKS_PER_MILLI = 10_000,
|
||||
MAX_WAIT_MILLIS = uint.max - 1
|
||||
}
|
||||
|
||||
period /= TICKS_PER_MILLI;
|
||||
if( period > MAX_WAIT_MILLIS )
|
||||
period = MAX_WAIT_MILLIS;
|
||||
switch( WaitForSingleObject( m_hndl, cast(uint) period ) )
|
||||
{
|
||||
case WAIT_OBJECT_0:
|
||||
return true;
|
||||
case WAIT_TIMEOUT:
|
||||
return false;
|
||||
default:
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
mach_timespec_t t = void;
|
||||
(cast(byte*) &t)[0 .. t.sizeof] = 0;
|
||||
|
||||
if( period != 0 )
|
||||
{
|
||||
enum : uint
|
||||
{
|
||||
NANOS_PER_TICK = 100,
|
||||
TICKS_PER_SECOND = 10_000_000,
|
||||
NANOS_PER_SECOND = NANOS_PER_TICK * TICKS_PER_SECOND,
|
||||
}
|
||||
|
||||
if( t.tv_sec.max - t.tv_sec < period / TICKS_PER_SECOND )
|
||||
{
|
||||
t.tv_sec = t.tv_sec.max;
|
||||
t.tv_nsec = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t.tv_sec += cast(typeof(t.tv_sec)) (period / TICKS_PER_SECOND);
|
||||
long ns = (period % TICKS_PER_SECOND) * NANOS_PER_TICK;
|
||||
if( NANOS_PER_SECOND - t.tv_nsec > ns )
|
||||
t.tv_nsec = cast(typeof(t.tv_nsec)) ns;
|
||||
else
|
||||
{
|
||||
t.tv_sec += 1;
|
||||
t.tv_nsec += ns - NANOS_PER_SECOND;
|
||||
}
|
||||
}
|
||||
}
|
||||
while( true )
|
||||
{
|
||||
auto rc = semaphore_timedwait( m_hndl, t );
|
||||
if( !rc )
|
||||
return true;
|
||||
if( rc == KERN_OPERATION_TIMED_OUT )
|
||||
return false;
|
||||
if( rc != KERN_ABORTED || errno != EINTR )
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
// -w trip
|
||||
return false;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
timespec t = void;
|
||||
mktspec( t, period );
|
||||
|
||||
while( true )
|
||||
{
|
||||
if( !sem_timedwait( &m_hndl, &t ) )
|
||||
return true;
|
||||
if( errno == ETIMEDOUT )
|
||||
return false;
|
||||
if( errno != EINTR )
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
// -w trip
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Atomically increment the current count by one. This will notify one
|
||||
* waiter, if there are any in the queue.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*/
|
||||
void notify()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
if( !ReleaseSemaphore( m_hndl, 1, null ) )
|
||||
throw new SyncException( "Unable to notify semaphore" );
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
auto rc = semaphore_signal( m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to notify semaphore" );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
int rc = sem_post( &m_hndl );
|
||||
if( rc )
|
||||
throw new SyncException( "Unable to notify semaphore" );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* If the current count is equal to zero, return. Otherwise, atomically
|
||||
* decrement the count by one and return true.
|
||||
*
|
||||
* Throws:
|
||||
* SyncException on error.
|
||||
*
|
||||
* Returns:
|
||||
* true if the count was above zero and false if not.
|
||||
*/
|
||||
bool tryWait()
|
||||
{
|
||||
version( Win32 )
|
||||
{
|
||||
switch( WaitForSingleObject( m_hndl, 0 ) )
|
||||
{
|
||||
case WAIT_OBJECT_0:
|
||||
return true;
|
||||
case WAIT_TIMEOUT:
|
||||
return false;
|
||||
default:
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
return wait( 0 );
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
while( true )
|
||||
{
|
||||
if( !sem_trywait( &m_hndl ) )
|
||||
return true;
|
||||
if( errno == EAGAIN )
|
||||
return false;
|
||||
if( errno != EINTR )
|
||||
throw new SyncException( "Unable to wait for semaphore" );
|
||||
}
|
||||
// -w trip
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
version( Win32 )
|
||||
{
|
||||
HANDLE m_hndl;
|
||||
}
|
||||
else version( OSX )
|
||||
{
|
||||
semaphore_t m_hndl;
|
||||
}
|
||||
else version( Posix )
|
||||
{
|
||||
sem_t m_hndl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Unit Tests
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
version( unittest )
|
||||
{
|
||||
private import core.thread;
|
||||
|
||||
|
||||
void testWait()
|
||||
{
|
||||
auto semaphore = new Semaphore;
|
||||
int numToProduce = 10;
|
||||
bool allProduced = false;
|
||||
auto synProduced = new Object;
|
||||
int numConsumed = 0;
|
||||
auto synConsumed = new Object;
|
||||
int numConsumers = 10;
|
||||
int numComplete = 0;
|
||||
auto synComplete = new Object;
|
||||
|
||||
void consumer()
|
||||
{
|
||||
while( true )
|
||||
{
|
||||
semaphore.wait();
|
||||
|
||||
synchronized( synProduced )
|
||||
{
|
||||
if( allProduced )
|
||||
break;
|
||||
}
|
||||
|
||||
synchronized( synConsumed )
|
||||
{
|
||||
++numConsumed;
|
||||
}
|
||||
}
|
||||
|
||||
synchronized( synComplete )
|
||||
{
|
||||
++numComplete;
|
||||
}
|
||||
}
|
||||
|
||||
void producer()
|
||||
{
|
||||
assert( !semaphore.tryWait() );
|
||||
|
||||
for( int i = 0; i < numToProduce; ++i )
|
||||
{
|
||||
semaphore.notify();
|
||||
Thread.yield();
|
||||
}
|
||||
Thread.sleep( 10_000_000 ); // 1s
|
||||
synchronized( synProduced )
|
||||
{
|
||||
allProduced = true;
|
||||
}
|
||||
|
||||
for( int i = 0; i < numConsumers; ++i )
|
||||
{
|
||||
semaphore.notify();
|
||||
Thread.yield();
|
||||
}
|
||||
|
||||
for( int i = numConsumers * 10000; i > 0; --i )
|
||||
{
|
||||
synchronized( synComplete )
|
||||
{
|
||||
if( numComplete == numConsumers )
|
||||
break;
|
||||
}
|
||||
Thread.yield();
|
||||
}
|
||||
|
||||
synchronized( synComplete )
|
||||
{
|
||||
assert( numComplete == numConsumers );
|
||||
}
|
||||
|
||||
synchronized( synConsumed )
|
||||
{
|
||||
assert( numConsumed == numToProduce );
|
||||
}
|
||||
|
||||
assert( !semaphore.tryWait() );
|
||||
semaphore.notify();
|
||||
assert( semaphore.tryWait() );
|
||||
assert( !semaphore.tryWait() );
|
||||
}
|
||||
|
||||
auto group = new ThreadGroup;
|
||||
|
||||
for( int i = 0; i < numConsumers; ++i )
|
||||
group.create( &consumer );
|
||||
group.create( &producer );
|
||||
group.joinAll();
|
||||
}
|
||||
|
||||
|
||||
void testWaitTimeout()
|
||||
{
|
||||
auto synReady = new Object;
|
||||
auto semReady = new Semaphore;
|
||||
bool waiting = false;
|
||||
bool alertedOne = true;
|
||||
bool alertedTwo = true;
|
||||
|
||||
void waiter()
|
||||
{
|
||||
synchronized( synReady )
|
||||
{
|
||||
waiting = true;
|
||||
}
|
||||
alertedOne = semReady.wait( 10_000_000 ); // 100ms
|
||||
alertedTwo = semReady.wait( 10_000_000 ); // 100ms
|
||||
}
|
||||
|
||||
auto thread = new Thread( &waiter );
|
||||
thread.start();
|
||||
|
||||
while( true )
|
||||
{
|
||||
synchronized( synReady )
|
||||
{
|
||||
if( waiting )
|
||||
{
|
||||
semReady.notify();
|
||||
break;
|
||||
}
|
||||
}
|
||||
Thread.yield();
|
||||
}
|
||||
thread.join();
|
||||
assert( waiting && alertedOne && !alertedTwo );
|
||||
}
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
testWait();
|
||||
testWaitTimeout();
|
||||
}
|
||||
}
|
||||
3516
druntime/src/common/core/thread.d
Normal file
3516
druntime/src/common/core/thread.d
Normal file
File diff suppressed because it is too large
Load Diff
143
druntime/src/common/core/threadasm.S
Normal file
143
druntime/src/common/core/threadasm.S
Normal file
@@ -0,0 +1,143 @@
|
||||
/**
|
||||
* Support code for mutithreading.
|
||||
*
|
||||
* Copyright: Copyright Mikola Lysenko 2005 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Mikola Lysenko
|
||||
*
|
||||
* Copyright Mikola Lysenko 2005 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
/************************************************************************************
|
||||
* POWER PC ASM BITS
|
||||
************************************************************************************/
|
||||
#if defined( __ppc__ ) || defined( __PPC__ ) || defined( __powerpc__ )
|
||||
|
||||
|
||||
/**
|
||||
* Performs a context switch.
|
||||
*
|
||||
* r3 - old context pointer
|
||||
* r4 - new context pointer
|
||||
*
|
||||
*/
|
||||
.text
|
||||
.align 2
|
||||
.globl _fiber_switchContext
|
||||
_fiber_switchContext:
|
||||
|
||||
/* Save linkage area */
|
||||
mflr r0
|
||||
mfcr r5
|
||||
stw r0, 8(r1)
|
||||
stw r5, 4(r1)
|
||||
|
||||
/* Save GPRs */
|
||||
stw r11, (-1 * 4)(r1)
|
||||
stw r13, (-2 * 4)(r1)
|
||||
stw r14, (-3 * 4)(r1)
|
||||
stw r15, (-4 * 4)(r1)
|
||||
stw r16, (-5 * 4)(r1)
|
||||
stw r17, (-6 * 4)(r1)
|
||||
stw r18, (-7 * 4)(r1)
|
||||
stw r19, (-8 * 4)(r1)
|
||||
stw r20, (-9 * 4)(r1)
|
||||
stw r21, (-10 * 4)(r1)
|
||||
stw r22, (-11 * 4)(r1)
|
||||
stw r23, (-12 * 4)(r1)
|
||||
stw r24, (-13 * 4)(r1)
|
||||
stw r25, (-14 * 4)(r1)
|
||||
stw r26, (-15 * 4)(r1)
|
||||
stw r27, (-16 * 4)(r1)
|
||||
stw r28, (-17 * 4)(r1)
|
||||
stw r29, (-18 * 4)(r1)
|
||||
stw r30, (-19 * 4)(r1)
|
||||
stwu r31, (-20 * 4)(r1)
|
||||
|
||||
/* We update the stack pointer here, since we do not want the GC to
|
||||
scan the floating point registers. */
|
||||
|
||||
/* Save FPRs */
|
||||
stfd f14, (-1 * 8)(r1)
|
||||
stfd f15, (-2 * 8)(r1)
|
||||
stfd f16, (-3 * 8)(r1)
|
||||
stfd f17, (-4 * 8)(r1)
|
||||
stfd f18, (-5 * 8)(r1)
|
||||
stfd f19, (-6 * 8)(r1)
|
||||
stfd f20, (-7 * 8)(r1)
|
||||
stfd f21, (-8 * 8)(r1)
|
||||
stfd f22, (-9 * 8)(r1)
|
||||
stfd f23, (-10 * 8)(r1)
|
||||
stfd f24, (-11 * 8)(r1)
|
||||
stfd f25, (-12 * 8)(r1)
|
||||
stfd f26, (-13 * 8)(r1)
|
||||
stfd f27, (-14 * 8)(r1)
|
||||
stfd f28, (-15 * 8)(r1)
|
||||
stfd f29, (-16 * 8)(r1)
|
||||
stfd f30, (-17 * 8)(r1)
|
||||
stfd f31, (-18 * 8)(r1)
|
||||
|
||||
/* Update the old stack pointer */
|
||||
stw r1, 0(r3)
|
||||
|
||||
/* Set new stack pointer */
|
||||
addi r1, r4, 20 * 4
|
||||
|
||||
/* Restore linkage area */
|
||||
lwz r0, 8(r1)
|
||||
lwz r5, 4(r1)
|
||||
|
||||
/* Restore GPRs */
|
||||
lwz r11, (-1 * 4)(r1)
|
||||
lwz r13, (-2 * 4)(r1)
|
||||
lwz r14, (-3 * 4)(r1)
|
||||
lwz r15, (-4 * 4)(r1)
|
||||
lwz r16, (-5 * 4)(r1)
|
||||
lwz r17, (-6 * 4)(r1)
|
||||
lwz r18, (-7 * 4)(r1)
|
||||
lwz r19, (-8 * 4)(r1)
|
||||
lwz r20, (-9 * 4)(r1)
|
||||
lwz r21, (-10 * 4)(r1)
|
||||
lwz r22, (-11 * 4)(r1)
|
||||
lwz r23, (-12 * 4)(r1)
|
||||
lwz r24, (-13 * 4)(r1)
|
||||
lwz r25, (-14 * 4)(r1)
|
||||
lwz r26, (-15 * 4)(r1)
|
||||
lwz r27, (-16 * 4)(r1)
|
||||
lwz r28, (-17 * 4)(r1)
|
||||
lwz r29, (-18 * 4)(r1)
|
||||
lwz r30, (-19 * 4)(r1)
|
||||
lwz r31, (-20 * 4)(r1)
|
||||
|
||||
|
||||
/* Restore FPRs */
|
||||
lfd f14, (-1 * 8)(r4)
|
||||
lfd f15, (-2 * 8)(r4)
|
||||
lfd f16, (-3 * 8)(r4)
|
||||
lfd f17, (-4 * 8)(r4)
|
||||
lfd f18, (-5 * 8)(r4)
|
||||
lfd f19, (-6 * 8)(r4)
|
||||
lfd f20, (-7 * 8)(r4)
|
||||
lfd f21, (-8 * 8)(r4)
|
||||
lfd f22, (-9 * 8)(r4)
|
||||
lfd f23, (-10 * 8)(r4)
|
||||
lfd f24, (-11 * 8)(r4)
|
||||
lfd f25, (-12 * 8)(r4)
|
||||
lfd f26, (-13 * 8)(r4)
|
||||
lfd f27, (-14 * 8)(r4)
|
||||
lfd f28, (-15 * 8)(r4)
|
||||
lfd f29, (-16 * 8)(r4)
|
||||
lfd f30, (-17 * 8)(r4)
|
||||
lfd f31, (-18 * 8)(r4)
|
||||
|
||||
/* Set condition and link register */
|
||||
mtcr r5
|
||||
mtlr r0
|
||||
|
||||
/* Return and switch context */
|
||||
blr
|
||||
|
||||
#endif
|
||||
81
druntime/src/common/core/vararg.d
Normal file
81
druntime/src/common/core/vararg.d
Normal file
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* The vararg module is intended to facilitate vararg manipulation in D.
|
||||
* It should be interface compatible with the C module "stdarg," and the
|
||||
* two modules may share a common implementation if possible (as is done
|
||||
* here).
|
||||
* Copyright: Copyright Digital Mars 2000 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Hauke Duden
|
||||
*
|
||||
* Copyright Digital Mars 2000 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module core.vararg;
|
||||
|
||||
|
||||
/**
|
||||
* The base vararg list type.
|
||||
*/
|
||||
alias void* va_list;
|
||||
|
||||
|
||||
/**
|
||||
* This function initializes the supplied argument pointer for subsequent
|
||||
* use by va_arg and va_end.
|
||||
*
|
||||
* Params:
|
||||
* ap = The argument pointer to initialize.
|
||||
* paramn = The identifier of the rightmost parameter in the function
|
||||
* parameter list.
|
||||
*/
|
||||
void va_start(T) ( out va_list ap, inout T parmn )
|
||||
{
|
||||
ap = cast(va_list) ( cast(void*) &parmn + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
|
||||
}
|
||||
|
||||
/**
|
||||
* This function returns the next argument in the sequence referenced by
|
||||
* the supplied argument pointer. The argument pointer will be adjusted
|
||||
* to point to the next arggument in the sequence.
|
||||
*
|
||||
* Params:
|
||||
* ap = The argument pointer.
|
||||
*
|
||||
* Returns:
|
||||
* The next argument in the sequence. The result is undefined if ap
|
||||
* does not point to a valid argument.
|
||||
*/
|
||||
T va_arg(T) ( inout va_list ap )
|
||||
{
|
||||
T arg = *cast(T*) ap;
|
||||
ap = cast(va_list) ( cast(void*) ap + ( ( T.sizeof + int.sizeof - 1 ) & ~( int.sizeof - 1 ) ) );
|
||||
return arg;
|
||||
}
|
||||
|
||||
/**
|
||||
* This function cleans up any resources allocated by va_start. It is
|
||||
* currently a no-op and exists mostly for syntax compatibility with
|
||||
* the variadric argument functions for C.
|
||||
*
|
||||
* Params:
|
||||
* ap = The argument pointer.
|
||||
*/
|
||||
void va_end( va_list ap )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* This function copied the argument pointer src to dst.
|
||||
*
|
||||
* Params:
|
||||
* src = The source pointer.
|
||||
* dst = The destination pointer.
|
||||
*/
|
||||
void va_copy( out va_list dst, va_list src )
|
||||
{
|
||||
dst = src;
|
||||
}
|
||||
81
druntime/src/common/posix.mak
Normal file
81
druntime/src/common/posix.mak
Normal file
@@ -0,0 +1,81 @@
|
||||
# Makefile to build the D runtime library core components for Posix
|
||||
# Designed to work with GNU make
|
||||
# Targets:
|
||||
# make
|
||||
# Same as make all
|
||||
# make debug
|
||||
# Build the debug version of the library
|
||||
# make release
|
||||
# Build the release version of the library
|
||||
# make doc
|
||||
# Generate documentation
|
||||
# make clean
|
||||
# Delete all files created by build process
|
||||
|
||||
# Essentials
|
||||
|
||||
LIBDIR=../../lib
|
||||
DOCDIR=../../doc
|
||||
IMPDIR=../../import
|
||||
LIBBASENAME=libdruntime-core.a
|
||||
MODULES=bitop exception memory runtime thread vararg \
|
||||
$(addprefix sync/,barrier condition config exception mutex rwmutex semaphore)
|
||||
BUILDS=debug release unittest
|
||||
|
||||
# Symbols
|
||||
|
||||
DMD=dmd
|
||||
CLC=ar rsv
|
||||
DOCFLAGS=-version=DDoc
|
||||
DFLAGS_release=-d -release -O -inline -w
|
||||
DFLAGS_debug=-d -g -w
|
||||
DFLAGS_unittest=$(DFLAGS_release) -unittest
|
||||
CFLAGS_release= -O
|
||||
CFLAGS_debug= -g
|
||||
CFLAGS_unittest=$(CFLAGS_release)
|
||||
|
||||
# Derived symbols
|
||||
|
||||
C_SRCS=core/stdc/errno.c #core/threadasm.S
|
||||
C_OBJS=errno.o threadasm.o
|
||||
AS_OBJS=$(addsuffix .o,$(basename $(AS_SRCS)))
|
||||
D_SRCS=$(addsuffix .d,$(addprefix core/,$(MODULES))) \
|
||||
$(addsuffix .d,$(addprefix $(IMPDIR)/core/stdc/,math stdarg stdio wchar_)) \
|
||||
$(addsuffix .d,$(addprefix $(IMPDIR)/core/sys/posix/,netinet/in_ sys/select sys/socket sys/stat sys/wait))
|
||||
ALL_OBJS_O=$(addsuffix .o,$(addprefix core/,$(MODULES))) \
|
||||
$(addsuffix .o,$(addprefix $(IMPDIR)/core/stdc/,math stdarg stdio wchar_)) \
|
||||
$(addsuffix .o,$(addprefix $(IMPDIR)/core/sys/posix/,netinet/in_ sys/select sys/socket sys/stat sys/wait)) \
|
||||
$(AS_OBJS) $(C_OBJS)
|
||||
DOCS=$(addsuffix .html,$(addprefix $(DOCDIR)/core/,$(MODULES)))
|
||||
IMPORTS=$(addsuffix .di,$(addprefix $(IMPDIR)/core/,$(MODULES)))
|
||||
ALLLIBS=$(addsuffix /$(LIBBASENAME),$(addprefix $(LIBDIR)/,$(BUILDS)))
|
||||
|
||||
# Patterns
|
||||
|
||||
$(LIBDIR)/%/$(LIBBASENAME) : $(D_SRCS) $(C_SRCS)
|
||||
$(CC) -c $(CFLAGS_$*) $(C_SRCS)
|
||||
ifeq ($(DMD),ldc2 -vv)
|
||||
$(DMD) $(DFLAGS_$*) -of$@ $(D_SRCS)
|
||||
$(CLC) $@ $(ALL_OBJS_O)
|
||||
else
|
||||
$(DMD) $(DFLAGS_$*) -lib -of$@ $(D_SRCS) $(C_OBJS)
|
||||
endif
|
||||
rm $(C_OBJS)
|
||||
|
||||
$(DOCDIR)/%.html : %.d
|
||||
$(DMD) -c -d -o- -Df$@ $<
|
||||
|
||||
$(IMPDIR)/%.di : %.d
|
||||
$(DMD) -c -d -o- -Hf$@ $<
|
||||
|
||||
# Rulez
|
||||
|
||||
all : $(BUILDS) doc
|
||||
|
||||
debug : $(LIBDIR)/debug/$(LIBBASENAME) $(IMPORTS)
|
||||
release : $(LIBDIR)/release/$(LIBBASENAME) $(IMPORTS)
|
||||
unittest : $(LIBDIR)/unittest/$(LIBBASENAME) $(IMPORTS)
|
||||
doc : $(DOCS)
|
||||
|
||||
clean :
|
||||
rm -f $(IMPORTS) $(DOCS) $(ALLLIBS)
|
||||
226
druntime/src/common/win32.mak
Normal file
226
druntime/src/common/win32.mak
Normal file
@@ -0,0 +1,226 @@
|
||||
# Makefile to build the D runtime library core components for Posix
|
||||
# Designed to work with GNU make
|
||||
# Targets:
|
||||
# make
|
||||
# Same as make all
|
||||
# make debug
|
||||
# Build the debug version of the library
|
||||
# make release
|
||||
# Build the release version of the library
|
||||
# make doc
|
||||
# Generate documentation
|
||||
# make clean
|
||||
# Delete all files created by build process
|
||||
|
||||
# Essentials
|
||||
|
||||
LIBDIR=..\..\lib
|
||||
DOCDIR=..\..\doc
|
||||
IMPDIR=..\..\import
|
||||
LIBBASENAME=druntime_core.lib
|
||||
#MODULES=bitop exception memory runtime thread vararg \
|
||||
# $(addprefix sync/,barrier condition config exception mutex rwmutex semaphore)
|
||||
BUILDS=debug release unittest
|
||||
|
||||
# Symbols
|
||||
|
||||
CC=dmc
|
||||
DMD=dmd
|
||||
DOCFLAGS=-version=DDoc
|
||||
DFLAGS_release=-d -release -O -inline -w -nofloat
|
||||
DFLAGS_debug=-d -g -w -nofloat
|
||||
DFLAGS_unittest=$(DFLAGS_release) -unittest
|
||||
CFLAGS_release=-mn -6 -r
|
||||
CFLAGS_debug=-g -mn -6 -r
|
||||
CFLAGS_unittest=$(CFLAGS_release)
|
||||
|
||||
# Derived symbols
|
||||
|
||||
C_SRCS=core\stdc\errno.c
|
||||
|
||||
C_OBJS=errno.obj
|
||||
|
||||
D_SRCS=\
|
||||
core\bitop.d \
|
||||
core\exception.d \
|
||||
core\memory.d \
|
||||
core\runtime.d \
|
||||
core\thread.d \
|
||||
core\vararg.d \
|
||||
\
|
||||
core\sync\barrier.d \
|
||||
core\sync\condition.d \
|
||||
core\sync\config.d \
|
||||
core\sync\exception.d \
|
||||
core\sync\mutex.d \
|
||||
core\sync\rwmutex.d \
|
||||
core\sync\semaphore.d \
|
||||
\
|
||||
$(IMPDIR)\core\stdc\math.d \
|
||||
$(IMPDIR)\core\stdc\stdarg.d \
|
||||
$(IMPDIR)\core\stdc\stdio.d \
|
||||
$(IMPDIR)\core\stdc\wchar_.d \
|
||||
\
|
||||
$(IMPDIR)\core\sys\windows\windows.d
|
||||
|
||||
DOCS=\
|
||||
$(DOCDIR)\core\bitop.html \
|
||||
$(DOCDIR)\core\exception.html \
|
||||
$(DOCDIR)\core\memory.html \
|
||||
$(DOCDIR)\core\runtime.html \
|
||||
$(DOCDIR)\core\thread.html \
|
||||
$(DOCDIR)\core\vararg.html \
|
||||
\
|
||||
$(DOCDIR)\core\sync\barrier.html \
|
||||
$(DOCDIR)\core\sync\condition.html \
|
||||
$(DOCDIR)\core\sync\config.html \
|
||||
$(DOCDIR)\core\sync\exception.html \
|
||||
$(DOCDIR)\core\sync\mutex.html \
|
||||
$(DOCDIR)\core\sync\rwmutex.html \
|
||||
$(DOCDIR)\core\sync\semaphore.html
|
||||
|
||||
IMPORTS=\
|
||||
$(IMPDIR)\core\exception.di \
|
||||
$(IMPDIR)\core\memory.di \
|
||||
$(IMPDIR)\core\runtime.di \
|
||||
$(IMPDIR)\core\thread.di \
|
||||
$(IMPDIR)\core\vararg.di \
|
||||
\
|
||||
$(IMPDIR)\core\sync\barrier.di \
|
||||
$(IMPDIR)\core\sync\condition.di \
|
||||
$(IMPDIR)\core\sync\config.di \
|
||||
$(IMPDIR)\core\sync\exception.di \
|
||||
$(IMPDIR)\core\sync\mutex.di \
|
||||
$(IMPDIR)\core\sync\rwmutex.di \
|
||||
$(IMPDIR)\core\sync\semaphore.di
|
||||
# bitop.di is already published
|
||||
|
||||
ALLLIBS=\
|
||||
$(LIBDIR)\debug\$(LIBBASENAME) \
|
||||
$(LIBDIR)\release\$(LIBBASENAME) \
|
||||
$(LIBDIR)\unittest\$(LIBBASENAME)
|
||||
|
||||
# Patterns
|
||||
|
||||
#$(LIBDIR)\%\$(LIBBASENAME) : $(D_SRCS) $(C_SRCS)
|
||||
# $(CC) -c $(CFLAGS_$*) $(C_SRCS)
|
||||
# $(DMD) $(DFLAGS_$*) -lib -of$@ $(D_SRCS) $(C_OBJS)
|
||||
# del $(C_OBJS)
|
||||
|
||||
#$(DOCDIR)\%.html : %.d
|
||||
# $(DMD) -c -d -o- -Df$@ $<
|
||||
|
||||
#$(IMPDIR)\%.di : %.d
|
||||
# $(DMD) -c -d -o- -Hf$@ $<
|
||||
|
||||
# Patterns - debug
|
||||
|
||||
$(LIBDIR)\debug\$(LIBBASENAME) : $(D_SRCS) $(C_SRCS)
|
||||
$(CC) -c $(CFLAGS_debug) $(C_SRCS)
|
||||
$(DMD) $(DFLAGS_debug) -lib -of$@ $(D_SRCS) $(C_OBJS)
|
||||
del $(C_OBJS)
|
||||
|
||||
# Patterns - release
|
||||
|
||||
$(LIBDIR)\release\$(LIBBASENAME) : $(D_SRCS) $(C_SRCS)
|
||||
$(CC) -c $(CFLAGS_release) $(C_SRCS)
|
||||
$(DMD) $(DFLAGS_release) -lib -of$@ $(D_SRCS) $(C_OBJS)
|
||||
del $(C_OBJS)
|
||||
|
||||
# Patterns - unittest
|
||||
|
||||
$(LIBDIR)\unittest\$(LIBBASENAME) : $(D_SRCS) $(C_SRCS)
|
||||
$(CC) -c $(CFLAGS_unittest) $(C_SRCS)
|
||||
$(DMD) $(DFLAGS_unittest) -lib -of$@ $(D_SRCS) $(C_OBJS)
|
||||
del $(C_OBJS)
|
||||
|
||||
# Patterns - docs
|
||||
|
||||
$(DOCDIR)\core\bitop.html : core\bitop.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\exception.html : core\exception.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\memory.html : core\memory.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\runtime.html : core\runtime.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\thread.html : core\thread.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\vararg.html : core\vararg.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\barrier.html : core\sync\barrier.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\condition.html : core\sync\condition.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\config.html : core\sync\config.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\exception.html : core\sync\exception.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\mutex.html : core\sync\mutex.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\rwmutex.html : core\sync\rwmutex.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
$(DOCDIR)\core\sync\semaphore.html : core\sync\semaphore.d
|
||||
$(DMD) -c -d -o- -Df$@ $**
|
||||
|
||||
# Patterns - imports
|
||||
|
||||
$(IMPDIR)\core\exception.di : core\exception.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\memory.di : core\memory.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\runtime.di : core\runtime.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\thread.di : core\thread.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\vararg.di : core\vararg.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\barrier.di : core\sync\barrier.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\condition.di : core\sync\condition.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\config.di : core\sync\config.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\exception.di : core\sync\exception.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\mutex.di : core\sync\mutex.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\rwmutex.di : core\sync\rwmutex.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
$(IMPDIR)\core\sync\semaphore.di : core\sync\semaphore.d
|
||||
$(DMD) -c -d -o- -Hf$@ $**
|
||||
|
||||
# Rulez
|
||||
|
||||
all : $(BUILDS) doc
|
||||
|
||||
debug : $(LIBDIR)\debug\$(LIBBASENAME) $(IMPORTS)
|
||||
release : $(LIBDIR)\release\$(LIBBASENAME) $(IMPORTS)
|
||||
unittest : $(LIBDIR)\unittest\$(LIBBASENAME) $(IMPORTS)
|
||||
doc : $(DOCS)
|
||||
|
||||
clean :
|
||||
del $(IMPORTS) $(DOCS) $(ALLLIBS)
|
||||
386
druntime/src/compiler/dmd/aApply.d
Normal file
386
druntime/src/compiler/dmd/aApply.d
Normal file
@@ -0,0 +1,386 @@
|
||||
/**
|
||||
* This code handles decoding UTF strings for foreach loops. There are 6
|
||||
* combinations of conversions between char, wchar, and dchar, and 2 of each
|
||||
* of those.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2004 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright
|
||||
*
|
||||
* Copyright Digital Mars 2004 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.aApply;
|
||||
|
||||
private import rt.util.utf;
|
||||
|
||||
/**********************************************
|
||||
*/
|
||||
|
||||
// dg is D, but _aApplycd() is C
|
||||
extern (D) typedef int delegate(void *) dg_t;
|
||||
|
||||
extern (C) int _aApplycd1(char[] aa, dg_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplycd1(), len = %d\n", len);
|
||||
for (i = 0; i < len; )
|
||||
{ dchar d;
|
||||
|
||||
d = aa[i];
|
||||
if (d & 0x80)
|
||||
d = decode(aa, i);
|
||||
else
|
||||
i++;
|
||||
result = dg(cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplywd1(wchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplywd1(), len = %d\n", len);
|
||||
for (i = 0; i < len; )
|
||||
{ dchar d;
|
||||
|
||||
d = aa[i];
|
||||
if (d & ~0x7F)
|
||||
d = decode(aa, i);
|
||||
else
|
||||
i++;
|
||||
result = dg(cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplycw1(char[] aa, dg_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplycw1(), len = %d\n", len);
|
||||
for (i = 0; i < len; )
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
|
||||
w = aa[i];
|
||||
if (w & 0x80)
|
||||
{ d = decode(aa, i);
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
}
|
||||
else
|
||||
i++;
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplywc1(wchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplywc1(), len = %d\n", len);
|
||||
for (i = 0; i < len; )
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
char c;
|
||||
|
||||
w = aa[i];
|
||||
if (w & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
d = decode(aa, i);
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{ c = cast(char)w;
|
||||
i++;
|
||||
}
|
||||
result = dg(cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplydc1(dchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplydc1(), len = %d\n", aa.length);
|
||||
foreach (dchar d; aa)
|
||||
{
|
||||
char c;
|
||||
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
c = cast(char)d;
|
||||
}
|
||||
result = dg(cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplydw1(dchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplydw1(), len = %d\n", aa.length);
|
||||
foreach (dchar d; aa)
|
||||
{
|
||||
wchar w;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************/
|
||||
|
||||
// dg is D, but _aApplycd2() is C
|
||||
extern (D) typedef int delegate(void *, void *) dg2_t;
|
||||
|
||||
extern (C) int _aApplycd2(char[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t n;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplycd2(), len = %d\n", len);
|
||||
for (i = 0; i < len; i += n)
|
||||
{ dchar d;
|
||||
|
||||
d = aa[i];
|
||||
if (d & 0x80)
|
||||
{
|
||||
n = i;
|
||||
d = decode(aa, n);
|
||||
n -= i;
|
||||
}
|
||||
else
|
||||
n = 1;
|
||||
result = dg(&i, cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplywd2(wchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t n;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplywd2(), len = %d\n", len);
|
||||
for (i = 0; i < len; i += n)
|
||||
{ dchar d;
|
||||
|
||||
d = aa[i];
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
n = i;
|
||||
d = decode(aa, n);
|
||||
n -= i;
|
||||
}
|
||||
else
|
||||
n = 1;
|
||||
result = dg(&i, cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplycw2(char[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t n;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplycw2(), len = %d\n", len);
|
||||
for (i = 0; i < len; i += n)
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
|
||||
w = aa[i];
|
||||
if (w & 0x80)
|
||||
{ n = i;
|
||||
d = decode(aa, n);
|
||||
n -= i;
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
}
|
||||
else
|
||||
n = 1;
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplywc2(wchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t n;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplywc2(), len = %d\n", len);
|
||||
for (i = 0; i < len; i += n)
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
char c;
|
||||
|
||||
w = aa[i];
|
||||
if (w & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
n = i;
|
||||
d = decode(aa, n);
|
||||
n -= i;
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(&i, cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{ c = cast(char)w;
|
||||
n = 1;
|
||||
}
|
||||
result = dg(&i, cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplydc2(dchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplydc2(), len = %d\n", len);
|
||||
for (i = 0; i < len; i++)
|
||||
{ dchar d;
|
||||
char c;
|
||||
|
||||
d = aa[i];
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(&i, cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{ c = cast(char)d;
|
||||
}
|
||||
result = dg(&i, cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
extern (C) int _aApplydw2(dchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplydw2(), len = %d\n", aa.length);
|
||||
foreach (size_t i, dchar d; aa)
|
||||
{
|
||||
wchar w;
|
||||
auto j = i;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(&j, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
result = dg(&j, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
957
druntime/src/compiler/dmd/aApplyR.d
Normal file
957
druntime/src/compiler/dmd/aApplyR.d
Normal file
@@ -0,0 +1,957 @@
|
||||
/**
|
||||
* This code handles decoding UTF strings for foreach_reverse loops. There are
|
||||
* 6 combinations of conversions between char, wchar, and dchar, and 2 of each
|
||||
* of those.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2004 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Sean Kelly
|
||||
*
|
||||
* Copyright Digital Mars 2004 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.aApplyR;
|
||||
|
||||
/* This code handles decoding UTF strings for foreach_reverse loops.
|
||||
* There are 6 combinations of conversions between char, wchar,
|
||||
* and dchar, and 2 of each of those.
|
||||
*/
|
||||
|
||||
private import rt.util.utf;
|
||||
|
||||
/**********************************************/
|
||||
/* 1 argument versions */
|
||||
|
||||
// dg is D, but _aApplyRcd() is C
|
||||
extern (D) typedef int delegate(void *) dg_t;
|
||||
|
||||
extern (C) int _aApplyRcd1(in char[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRcd1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d & 0x80)
|
||||
{ char c = cast(char)d;
|
||||
uint j;
|
||||
uint m = 0x3F;
|
||||
d = 0;
|
||||
while ((c & 0xC0) != 0xC0)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-8 sequence", 0);
|
||||
i--;
|
||||
d |= (c & 0x3F) << j;
|
||||
j += 6;
|
||||
m >>= 1;
|
||||
c = aa[i];
|
||||
}
|
||||
d |= (c & m) << j;
|
||||
}
|
||||
result = dg(cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRcd1.unittest\n");
|
||||
|
||||
auto s = "hello"c[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(dchar d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(dchar d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == '\U00100456'); break;
|
||||
case 2: assert(d == '\u1234'); break;
|
||||
case 3: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 4);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRwd1(in wchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRwd1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d >= 0xDC00 && d <= 0xDFFF)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-16 sequence", 0);
|
||||
i--;
|
||||
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
|
||||
}
|
||||
result = dg(cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRwd1.unittest\n");
|
||||
|
||||
auto s = "hello"w[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(dchar d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(dchar d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == '\U00100456'); break;
|
||||
case 2: assert(d == '\u1234'); break;
|
||||
case 3: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 4);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRcw1(in char[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRcw1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
|
||||
i--;
|
||||
w = aa[i];
|
||||
if (w & 0x80)
|
||||
{ char c = cast(char)w;
|
||||
uint j;
|
||||
uint m = 0x3F;
|
||||
d = 0;
|
||||
while ((c & 0xC0) != 0xC0)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-8 sequence", 0);
|
||||
i--;
|
||||
d |= (c & 0x3F) << j;
|
||||
j += 6;
|
||||
m >>= 1;
|
||||
c = aa[i];
|
||||
}
|
||||
d |= (c & m) << j;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
}
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRcw1.unittest\n");
|
||||
|
||||
auto s = "hello"c[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(wchar d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(wchar d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == 0xDBC1); break;
|
||||
case 2: assert(d == 0xDC56); break;
|
||||
case 3: assert(d == 0x1234); break;
|
||||
case 4: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRwc1(in wchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRwc1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
char c;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d >= 0xDC00 && d <= 0xDFFF)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-16 sequence", 0);
|
||||
i--;
|
||||
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
|
||||
}
|
||||
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
c = cast(char)d;
|
||||
result = dg(cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRwc1.unittest\n");
|
||||
|
||||
auto s = "hello"w[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(char d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(char d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == 0xF4); break;
|
||||
case 2: assert(d == 0x80); break;
|
||||
case 3: assert(d == 0x91); break;
|
||||
case 4: assert(d == 0x96); break;
|
||||
case 5: assert(d == 0xE1); break;
|
||||
case 6: assert(d == 0x88); break;
|
||||
case 7: assert(d == 0xB4); break;
|
||||
case 8: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 9);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRdc1(in dchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRdc1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0;)
|
||||
{ dchar d = aa[--i];
|
||||
char c;
|
||||
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
c = cast(char)d;
|
||||
}
|
||||
result = dg(cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRdc1.unittest\n");
|
||||
|
||||
auto s = "hello"d[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(char d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(char d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == 0xF4); break;
|
||||
case 2: assert(d == 0x80); break;
|
||||
case 3: assert(d == 0x91); break;
|
||||
case 4: assert(d == 0x96); break;
|
||||
case 5: assert(d == 0xE1); break;
|
||||
case 6: assert(d == 0x88); break;
|
||||
case 7: assert(d == 0xB4); break;
|
||||
case 8: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 9);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRdw1(in dchar[] aa, dg_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRdw1(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d = aa[--i];
|
||||
wchar w;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
result = dg(cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRdw1.unittest\n");
|
||||
|
||||
auto s = "hello"d[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(wchar d; s)
|
||||
{
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(wchar d; s)
|
||||
{
|
||||
//printf("i = %d, d = %x\n", i, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); break;
|
||||
case 1: assert(d == 0xDBC1); break;
|
||||
case 2: assert(d == 0xDC56); break;
|
||||
case 3: assert(d == 0x1234); break;
|
||||
case 4: assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************/
|
||||
/* 2 argument versions */
|
||||
|
||||
// dg is D, but _aApplyRcd2() is C
|
||||
extern (D) typedef int delegate(void *, void *) dg2_t;
|
||||
|
||||
extern (C) int _aApplyRcd2(in char[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
size_t i;
|
||||
size_t len = aa.length;
|
||||
|
||||
debug(apply) printf("_aApplyRcd2(), len = %d\n", len);
|
||||
for (i = len; i != 0; )
|
||||
{ dchar d;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d & 0x80)
|
||||
{ char c = cast(char)d;
|
||||
uint j;
|
||||
uint m = 0x3F;
|
||||
d = 0;
|
||||
while ((c & 0xC0) != 0xC0)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-8 sequence", 0);
|
||||
i--;
|
||||
d |= (c & 0x3F) << j;
|
||||
j += 6;
|
||||
m >>= 1;
|
||||
c = aa[i];
|
||||
}
|
||||
d |= (c & m) << j;
|
||||
}
|
||||
result = dg(&i, cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRcd2.unittest\n");
|
||||
|
||||
auto s = "hello"c[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, dchar d; s)
|
||||
{
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, dchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'b'); assert(k == 8); break;
|
||||
case 1: assert(d == '\U00100456'); assert(k == 4); break;
|
||||
case 2: assert(d == '\u1234'); assert(k == 1); break;
|
||||
case 3: assert(d == 'a'); assert(k == 0); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 4);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRwd2(in wchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRwd2(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d >= 0xDC00 && d <= 0xDFFF)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-16 sequence", 0);
|
||||
i--;
|
||||
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
|
||||
}
|
||||
result = dg(&i, cast(void *)&d);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRwd2.unittest\n");
|
||||
|
||||
auto s = "hello"w[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, dchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, dchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(k == 4); assert(d == 'b'); break;
|
||||
case 1: assert(k == 2); assert(d == '\U00100456'); break;
|
||||
case 2: assert(k == 1); assert(d == '\u1234'); break;
|
||||
case 3: assert(k == 0); assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 4);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRcw2(in char[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRcw2(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
wchar w;
|
||||
|
||||
i--;
|
||||
w = aa[i];
|
||||
if (w & 0x80)
|
||||
{ char c = cast(char)w;
|
||||
uint j;
|
||||
uint m = 0x3F;
|
||||
d = 0;
|
||||
while ((c & 0xC0) != 0xC0)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-8 sequence", 0);
|
||||
i--;
|
||||
d |= (c & 0x3F) << j;
|
||||
j += 6;
|
||||
m >>= 1;
|
||||
c = aa[i];
|
||||
}
|
||||
d |= (c & m) << j;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
}
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRcw2.unittest\n");
|
||||
|
||||
auto s = "hello"c[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, wchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, wchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(k == 8); assert(d == 'b'); break;
|
||||
case 1: assert(k == 4); assert(d == 0xDBC1); break;
|
||||
case 2: assert(k == 4); assert(d == 0xDC56); break;
|
||||
case 3: assert(k == 1); assert(d == 0x1234); break;
|
||||
case 4: assert(k == 0); assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRwc2(in wchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRwc2(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d;
|
||||
char c;
|
||||
|
||||
i--;
|
||||
d = aa[i];
|
||||
if (d >= 0xDC00 && d <= 0xDFFF)
|
||||
{ if (i == 0)
|
||||
onUnicodeError("Invalid UTF-16 sequence", 0);
|
||||
i--;
|
||||
d = ((aa[i] - 0xD7C0) << 10) + (d - 0xDC00);
|
||||
}
|
||||
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(&i, cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
c = cast(char)d;
|
||||
result = dg(&i, cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRwc2.unittest\n");
|
||||
|
||||
auto s = "hello"w[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, char d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, char d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(k == 4); assert(d == 'b'); break;
|
||||
case 1: assert(k == 2); assert(d == 0xF4); break;
|
||||
case 2: assert(k == 2); assert(d == 0x80); break;
|
||||
case 3: assert(k == 2); assert(d == 0x91); break;
|
||||
case 4: assert(k == 2); assert(d == 0x96); break;
|
||||
case 5: assert(k == 1); assert(d == 0xE1); break;
|
||||
case 6: assert(k == 1); assert(d == 0x88); break;
|
||||
case 7: assert(k == 1); assert(d == 0xB4); break;
|
||||
case 8: assert(k == 0); assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 9);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRdc2(in dchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRdc2(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d = aa[--i];
|
||||
char c;
|
||||
|
||||
if (d & ~0x7F)
|
||||
{
|
||||
char[4] buf;
|
||||
|
||||
auto b = toUTF8(buf, d);
|
||||
foreach (char c2; b)
|
||||
{
|
||||
result = dg(&i, cast(void *)&c2);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{ c = cast(char)d;
|
||||
}
|
||||
result = dg(&i, cast(void *)&c);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRdc2.unittest\n");
|
||||
|
||||
auto s = "hello"d[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, char d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, char d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(k == 3); assert(d == 'b'); break;
|
||||
case 1: assert(k == 2); assert(d == 0xF4); break;
|
||||
case 2: assert(k == 2); assert(d == 0x80); break;
|
||||
case 3: assert(k == 2); assert(d == 0x91); break;
|
||||
case 4: assert(k == 2); assert(d == 0x96); break;
|
||||
case 5: assert(k == 1); assert(d == 0xE1); break;
|
||||
case 6: assert(k == 1); assert(d == 0x88); break;
|
||||
case 7: assert(k == 1); assert(d == 0xB4); break;
|
||||
case 8: assert(k == 0); assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 9);
|
||||
}
|
||||
|
||||
/*****************************/
|
||||
|
||||
extern (C) int _aApplyRdw2(in dchar[] aa, dg2_t dg)
|
||||
{ int result;
|
||||
|
||||
debug(apply) printf("_aApplyRdw2(), len = %d\n", aa.length);
|
||||
for (size_t i = aa.length; i != 0; )
|
||||
{ dchar d = aa[--i];
|
||||
wchar w;
|
||||
|
||||
if (d <= 0xFFFF)
|
||||
w = cast(wchar) d;
|
||||
else
|
||||
{
|
||||
w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
|
||||
}
|
||||
result = dg(&i, cast(void *)&w);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(apply) printf("_aApplyRdw2.unittest\n");
|
||||
|
||||
auto s = "hello"d[];
|
||||
int i;
|
||||
|
||||
foreach_reverse(k, wchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
assert(k == 4 - i);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(d == 'o'); break;
|
||||
case 1: assert(d == 'l'); break;
|
||||
case 2: assert(d == 'l'); break;
|
||||
case 3: assert(d == 'e'); break;
|
||||
case 4: assert(d == 'h'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
|
||||
s = "a\u1234\U00100456b";
|
||||
i = 0;
|
||||
foreach_reverse(k, wchar d; s)
|
||||
{
|
||||
//printf("i = %d, k = %d, d = %x\n", i, k, d);
|
||||
switch (i)
|
||||
{
|
||||
case 0: assert(k == 3); assert(d == 'b'); break;
|
||||
case 1: assert(k == 2); assert(d == 0xDBC1); break;
|
||||
case 2: assert(k == 2); assert(d == 0xDC56); break;
|
||||
case 3: assert(k == 1); assert(d == 0x1234); break;
|
||||
case 4: assert(k == 0); assert(d == 'a'); break;
|
||||
default: assert(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
assert(i == 5);
|
||||
}
|
||||
872
druntime/src/compiler/dmd/aaA.d
Normal file
872
druntime/src/compiler/dmd/aaA.d
Normal file
@@ -0,0 +1,872 @@
|
||||
/**
|
||||
* Implementation of associative arrays.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2000 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Sean Kelly
|
||||
*
|
||||
* Copyright Digital Mars 2000 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.aaA;
|
||||
|
||||
private
|
||||
{
|
||||
import core.stdc.stdarg;
|
||||
import core.stdc.string;
|
||||
import core.stdc.stdio;
|
||||
|
||||
enum BlkAttr : uint
|
||||
{
|
||||
FINALIZE = 0b0000_0001,
|
||||
NO_SCAN = 0b0000_0010,
|
||||
NO_MOVE = 0b0000_0100,
|
||||
ALL_BITS = 0b1111_1111
|
||||
}
|
||||
|
||||
extern (C) void* gc_malloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void* gc_calloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void gc_free( void* p );
|
||||
}
|
||||
|
||||
// Auto-rehash and pre-allocate - Dave Fladebo
|
||||
|
||||
immutable size_t[] prime_list = [
|
||||
97UL, 389UL,
|
||||
1_543UL, 6_151UL,
|
||||
24_593UL, 98_317UL,
|
||||
393_241UL, 1_572_869UL,
|
||||
6_291_469UL, 25_165_843UL,
|
||||
100_663_319UL, 402_653_189UL,
|
||||
1_610_612_741UL, 4_294_967_291UL,
|
||||
// 8_589_934_513UL, 17_179_869_143UL
|
||||
];
|
||||
|
||||
/* This is the type of the return value for dynamic arrays.
|
||||
* It should be a type that is returned in registers.
|
||||
* Although DMD will return types of Array in registers,
|
||||
* gcc will not, so we instead use a 'long'.
|
||||
*/
|
||||
alias long ArrayRet_t;
|
||||
|
||||
struct Array
|
||||
{
|
||||
size_t length;
|
||||
void* ptr;
|
||||
}
|
||||
|
||||
struct aaA
|
||||
{
|
||||
aaA *left;
|
||||
aaA *right;
|
||||
hash_t hash;
|
||||
/* key */
|
||||
/* value */
|
||||
}
|
||||
|
||||
struct BB
|
||||
{
|
||||
aaA*[] b;
|
||||
size_t nodes; // total number of aaA nodes
|
||||
TypeInfo keyti; // TODO: replace this with TypeInfo_AssociativeArray when available in _aaGet()
|
||||
}
|
||||
|
||||
/* This is the type actually seen by the programmer, although
|
||||
* it is completely opaque.
|
||||
*/
|
||||
|
||||
struct AA
|
||||
{
|
||||
BB* a;
|
||||
}
|
||||
|
||||
/**********************************
|
||||
* Align to next pointer boundary, so that
|
||||
* GC won't be faced with misaligned pointers
|
||||
* in value.
|
||||
*/
|
||||
|
||||
size_t aligntsize(size_t tsize)
|
||||
{
|
||||
// Is pointer alignment on the x64 4 bytes or 8?
|
||||
return (tsize + size_t.sizeof - 1) & ~(size_t.sizeof - 1);
|
||||
}
|
||||
|
||||
extern (C):
|
||||
|
||||
/*************************************************
|
||||
* Invariant for aa.
|
||||
*/
|
||||
|
||||
/+
|
||||
void _aaInvAh(aaA*[] aa)
|
||||
{
|
||||
for (size_t i = 0; i < aa.length; i++)
|
||||
{
|
||||
if (aa[i])
|
||||
_aaInvAh_x(aa[i]);
|
||||
}
|
||||
}
|
||||
|
||||
private int _aaCmpAh_x(aaA *e1, aaA *e2)
|
||||
{ int c;
|
||||
|
||||
c = e1.hash - e2.hash;
|
||||
if (c == 0)
|
||||
{
|
||||
c = e1.key.length - e2.key.length;
|
||||
if (c == 0)
|
||||
c = memcmp((char *)e1.key, (char *)e2.key, e1.key.length);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
private void _aaInvAh_x(aaA *e)
|
||||
{
|
||||
hash_t key_hash;
|
||||
aaA *e1;
|
||||
aaA *e2;
|
||||
|
||||
key_hash = getHash(e.key);
|
||||
assert(key_hash == e.hash);
|
||||
|
||||
while (1)
|
||||
{ int c;
|
||||
|
||||
e1 = e.left;
|
||||
if (e1)
|
||||
{
|
||||
_aaInvAh_x(e1); // ordinary recursion
|
||||
do
|
||||
{
|
||||
c = _aaCmpAh_x(e1, e);
|
||||
assert(c < 0);
|
||||
e1 = e1.right;
|
||||
} while (e1 != null);
|
||||
}
|
||||
|
||||
e2 = e.right;
|
||||
if (e2)
|
||||
{
|
||||
do
|
||||
{
|
||||
c = _aaCmpAh_x(e, e2);
|
||||
assert(c < 0);
|
||||
e2 = e2.left;
|
||||
} while (e2 != null);
|
||||
e = e.right; // tail recursion
|
||||
}
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
+/
|
||||
|
||||
/****************************************************
|
||||
* Determine number of entries in associative array.
|
||||
*/
|
||||
|
||||
size_t _aaLen(AA aa)
|
||||
in
|
||||
{
|
||||
//printf("_aaLen()+\n");
|
||||
//_aaInv(aa);
|
||||
}
|
||||
out (result)
|
||||
{
|
||||
size_t len = 0;
|
||||
|
||||
void _aaLen_x(aaA* ex)
|
||||
{
|
||||
auto e = ex;
|
||||
len++;
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (e.right)
|
||||
_aaLen_x(e.right);
|
||||
e = e.left;
|
||||
if (!e)
|
||||
break;
|
||||
len++;
|
||||
}
|
||||
}
|
||||
|
||||
if (aa.a)
|
||||
{
|
||||
foreach (e; aa.a.b)
|
||||
{
|
||||
if (e)
|
||||
_aaLen_x(e);
|
||||
}
|
||||
}
|
||||
assert(len == result);
|
||||
|
||||
//printf("_aaLen()-\n");
|
||||
}
|
||||
body
|
||||
{
|
||||
return aa.a ? aa.a.nodes : 0;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Get pointer to value in associative array indexed by key.
|
||||
* Add entry for key if it is not already there.
|
||||
*/
|
||||
|
||||
void* _aaGet(AA* aa, TypeInfo keyti, size_t valuesize, ...)
|
||||
in
|
||||
{
|
||||
assert(aa);
|
||||
}
|
||||
out (result)
|
||||
{
|
||||
assert(result);
|
||||
assert(aa.a);
|
||||
assert(aa.a.b.length);
|
||||
//assert(_aaInAh(*aa.a, key));
|
||||
}
|
||||
body
|
||||
{
|
||||
auto pkey = cast(void *)(&valuesize + 1);
|
||||
size_t i;
|
||||
aaA *e;
|
||||
//printf("keyti = %p\n", keyti);
|
||||
//printf("aa = %p\n", aa);
|
||||
auto keysize = aligntsize(keyti.tsize());
|
||||
|
||||
if (!aa.a)
|
||||
aa.a = new BB();
|
||||
//printf("aa = %p\n", aa);
|
||||
//printf("aa.a = %p\n", aa.a);
|
||||
aa.a.keyti = keyti;
|
||||
|
||||
if (!aa.a.b.length)
|
||||
{
|
||||
alias aaA *pa;
|
||||
auto len = prime_list[0];
|
||||
|
||||
aa.a.b = new pa[len];
|
||||
}
|
||||
|
||||
auto key_hash = keyti.getHash(pkey);
|
||||
//printf("hash = %d\n", key_hash);
|
||||
i = key_hash % aa.a.b.length;
|
||||
auto pe = &aa.a.b[i];
|
||||
while ((e = *pe) !is null)
|
||||
{
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(pkey, e + 1);
|
||||
if (c == 0)
|
||||
goto Lret;
|
||||
pe = (c < 0) ? &e.left : &e.right;
|
||||
}
|
||||
else
|
||||
pe = (key_hash < e.hash) ? &e.left : &e.right;
|
||||
}
|
||||
|
||||
// Not found, create new elem
|
||||
//printf("create new one\n");
|
||||
size_t size = aaA.sizeof + keysize + valuesize;
|
||||
e = cast(aaA *) gc_calloc(size);
|
||||
memcpy(e + 1, pkey, keysize);
|
||||
e.hash = key_hash;
|
||||
*pe = e;
|
||||
|
||||
auto nodes = ++aa.a.nodes;
|
||||
//printf("length = %d, nodes = %d\n", aa.a.b.length, nodes);
|
||||
if (nodes > aa.a.b.length * 4)
|
||||
{
|
||||
//printf("rehash\n");
|
||||
_aaRehash(aa,keyti);
|
||||
}
|
||||
|
||||
Lret:
|
||||
return cast(void *)(e + 1) + keysize;
|
||||
}
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Get pointer to value in associative array indexed by key.
|
||||
* Returns null if it is not already there.
|
||||
*/
|
||||
|
||||
void* _aaGetRvalue(AA aa, TypeInfo keyti, size_t valuesize, ...)
|
||||
{
|
||||
//printf("_aaGetRvalue(valuesize = %u)\n", valuesize);
|
||||
if (!aa.a)
|
||||
return null;
|
||||
|
||||
auto pkey = cast(void *)(&valuesize + 1);
|
||||
auto keysize = aligntsize(keyti.tsize());
|
||||
auto len = aa.a.b.length;
|
||||
|
||||
if (len)
|
||||
{
|
||||
auto key_hash = keyti.getHash(pkey);
|
||||
//printf("hash = %d\n", key_hash);
|
||||
size_t i = key_hash % len;
|
||||
auto e = aa.a.b[i];
|
||||
while (e !is null)
|
||||
{
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(pkey, e + 1);
|
||||
if (c == 0)
|
||||
return cast(void *)(e + 1) + keysize;
|
||||
e = (c < 0) ? e.left : e.right;
|
||||
}
|
||||
else
|
||||
e = (key_hash < e.hash) ? e.left : e.right;
|
||||
}
|
||||
}
|
||||
return null; // not found, caller will throw exception
|
||||
}
|
||||
|
||||
|
||||
/*************************************************
|
||||
* Determine if key is in aa.
|
||||
* Returns:
|
||||
* null not in aa
|
||||
* !=null in aa, return pointer to value
|
||||
*/
|
||||
|
||||
void* _aaIn(AA aa, TypeInfo keyti, ...)
|
||||
in
|
||||
{
|
||||
}
|
||||
out (result)
|
||||
{
|
||||
//assert(result == 0 || result == 1);
|
||||
}
|
||||
body
|
||||
{
|
||||
if (aa.a)
|
||||
{
|
||||
auto pkey = cast(void *)(&keyti + 1);
|
||||
|
||||
//printf("_aaIn(), .length = %d, .ptr = %x\n", aa.a.length, cast(uint)aa.a.ptr);
|
||||
auto len = aa.a.b.length;
|
||||
|
||||
if (len)
|
||||
{
|
||||
auto key_hash = keyti.getHash(pkey);
|
||||
//printf("hash = %d\n", key_hash);
|
||||
size_t i = key_hash % len;
|
||||
auto e = aa.a.b[i];
|
||||
while (e !is null)
|
||||
{
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(pkey, e + 1);
|
||||
if (c == 0)
|
||||
return cast(void *)(e + 1) + aligntsize(keyti.tsize());
|
||||
e = (c < 0) ? e.left : e.right;
|
||||
}
|
||||
else
|
||||
e = (key_hash < e.hash) ? e.left : e.right;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Not found
|
||||
return null;
|
||||
}
|
||||
|
||||
/*************************************************
|
||||
* Delete key entry in aa[].
|
||||
* If key is not in aa[], do nothing.
|
||||
*/
|
||||
|
||||
void _aaDel(AA aa, TypeInfo keyti, ...)
|
||||
{
|
||||
auto pkey = cast(void *)(&keyti + 1);
|
||||
aaA *e;
|
||||
|
||||
if (aa.a && aa.a.b.length)
|
||||
{
|
||||
auto key_hash = keyti.getHash(pkey);
|
||||
//printf("hash = %d\n", key_hash);
|
||||
size_t i = key_hash % aa.a.b.length;
|
||||
auto pe = &aa.a.b[i];
|
||||
while ((e = *pe) !is null) // null means not found
|
||||
{
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(pkey, e + 1);
|
||||
if (c == 0)
|
||||
{
|
||||
if (!e.left && !e.right)
|
||||
{
|
||||
*pe = null;
|
||||
}
|
||||
else if (e.left && !e.right)
|
||||
{
|
||||
*pe = e.left;
|
||||
e.left = null;
|
||||
}
|
||||
else if (!e.left && e.right)
|
||||
{
|
||||
*pe = e.right;
|
||||
e.right = null;
|
||||
}
|
||||
else
|
||||
{
|
||||
*pe = e.left;
|
||||
e.left = null;
|
||||
do
|
||||
pe = &(*pe).right;
|
||||
while (*pe);
|
||||
*pe = e.right;
|
||||
e.right = null;
|
||||
}
|
||||
|
||||
aa.a.nodes--;
|
||||
gc_free(e);
|
||||
break;
|
||||
}
|
||||
pe = (c < 0) ? &e.left : &e.right;
|
||||
}
|
||||
else
|
||||
pe = (key_hash < e.hash) ? &e.left : &e.right;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/********************************************
|
||||
* Produce array of values from aa.
|
||||
*/
|
||||
|
||||
ArrayRet_t _aaValues(AA aa, size_t keysize, size_t valuesize)
|
||||
in
|
||||
{
|
||||
assert(keysize == aligntsize(keysize));
|
||||
}
|
||||
body
|
||||
{
|
||||
size_t resi;
|
||||
Array a;
|
||||
|
||||
void _aaValues_x(aaA* e)
|
||||
{
|
||||
do
|
||||
{
|
||||
memcpy(a.ptr + resi * valuesize,
|
||||
cast(byte*)e + aaA.sizeof + keysize,
|
||||
valuesize);
|
||||
resi++;
|
||||
if (e.left)
|
||||
{ if (!e.right)
|
||||
{ e = e.left;
|
||||
continue;
|
||||
}
|
||||
_aaValues_x(e.left);
|
||||
}
|
||||
e = e.right;
|
||||
} while (e !is null);
|
||||
}
|
||||
|
||||
if (aa.a)
|
||||
{
|
||||
a.length = _aaLen(aa);
|
||||
a.ptr = cast(byte*) gc_malloc(a.length * valuesize,
|
||||
valuesize < (void*).sizeof ? BlkAttr.NO_SCAN : 0);
|
||||
resi = 0;
|
||||
foreach (e; aa.a.b)
|
||||
{
|
||||
if (e)
|
||||
_aaValues_x(e);
|
||||
}
|
||||
assert(resi == a.length);
|
||||
}
|
||||
return *cast(ArrayRet_t*)(&a);
|
||||
}
|
||||
|
||||
|
||||
/********************************************
|
||||
* Rehash an array.
|
||||
*/
|
||||
|
||||
void* _aaRehash(AA* paa, TypeInfo keyti)
|
||||
in
|
||||
{
|
||||
//_aaInvAh(paa);
|
||||
}
|
||||
out (result)
|
||||
{
|
||||
//_aaInvAh(result);
|
||||
}
|
||||
body
|
||||
{
|
||||
BB newb;
|
||||
|
||||
void _aaRehash_x(aaA* olde)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
auto left = olde.left;
|
||||
auto right = olde.right;
|
||||
olde.left = null;
|
||||
olde.right = null;
|
||||
|
||||
aaA *e;
|
||||
|
||||
//printf("rehash %p\n", olde);
|
||||
auto key_hash = olde.hash;
|
||||
size_t i = key_hash % newb.b.length;
|
||||
auto pe = &newb.b[i];
|
||||
while ((e = *pe) !is null)
|
||||
{
|
||||
//printf("\te = %p, e.left = %p, e.right = %p\n", e, e.left, e.right);
|
||||
assert(e.left != e);
|
||||
assert(e.right != e);
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(olde + 1, e + 1);
|
||||
assert(c != 0);
|
||||
pe = (c < 0) ? &e.left : &e.right;
|
||||
}
|
||||
else
|
||||
pe = (key_hash < e.hash) ? &e.left : &e.right;
|
||||
}
|
||||
*pe = olde;
|
||||
|
||||
if (right)
|
||||
{
|
||||
if (!left)
|
||||
{ olde = right;
|
||||
continue;
|
||||
}
|
||||
_aaRehash_x(right);
|
||||
}
|
||||
if (!left)
|
||||
break;
|
||||
olde = left;
|
||||
}
|
||||
}
|
||||
|
||||
//printf("Rehash\n");
|
||||
if (paa.a)
|
||||
{
|
||||
auto aa = paa.a;
|
||||
auto len = _aaLen(*paa);
|
||||
if (len)
|
||||
{ size_t i;
|
||||
|
||||
for (i = 0; i < prime_list.length - 1; i++)
|
||||
{
|
||||
if (len <= prime_list[i])
|
||||
break;
|
||||
}
|
||||
len = prime_list[i];
|
||||
newb.b = new aaA*[len];
|
||||
|
||||
foreach (e; aa.b)
|
||||
{
|
||||
if (e)
|
||||
_aaRehash_x(e);
|
||||
}
|
||||
delete aa.b;
|
||||
|
||||
newb.nodes = aa.nodes;
|
||||
newb.keyti = aa.keyti;
|
||||
}
|
||||
|
||||
*paa.a = newb;
|
||||
_aaBalance(paa);
|
||||
}
|
||||
return (*paa).a;
|
||||
}
|
||||
|
||||
/********************************************
|
||||
* Balance an array.
|
||||
*/
|
||||
|
||||
void _aaBalance(AA* paa)
|
||||
{
|
||||
//printf("_aaBalance()\n");
|
||||
if (paa.a)
|
||||
{
|
||||
aaA*[16] tmp;
|
||||
aaA*[] array = tmp;
|
||||
auto aa = paa.a;
|
||||
foreach (j, e; aa.b)
|
||||
{
|
||||
/* Temporarily store contents of bucket in array[]
|
||||
*/
|
||||
size_t k = 0;
|
||||
void addToArray(aaA* e)
|
||||
{
|
||||
while (e)
|
||||
{ addToArray(e.left);
|
||||
if (k == array.length)
|
||||
array.length = array.length * 2;
|
||||
array[k++] = e;
|
||||
e = e.right;
|
||||
}
|
||||
}
|
||||
addToArray(e);
|
||||
/* The contents of the bucket are now sorted into array[].
|
||||
* Rebuild the tree.
|
||||
*/
|
||||
void buildTree(aaA** p, size_t x1, size_t x2)
|
||||
{
|
||||
if (x1 >= x2)
|
||||
*p = null;
|
||||
else
|
||||
{ auto mid = (x1 + x2) >> 1;
|
||||
*p = array[mid];
|
||||
buildTree(&(*p).left, x1, mid);
|
||||
buildTree(&(*p).right, mid + 1, x2);
|
||||
}
|
||||
}
|
||||
auto p = &aa.b[j];
|
||||
buildTree(p, 0, k);
|
||||
}
|
||||
}
|
||||
}
|
||||
/********************************************
|
||||
* Produce array of N byte keys from aa.
|
||||
*/
|
||||
|
||||
ArrayRet_t _aaKeys(AA aa, size_t keysize)
|
||||
{
|
||||
byte[] res;
|
||||
size_t resi;
|
||||
|
||||
void _aaKeys_x(aaA* e)
|
||||
{
|
||||
do
|
||||
{
|
||||
memcpy(&res[resi * keysize], cast(byte*)(e + 1), keysize);
|
||||
resi++;
|
||||
if (e.left)
|
||||
{ if (!e.right)
|
||||
{ e = e.left;
|
||||
continue;
|
||||
}
|
||||
_aaKeys_x(e.left);
|
||||
}
|
||||
e = e.right;
|
||||
} while (e !is null);
|
||||
}
|
||||
|
||||
auto len = _aaLen(aa);
|
||||
if (!len)
|
||||
return 0;
|
||||
res = (cast(byte*) gc_malloc(len * keysize,
|
||||
!(aa.a.keyti.flags() & 1) ? BlkAttr.NO_SCAN : 0))[0 .. len * keysize];
|
||||
resi = 0;
|
||||
foreach (e; aa.a.b)
|
||||
{
|
||||
if (e)
|
||||
_aaKeys_x(e);
|
||||
}
|
||||
assert(resi == len);
|
||||
|
||||
Array a;
|
||||
a.length = len;
|
||||
a.ptr = res.ptr;
|
||||
return *cast(ArrayRet_t*)(&a);
|
||||
}
|
||||
|
||||
|
||||
/**********************************************
|
||||
* 'apply' for associative arrays - to support foreach
|
||||
*/
|
||||
|
||||
// dg is D, but _aaApply() is C
|
||||
extern (D) typedef int delegate(void *) dg_t;
|
||||
|
||||
int _aaApply(AA aa, size_t keysize, dg_t dg)
|
||||
in
|
||||
{
|
||||
assert(aligntsize(keysize) == keysize);
|
||||
}
|
||||
body
|
||||
{ int result;
|
||||
|
||||
//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
|
||||
|
||||
int treewalker(aaA* e)
|
||||
{ int result;
|
||||
|
||||
do
|
||||
{
|
||||
//printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
|
||||
result = dg(cast(void *)(e + 1) + keysize);
|
||||
if (result)
|
||||
break;
|
||||
if (e.right)
|
||||
{ if (!e.left)
|
||||
{
|
||||
e = e.right;
|
||||
continue;
|
||||
}
|
||||
result = treewalker(e.right);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
e = e.left;
|
||||
} while (e);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
if (aa.a)
|
||||
{
|
||||
foreach (e; aa.a.b)
|
||||
{
|
||||
if (e)
|
||||
{
|
||||
result = treewalker(e);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// dg is D, but _aaApply2() is C
|
||||
extern (D) typedef int delegate(void *, void *) dg2_t;
|
||||
|
||||
int _aaApply2(AA aa, size_t keysize, dg2_t dg)
|
||||
in
|
||||
{
|
||||
assert(aligntsize(keysize) == keysize);
|
||||
}
|
||||
body
|
||||
{ int result;
|
||||
|
||||
//printf("_aaApply(aa = x%llx, keysize = %d, dg = x%llx)\n", aa.a, keysize, dg);
|
||||
|
||||
int treewalker(aaA* e)
|
||||
{ int result;
|
||||
|
||||
do
|
||||
{
|
||||
//printf("treewalker(e = %p, dg = x%llx)\n", e, dg);
|
||||
result = dg(cast(void *)(e + 1), cast(void *)(e + 1) + keysize);
|
||||
if (result)
|
||||
break;
|
||||
if (e.right)
|
||||
{ if (!e.left)
|
||||
{
|
||||
e = e.right;
|
||||
continue;
|
||||
}
|
||||
result = treewalker(e.right);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
e = e.left;
|
||||
} while (e);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
if (aa.a)
|
||||
{
|
||||
foreach (e; aa.a.b)
|
||||
{
|
||||
if (e)
|
||||
{
|
||||
result = treewalker(e);
|
||||
if (result)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/***********************************
|
||||
* Construct an associative array of type ti from
|
||||
* length pairs of key/value pairs.
|
||||
*/
|
||||
|
||||
extern (C)
|
||||
BB* _d_assocarrayliteralT(TypeInfo_AssociativeArray ti, size_t length, ...)
|
||||
{
|
||||
auto valuesize = ti.next.tsize(); // value size
|
||||
auto keyti = ti.key;
|
||||
auto keysize = keyti.tsize(); // key size
|
||||
BB* result;
|
||||
|
||||
//printf("_d_assocarrayliteralT(keysize = %d, valuesize = %d, length = %d)\n", keysize, valuesize, length);
|
||||
//printf("tivalue = %.*s\n", ti.next.classinfo.name);
|
||||
if (length == 0 || valuesize == 0 || keysize == 0)
|
||||
{
|
||||
;
|
||||
}
|
||||
else
|
||||
{
|
||||
va_list q;
|
||||
va_start!(size_t)(q, length);
|
||||
|
||||
result = new BB();
|
||||
result.keyti = keyti;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < prime_list.length - 1; i++)
|
||||
{
|
||||
if (length <= prime_list[i])
|
||||
break;
|
||||
}
|
||||
auto len = prime_list[i];
|
||||
result.b = new aaA*[len];
|
||||
|
||||
size_t keystacksize = (keysize + int.sizeof - 1) & ~(int.sizeof - 1);
|
||||
size_t valuestacksize = (valuesize + int.sizeof - 1) & ~(int.sizeof - 1);
|
||||
|
||||
size_t keytsize = aligntsize(keysize);
|
||||
|
||||
for (size_t j = 0; j < length; j++)
|
||||
{ void* pkey = q;
|
||||
q += keystacksize;
|
||||
void* pvalue = q;
|
||||
q += valuestacksize;
|
||||
aaA* e;
|
||||
|
||||
auto key_hash = keyti.getHash(pkey);
|
||||
//printf("hash = %d\n", key_hash);
|
||||
i = key_hash % len;
|
||||
auto pe = &result.b[i];
|
||||
while (1)
|
||||
{
|
||||
e = *pe;
|
||||
if (!e)
|
||||
{
|
||||
// Not found, create new elem
|
||||
//printf("create new one\n");
|
||||
e = cast(aaA *) cast(void*) new void[aaA.sizeof + keytsize + valuesize];
|
||||
memcpy(e + 1, pkey, keysize);
|
||||
e.hash = key_hash;
|
||||
*pe = e;
|
||||
result.nodes++;
|
||||
break;
|
||||
}
|
||||
if (key_hash == e.hash)
|
||||
{
|
||||
auto c = keyti.compare(pkey, e + 1);
|
||||
if (c == 0)
|
||||
break;
|
||||
pe = (c < 0) ? &e.left : &e.right;
|
||||
}
|
||||
else
|
||||
pe = (key_hash < e.hash) ? &e.left : &e.right;
|
||||
}
|
||||
memcpy(cast(void *)(e + 1) + keytsize, pvalue, valuesize);
|
||||
}
|
||||
|
||||
va_end(q);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
603
druntime/src/compiler/dmd/adi.d
Normal file
603
druntime/src/compiler/dmd/adi.d
Normal file
@@ -0,0 +1,603 @@
|
||||
/**
|
||||
* Implementation of dynamic array property support routines.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2000 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright
|
||||
*
|
||||
* Copyright Digital Mars 2000 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.adi;
|
||||
|
||||
//debug=adi; // uncomment to turn on debugging printf's
|
||||
|
||||
private
|
||||
{
|
||||
debug(adi) import core.stdc.stdio;
|
||||
import core.stdc.string;
|
||||
import core.stdc.stdlib;
|
||||
import rt.util.utf;
|
||||
|
||||
enum BlkAttr : uint
|
||||
{
|
||||
FINALIZE = 0b0000_0001,
|
||||
NO_SCAN = 0b0000_0010,
|
||||
NO_MOVE = 0b0000_0100,
|
||||
ALL_BITS = 0b1111_1111
|
||||
}
|
||||
|
||||
extern (C) void* gc_malloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void* gc_calloc( size_t sz, uint ba = 0 );
|
||||
extern (C) void gc_free( void* p );
|
||||
}
|
||||
|
||||
|
||||
struct Array
|
||||
{
|
||||
size_t length;
|
||||
void* ptr;
|
||||
}
|
||||
|
||||
/**********************************************
|
||||
* Reverse array of chars.
|
||||
* Handled separately because embedded multibyte encodings should not be
|
||||
* reversed.
|
||||
*/
|
||||
|
||||
extern (C) long _adReverseChar(char[] a)
|
||||
{
|
||||
if (a.length > 1)
|
||||
{
|
||||
char[6] tmp;
|
||||
char[6] tmplo;
|
||||
char* lo = a.ptr;
|
||||
char* hi = &a[length - 1];
|
||||
|
||||
while (lo < hi)
|
||||
{ auto clo = *lo;
|
||||
auto chi = *hi;
|
||||
|
||||
debug(adi) printf("lo = %d, hi = %d\n", lo, hi);
|
||||
if (clo <= 0x7F && chi <= 0x7F)
|
||||
{
|
||||
debug(adi) printf("\tascii\n");
|
||||
*lo = chi;
|
||||
*hi = clo;
|
||||
lo++;
|
||||
hi--;
|
||||
continue;
|
||||
}
|
||||
|
||||
uint stridelo = UTF8stride[clo];
|
||||
|
||||
uint stridehi = 1;
|
||||
while ((chi & 0xC0) == 0x80)
|
||||
{
|
||||
chi = *--hi;
|
||||
stridehi++;
|
||||
assert(hi >= lo);
|
||||
}
|
||||
if (lo == hi)
|
||||
break;
|
||||
|
||||
debug(adi) printf("\tstridelo = %d, stridehi = %d\n", stridelo, stridehi);
|
||||
if (stridelo == stridehi)
|
||||
{
|
||||
|
||||
memcpy(tmp.ptr, lo, stridelo);
|
||||
memcpy(lo, hi, stridelo);
|
||||
memcpy(hi, tmp.ptr, stridelo);
|
||||
lo += stridelo;
|
||||
hi--;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Shift the whole array. This is woefully inefficient
|
||||
*/
|
||||
memcpy(tmp.ptr, hi, stridehi);
|
||||
memcpy(tmplo.ptr, lo, stridelo);
|
||||
memmove(lo + stridehi, lo + stridelo , (hi - lo) - stridelo);
|
||||
memcpy(lo, tmp.ptr, stridehi);
|
||||
memcpy(hi + stridehi - stridelo, tmplo.ptr, stridelo);
|
||||
|
||||
lo += stridehi;
|
||||
hi = hi - 1 + (stridehi - stridelo);
|
||||
}
|
||||
}
|
||||
return *cast(long*)(&a);
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
auto a = "abcd"c[];
|
||||
|
||||
auto r = a.dup.reverse;
|
||||
//writefln(r);
|
||||
assert(r == "dcba");
|
||||
|
||||
a = "a\u1235\u1234c";
|
||||
//writefln(a);
|
||||
r = a.dup.reverse;
|
||||
//writefln(r);
|
||||
assert(r == "c\u1234\u1235a");
|
||||
|
||||
a = "ab\u1234c";
|
||||
//writefln(a);
|
||||
r = a.dup.reverse;
|
||||
//writefln(r);
|
||||
assert(r == "c\u1234ba");
|
||||
|
||||
a = "\u3026\u2021\u3061\n";
|
||||
r = a.dup.reverse;
|
||||
assert(r == "\n\u3061\u2021\u3026");
|
||||
}
|
||||
|
||||
|
||||
/**********************************************
|
||||
* Reverse array of wchars.
|
||||
* Handled separately because embedded multiword encodings should not be
|
||||
* reversed.
|
||||
*/
|
||||
|
||||
extern (C) long _adReverseWchar(wchar[] a)
|
||||
{
|
||||
if (a.length > 1)
|
||||
{
|
||||
wchar[2] tmp;
|
||||
wchar* lo = a.ptr;
|
||||
wchar* hi = &a[length - 1];
|
||||
|
||||
while (lo < hi)
|
||||
{ auto clo = *lo;
|
||||
auto chi = *hi;
|
||||
|
||||
if ((clo < 0xD800 || clo > 0xDFFF) &&
|
||||
(chi < 0xD800 || chi > 0xDFFF))
|
||||
{
|
||||
*lo = chi;
|
||||
*hi = clo;
|
||||
lo++;
|
||||
hi--;
|
||||
continue;
|
||||
}
|
||||
|
||||
int stridelo = 1 + (clo >= 0xD800 && clo <= 0xDBFF);
|
||||
|
||||
int stridehi = 1;
|
||||
if (chi >= 0xDC00 && chi <= 0xDFFF)
|
||||
{
|
||||
chi = *--hi;
|
||||
stridehi++;
|
||||
assert(hi >= lo);
|
||||
}
|
||||
if (lo == hi)
|
||||
break;
|
||||
|
||||
if (stridelo == stridehi)
|
||||
{ int stmp;
|
||||
|
||||
assert(stridelo == 2);
|
||||
assert(stmp.sizeof == 2 * (*lo).sizeof);
|
||||
stmp = *cast(int*)lo;
|
||||
*cast(int*)lo = *cast(int*)hi;
|
||||
*cast(int*)hi = stmp;
|
||||
lo += stridelo;
|
||||
hi--;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Shift the whole array. This is woefully inefficient
|
||||
*/
|
||||
memcpy(tmp.ptr, hi, stridehi * wchar.sizeof);
|
||||
memcpy(hi + stridehi - stridelo, lo, stridelo * wchar.sizeof);
|
||||
memmove(lo + stridehi, lo + stridelo , (hi - (lo + stridelo)) * wchar.sizeof);
|
||||
memcpy(lo, tmp.ptr, stridehi * wchar.sizeof);
|
||||
|
||||
lo += stridehi;
|
||||
hi = hi - 1 + (stridehi - stridelo);
|
||||
}
|
||||
}
|
||||
return *cast(long*)(&a);
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
wstring a = "abcd";
|
||||
|
||||
auto r = a.dup.reverse;
|
||||
assert(r == "dcba");
|
||||
|
||||
a = "a\U00012356\U00012346c";
|
||||
r = a.dup.reverse;
|
||||
assert(r == "c\U00012346\U00012356a");
|
||||
|
||||
a = "ab\U00012345c";
|
||||
r = a.dup.reverse;
|
||||
assert(r == "c\U00012345ba");
|
||||
}
|
||||
|
||||
|
||||
/**********************************************
|
||||
* Support for array.reverse property.
|
||||
*/
|
||||
|
||||
extern (C) long _adReverse(Array a, size_t szelem)
|
||||
out (result)
|
||||
{
|
||||
assert(result is *cast(long*)(&a));
|
||||
}
|
||||
body
|
||||
{
|
||||
if (a.length >= 2)
|
||||
{
|
||||
byte* tmp;
|
||||
byte[16] buffer;
|
||||
|
||||
void* lo = a.ptr;
|
||||
void* hi = a.ptr + (a.length - 1) * szelem;
|
||||
|
||||
tmp = buffer.ptr;
|
||||
if (szelem > 16)
|
||||
{
|
||||
//version (Windows)
|
||||
tmp = cast(byte*) alloca(szelem);
|
||||
//else
|
||||
//tmp = gc_malloc(szelem);
|
||||
}
|
||||
|
||||
for (; lo < hi; lo += szelem, hi -= szelem)
|
||||
{
|
||||
memcpy(tmp, lo, szelem);
|
||||
memcpy(lo, hi, szelem);
|
||||
memcpy(hi, tmp, szelem);
|
||||
}
|
||||
|
||||
version (Windows)
|
||||
{
|
||||
}
|
||||
else
|
||||
{
|
||||
//if (szelem > 16)
|
||||
// BUG: bad code is generate for delete pointer, tries
|
||||
// to call delclass.
|
||||
//gc_free(tmp);
|
||||
}
|
||||
}
|
||||
return *cast(long*)(&a);
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(adi) printf("array.reverse.unittest\n");
|
||||
|
||||
int[] a = new int[5];
|
||||
int[] b;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < 5; i++)
|
||||
a[i] = i;
|
||||
b = a.reverse;
|
||||
assert(b is a);
|
||||
for (i = 0; i < 5; i++)
|
||||
assert(a[i] == 4 - i);
|
||||
|
||||
struct X20
|
||||
{ // More than 16 bytes in size
|
||||
int a;
|
||||
int b, c, d, e;
|
||||
}
|
||||
|
||||
X20[] c = new X20[5];
|
||||
X20[] d;
|
||||
|
||||
for (i = 0; i < 5; i++)
|
||||
{ c[i].a = i;
|
||||
c[i].e = 10;
|
||||
}
|
||||
d = c.reverse;
|
||||
assert(d is c);
|
||||
for (i = 0; i < 5; i++)
|
||||
{
|
||||
assert(c[i].a == 4 - i);
|
||||
assert(c[i].e == 10);
|
||||
}
|
||||
}
|
||||
|
||||
/**********************************************
|
||||
* Sort array of chars.
|
||||
*/
|
||||
|
||||
extern (C) long _adSortChar(char[] a)
|
||||
{
|
||||
if (a.length > 1)
|
||||
{
|
||||
dstring da = toUTF32(a);
|
||||
da.sort;
|
||||
size_t i = 0;
|
||||
foreach (dchar d; da)
|
||||
{ char[4] buf;
|
||||
auto t = toUTF8(buf, d);
|
||||
a[i .. i + t.length] = t[];
|
||||
i += t.length;
|
||||
}
|
||||
delete da;
|
||||
}
|
||||
return *cast(long*)(&a);
|
||||
}
|
||||
|
||||
/**********************************************
|
||||
* Sort array of wchars.
|
||||
*/
|
||||
|
||||
extern (C) long _adSortWchar(wchar[] a)
|
||||
{
|
||||
if (a.length > 1)
|
||||
{
|
||||
dstring da = toUTF32(a);
|
||||
da.sort;
|
||||
size_t i = 0;
|
||||
foreach (dchar d; da)
|
||||
{ wchar[2] buf;
|
||||
auto t = toUTF16(buf, d);
|
||||
a[i .. i + t.length] = t[];
|
||||
i += t.length;
|
||||
}
|
||||
delete da;
|
||||
}
|
||||
return *cast(long*)(&a);
|
||||
}
|
||||
|
||||
/***************************************
|
||||
* Support for array equality test.
|
||||
* Returns:
|
||||
* 1 equal
|
||||
* 0 not equal
|
||||
*/
|
||||
|
||||
extern (C) int _adEq(Array a1, Array a2, TypeInfo ti)
|
||||
{
|
||||
debug(adi) printf("_adEq(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
||||
if (a1.length != a2.length)
|
||||
return 0; // not equal
|
||||
auto sz = ti.tsize();
|
||||
auto p1 = a1.ptr;
|
||||
auto p2 = a2.ptr;
|
||||
|
||||
if (sz == 1)
|
||||
// We should really have a ti.isPOD() check for this
|
||||
return (memcmp(p1, p2, a1.length) == 0);
|
||||
|
||||
for (size_t i = 0; i < a1.length; i++)
|
||||
{
|
||||
if (!ti.equals(p1 + i * sz, p2 + i * sz))
|
||||
return 0; // not equal
|
||||
}
|
||||
return 1; // equal
|
||||
}
|
||||
|
||||
extern (C) int _adEq2(Array a1, Array a2, TypeInfo ti)
|
||||
{
|
||||
debug(adi) printf("_adEq2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
||||
if (a1.length != a2.length)
|
||||
return 0; // not equal
|
||||
if (!ti.equals(&a1, &a2))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
unittest
|
||||
{
|
||||
debug(adi) printf("array.Eq unittest\n");
|
||||
|
||||
auto a = "hello"c;
|
||||
|
||||
assert(a != "hel");
|
||||
assert(a != "helloo");
|
||||
assert(a != "betty");
|
||||
assert(a == "hello");
|
||||
assert(a != "hxxxx");
|
||||
}
|
||||
|
||||
/***************************************
|
||||
* Support for array compare test.
|
||||
*/
|
||||
|
||||
extern (C) int _adCmp(Array a1, Array a2, TypeInfo ti)
|
||||
{
|
||||
debug(adi) printf("adCmp()\n");
|
||||
auto len = a1.length;
|
||||
if (a2.length < len)
|
||||
len = a2.length;
|
||||
auto sz = ti.tsize();
|
||||
void *p1 = a1.ptr;
|
||||
void *p2 = a2.ptr;
|
||||
|
||||
if (sz == 1)
|
||||
{ // We should really have a ti.isPOD() check for this
|
||||
auto c = memcmp(p1, p2, len);
|
||||
if (c)
|
||||
return c;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_t i = 0; i < len; i++)
|
||||
{
|
||||
auto c = ti.compare(p1 + i * sz, p2 + i * sz);
|
||||
if (c)
|
||||
return c;
|
||||
}
|
||||
}
|
||||
if (a1.length == a2.length)
|
||||
return 0;
|
||||
return (a1.length > a2.length) ? 1 : -1;
|
||||
}
|
||||
|
||||
extern (C) int _adCmp2(Array a1, Array a2, TypeInfo ti)
|
||||
{
|
||||
debug(adi) printf("_adCmp2(a1.length = %d, a2.length = %d)\n", a1.length, a2.length);
|
||||
return ti.compare(&a1, &a2);
|
||||
}
|
||||
unittest
|
||||
{
|
||||
debug(adi) printf("array.Cmp unittest\n");
|
||||
|
||||
auto a = "hello"c;
|
||||
|
||||
assert(a > "hel");
|
||||
assert(a >= "hel");
|
||||
assert(a < "helloo");
|
||||
assert(a <= "helloo");
|
||||
assert(a > "betty");
|
||||
assert(a >= "betty");
|
||||
assert(a == "hello");
|
||||
assert(a <= "hello");
|
||||
assert(a >= "hello");
|
||||
}
|
||||
|
||||
/***************************************
|
||||
* Support for array compare test.
|
||||
*/
|
||||
|
||||
extern (C) int _adCmpChar(Array a1, Array a2)
|
||||
{
|
||||
version (X86)
|
||||
{
|
||||
asm
|
||||
{ naked ;
|
||||
|
||||
push EDI ;
|
||||
push ESI ;
|
||||
|
||||
mov ESI,a1+4[4+ESP] ;
|
||||
mov EDI,a2+4[4+ESP] ;
|
||||
|
||||
mov ECX,a1[4+ESP] ;
|
||||
mov EDX,a2[4+ESP] ;
|
||||
|
||||
cmp ECX,EDX ;
|
||||
jb GotLength ;
|
||||
|
||||
mov ECX,EDX ;
|
||||
|
||||
GotLength:
|
||||
cmp ECX,4 ;
|
||||
jb DoBytes ;
|
||||
|
||||
// Do alignment if neither is dword aligned
|
||||
test ESI,3 ;
|
||||
jz Aligned ;
|
||||
|
||||
test EDI,3 ;
|
||||
jz Aligned ;
|
||||
DoAlign:
|
||||
mov AL,[ESI] ; //align ESI to dword bounds
|
||||
mov DL,[EDI] ;
|
||||
|
||||
cmp AL,DL ;
|
||||
jnz Unequal ;
|
||||
|
||||
inc ESI ;
|
||||
inc EDI ;
|
||||
|
||||
test ESI,3 ;
|
||||
|
||||
lea ECX,[ECX-1] ;
|
||||
jnz DoAlign ;
|
||||
Aligned:
|
||||
mov EAX,ECX ;
|
||||
|
||||
// do multiple of 4 bytes at a time
|
||||
|
||||
shr ECX,2 ;
|
||||
jz TryOdd ;
|
||||
|
||||
repe ;
|
||||
cmpsd ;
|
||||
|
||||
jnz UnequalQuad ;
|
||||
|
||||
TryOdd:
|
||||
mov ECX,EAX ;
|
||||
DoBytes:
|
||||
// if still equal and not end of string, do up to 3 bytes slightly
|
||||
// slower.
|
||||
|
||||
and ECX,3 ;
|
||||
jz Equal ;
|
||||
|
||||
repe ;
|
||||
cmpsb ;
|
||||
|
||||
jnz Unequal ;
|
||||
Equal:
|
||||
mov EAX,a1[4+ESP] ;
|
||||
mov EDX,a2[4+ESP] ;
|
||||
|
||||
sub EAX,EDX ;
|
||||
pop ESI ;
|
||||
|
||||
pop EDI ;
|
||||
ret ;
|
||||
|
||||
UnequalQuad:
|
||||
mov EDX,[EDI-4] ;
|
||||
mov EAX,[ESI-4] ;
|
||||
|
||||
cmp AL,DL ;
|
||||
jnz Unequal ;
|
||||
|
||||
cmp AH,DH ;
|
||||
jnz Unequal ;
|
||||
|
||||
shr EAX,16 ;
|
||||
|
||||
shr EDX,16 ;
|
||||
|
||||
cmp AL,DL ;
|
||||
jnz Unequal ;
|
||||
|
||||
cmp AH,DH ;
|
||||
Unequal:
|
||||
sbb EAX,EAX ;
|
||||
pop ESI ;
|
||||
|
||||
or EAX,1 ;
|
||||
pop EDI ;
|
||||
|
||||
ret ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int len;
|
||||
int c;
|
||||
|
||||
debug(adi) printf("adCmpChar()\n");
|
||||
len = a1.length;
|
||||
if (a2.length < len)
|
||||
len = a2.length;
|
||||
c = memcmp(cast(char *)a1.ptr, cast(char *)a2.ptr, len);
|
||||
if (!c)
|
||||
c = cast(int)a1.length - cast(int)a2.length;
|
||||
return c;
|
||||
}
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
debug(adi) printf("array.CmpChar unittest\n");
|
||||
|
||||
auto a = "hello"c;
|
||||
|
||||
assert(a > "hel");
|
||||
assert(a >= "hel");
|
||||
assert(a < "helloo");
|
||||
assert(a <= "helloo");
|
||||
assert(a > "betty");
|
||||
assert(a >= "betty");
|
||||
assert(a == "hello");
|
||||
assert(a <= "hello");
|
||||
assert(a >= "hello");
|
||||
}
|
||||
135
druntime/src/compiler/dmd/alloca.d
Normal file
135
druntime/src/compiler/dmd/alloca.d
Normal file
@@ -0,0 +1,135 @@
|
||||
/**
|
||||
* Implementation of alloca() standard C routine.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 1990 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright
|
||||
*
|
||||
* Copyright Digital Mars 1990 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.alloca;
|
||||
|
||||
/+
|
||||
#if DOS386
|
||||
extern size_t _x386_break;
|
||||
#else
|
||||
extern size_t _pastdata;
|
||||
#endif
|
||||
+/
|
||||
|
||||
/*******************************************
|
||||
* Allocate data from the caller's stack frame.
|
||||
* This is a 'magic' function that needs help from the compiler to
|
||||
* work right, do not change its name, do not call it from other compilers.
|
||||
* Input:
|
||||
* nbytes number of bytes to allocate
|
||||
* ECX address of variable with # of bytes in locals
|
||||
* This is adjusted upon return to reflect the additional
|
||||
* size of the stack frame.
|
||||
* Returns:
|
||||
* EAX allocated data, null if stack overflows
|
||||
*/
|
||||
|
||||
extern (C) void* __alloca(int nbytes)
|
||||
{
|
||||
asm
|
||||
{
|
||||
naked ;
|
||||
mov EDX,ECX ;
|
||||
mov EAX,4[ESP] ; // get nbytes
|
||||
push EBX ;
|
||||
push EDI ;
|
||||
push ESI ;
|
||||
}
|
||||
|
||||
version (OSX)
|
||||
{
|
||||
asm
|
||||
{
|
||||
add EAX,15 ;
|
||||
and EAX,0xFFFFFFF0 ; // round up to 16 byte boundary
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
asm
|
||||
{
|
||||
add EAX,3 ;
|
||||
and EAX,0xFFFFFFFC ; // round up to dword
|
||||
}
|
||||
}
|
||||
|
||||
asm
|
||||
{
|
||||
jnz Abegin ;
|
||||
mov EAX,4 ; // allow zero bytes allocation, 0 rounded to dword is 4..
|
||||
Abegin:
|
||||
mov ESI,EAX ; // ESI = nbytes
|
||||
neg EAX ;
|
||||
add EAX,ESP ; // EAX is now what the new ESP will be.
|
||||
jae Aoverflow ;
|
||||
}
|
||||
version (Windows)
|
||||
{
|
||||
asm
|
||||
{
|
||||
// We need to be careful about the guard page
|
||||
// Thus, for every 4k page, touch it to cause the OS to load it in.
|
||||
mov ECX,EAX ; // ECX is new location for stack
|
||||
mov EBX,ESI ; // EBX is size to "grow" stack
|
||||
L1:
|
||||
test [ECX+EBX],EBX ; // bring in page
|
||||
sub EBX,0x1000 ; // next 4K page down
|
||||
jae L1 ; // if more pages
|
||||
test [ECX],EBX ; // bring in last page
|
||||
}
|
||||
}
|
||||
version (DOS386)
|
||||
{
|
||||
asm
|
||||
{
|
||||
// is ESP off bottom?
|
||||
cmp EAX,_x386_break ;
|
||||
jbe Aoverflow ;
|
||||
}
|
||||
}
|
||||
version (Unix)
|
||||
{
|
||||
asm
|
||||
{
|
||||
cmp EAX,_pastdata ;
|
||||
jbe Aoverflow ; // Unlikely - ~2 Gbytes under UNIX
|
||||
}
|
||||
}
|
||||
asm
|
||||
{
|
||||
// Copy down to [ESP] the temps on the stack.
|
||||
// The number of temps is (EBP - ESP - locals).
|
||||
mov ECX,EBP ;
|
||||
sub ECX,ESP ;
|
||||
sub ECX,[EDX] ; // ECX = number of temps (bytes) to move.
|
||||
add [EDX],ESI ; // adjust locals by nbytes for next call to alloca()
|
||||
mov ESP,EAX ; // Set up new stack pointer.
|
||||
add EAX,ECX ; // Return value = ESP + temps.
|
||||
mov EDI,ESP ; // Destination of copy of temps.
|
||||
add ESI,ESP ; // Source of copy.
|
||||
shr ECX,2 ; // ECX to count of dwords in temps
|
||||
// Always at least 4 (nbytes, EIP, ESI,and EDI).
|
||||
rep ;
|
||||
movsd ;
|
||||
jmp done ;
|
||||
|
||||
Aoverflow:
|
||||
// Overflowed the stack. Return null
|
||||
xor EAX,EAX ;
|
||||
|
||||
done:
|
||||
pop ESI ;
|
||||
pop EDI ;
|
||||
pop EBX ;
|
||||
ret ;
|
||||
}
|
||||
}
|
||||
186
druntime/src/compiler/dmd/arrayassign.d
Normal file
186
druntime/src/compiler/dmd/arrayassign.d
Normal file
@@ -0,0 +1,186 @@
|
||||
/**
|
||||
* Implementation of array assignment support routines.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2000 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright
|
||||
*
|
||||
* Copyright Digital Mars 2000 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.arrayassign;
|
||||
|
||||
private
|
||||
{
|
||||
import rt.util.string;
|
||||
import core.stdc.string;
|
||||
import core.stdc.stdlib;
|
||||
debug(PRINTF) import core.stdc.stdio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does array assignment (not construction) from another
|
||||
* array of the same element type.
|
||||
* ti is the element type.
|
||||
* Handles overlapping copies.
|
||||
*/
|
||||
extern (C) void[] _d_arrayassign(TypeInfo ti, void[] from, void[] to)
|
||||
{
|
||||
debug(PRINTF) printf("_d_arrayassign(from = %p,%d, to = %p,%d) size = %d\n", from.ptr, from.length, to.ptr, to.length, ti.tsize());
|
||||
|
||||
if (to.length != from.length)
|
||||
{
|
||||
char[10] tmp = void;
|
||||
string msg = "lengths don't match for array copy,"c;
|
||||
msg ~= tmp.intToString(to.length) ~ " = " ~ tmp.intToString(from.length);
|
||||
throw new Exception(msg);
|
||||
}
|
||||
|
||||
auto element_size = ti.tsize();
|
||||
|
||||
/* Need a temporary buffer tmp[] big enough to hold one element
|
||||
*/
|
||||
void[16] buf = void;
|
||||
void[] tmp;
|
||||
if (element_size > buf.sizeof)
|
||||
tmp = alloca(element_size)[0 .. element_size];
|
||||
else
|
||||
tmp = buf;
|
||||
|
||||
|
||||
if (to.ptr <= from.ptr)
|
||||
{
|
||||
foreach (i; 0 .. to.length)
|
||||
{
|
||||
void* pto = to.ptr + i * element_size;
|
||||
void* pfrom = from.ptr + i * element_size;
|
||||
memcpy(tmp.ptr, pto, element_size);
|
||||
memcpy(pto, pfrom, element_size);
|
||||
ti.postblit(pto);
|
||||
ti.destroy(tmp.ptr);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int i = to.length; i--; )
|
||||
{
|
||||
void* pto = to.ptr + i * element_size;
|
||||
void* pfrom = from.ptr + i * element_size;
|
||||
memcpy(tmp.ptr, pto, element_size);
|
||||
memcpy(pto, pfrom, element_size);
|
||||
ti.postblit(pto);
|
||||
ti.destroy(tmp.ptr);
|
||||
}
|
||||
}
|
||||
return to;
|
||||
}
|
||||
|
||||
/**
|
||||
* Does array initialization (not assignment) from another
|
||||
* array of the same element type.
|
||||
* ti is the element type.
|
||||
*/
|
||||
extern (C) void[] _d_arrayctor(TypeInfo ti, void[] from, void[] to)
|
||||
{
|
||||
debug(PRINTF) printf("_d_arrayctor(from = %p,%d, to = %p,%d) size = %d\n", from.ptr, from.length, to.ptr, to.length, ti.tsize());
|
||||
|
||||
if (to.length != from.length)
|
||||
{
|
||||
char[10] tmp = void;
|
||||
string msg = "lengths don't match for array initialization,"c;
|
||||
msg ~= tmp.intToString(to.length) ~ " = " ~ tmp.intToString(from.length);
|
||||
throw new Exception(msg);
|
||||
}
|
||||
|
||||
auto element_size = ti.tsize();
|
||||
|
||||
int i;
|
||||
try
|
||||
{
|
||||
for (i = 0; i < to.length; i++)
|
||||
{
|
||||
// Copy construction is defined as bit copy followed by postblit.
|
||||
memcpy(to.ptr + i * element_size, from.ptr + i * element_size, element_size);
|
||||
ti.postblit(to.ptr + i * element_size);
|
||||
}
|
||||
}
|
||||
catch (Object o)
|
||||
{
|
||||
/* Destroy, in reverse order, what we've constructed so far
|
||||
*/
|
||||
while (i--)
|
||||
{
|
||||
ti.destroy(to.ptr + i * element_size);
|
||||
}
|
||||
|
||||
throw o;
|
||||
}
|
||||
return to;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Do assignment to an array.
|
||||
* p[0 .. count] = value;
|
||||
*/
|
||||
extern (C) void* _d_arraysetassign(void* p, void* value, int count, TypeInfo ti)
|
||||
{
|
||||
void* pstart = p;
|
||||
|
||||
auto element_size = ti.tsize();
|
||||
|
||||
//Need a temporary buffer tmp[] big enough to hold one element
|
||||
void[16] buf = void;
|
||||
void[] tmp;
|
||||
if (element_size > buf.sizeof)
|
||||
{
|
||||
tmp = alloca(element_size)[0 .. element_size];
|
||||
}
|
||||
else
|
||||
tmp = buf;
|
||||
|
||||
foreach (i; 0 .. count)
|
||||
{
|
||||
memcpy(tmp.ptr, p, element_size);
|
||||
memcpy(p, value, element_size);
|
||||
ti.postblit(p);
|
||||
ti.destroy(tmp.ptr);
|
||||
p += element_size;
|
||||
}
|
||||
return pstart;
|
||||
}
|
||||
|
||||
/**
|
||||
* Do construction of an array.
|
||||
* ti[count] p = value;
|
||||
*/
|
||||
extern (C) void* _d_arraysetctor(void* p, void* value, int count, TypeInfo ti)
|
||||
{
|
||||
void* pstart = p;
|
||||
auto element_size = ti.tsize();
|
||||
|
||||
try
|
||||
{
|
||||
foreach (i; 0 .. count)
|
||||
{
|
||||
// Copy construction is defined as bit copy followed by postblit.
|
||||
memcpy(p, value, element_size);
|
||||
ti.postblit(p);
|
||||
p += element_size;
|
||||
}
|
||||
}
|
||||
catch (Object o)
|
||||
{
|
||||
// Destroy, in reverse order, what we've constructed so far
|
||||
while (p > pstart)
|
||||
{
|
||||
p -= element_size;
|
||||
ti.destroy(p);
|
||||
}
|
||||
|
||||
throw o;
|
||||
}
|
||||
return pstart;
|
||||
}
|
||||
1893
druntime/src/compiler/dmd/arraybyte.d
Normal file
1893
druntime/src/compiler/dmd/arraybyte.d
Normal file
File diff suppressed because it is too large
Load Diff
94
druntime/src/compiler/dmd/arraycast.d
Normal file
94
druntime/src/compiler/dmd/arraycast.d
Normal file
@@ -0,0 +1,94 @@
|
||||
/**
|
||||
* Implementation of array cast support routines.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2004 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Sean Kelly
|
||||
*
|
||||
* Copyright Digital Mars 2004 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.arraycast;
|
||||
|
||||
/******************************************
|
||||
* Runtime helper to convert dynamic array of one
|
||||
* type to dynamic array of another.
|
||||
* Adjusts the length of the array.
|
||||
* Throws exception if new length is not aligned.
|
||||
*/
|
||||
|
||||
extern (C)
|
||||
|
||||
void[] _d_arraycast(size_t tsize, size_t fsize, void[] a)
|
||||
{
|
||||
auto length = a.length;
|
||||
|
||||
auto nbytes = length * fsize;
|
||||
if (nbytes % tsize != 0)
|
||||
{
|
||||
throw new Exception("array cast misalignment");
|
||||
}
|
||||
length = nbytes / tsize;
|
||||
*cast(size_t *)&a = length; // jam new length
|
||||
return a;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
byte[int.sizeof * 3] b;
|
||||
int[] i;
|
||||
short[] s;
|
||||
|
||||
i = cast(int[])b;
|
||||
assert(i.length == 3);
|
||||
|
||||
s = cast(short[])b;
|
||||
assert(s.length == 6);
|
||||
|
||||
s = cast(short[])i;
|
||||
assert(s.length == 6);
|
||||
}
|
||||
|
||||
/******************************************
|
||||
* Runtime helper to convert dynamic array of bits
|
||||
* dynamic array of another.
|
||||
* Adjusts the length of the array.
|
||||
* Throws exception if new length is not aligned.
|
||||
*/
|
||||
|
||||
version (none)
|
||||
{
|
||||
extern (C)
|
||||
|
||||
void[] _d_arraycast_frombit(uint tsize, void[] a)
|
||||
{
|
||||
uint length = a.length;
|
||||
|
||||
if (length & 7)
|
||||
{
|
||||
throw new Exception("bit[] array cast misalignment");
|
||||
}
|
||||
length /= 8 * tsize;
|
||||
*cast(size_t *)&a = length; // jam new length
|
||||
return a;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
version (D_Bits)
|
||||
{
|
||||
bit[int.sizeof * 3 * 8] b;
|
||||
int[] i;
|
||||
short[] s;
|
||||
|
||||
i = cast(int[])b;
|
||||
assert(i.length == 3);
|
||||
|
||||
s = cast(short[])b;
|
||||
assert(s.length == 6);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
42
druntime/src/compiler/dmd/arraycat.d
Normal file
42
druntime/src/compiler/dmd/arraycat.d
Normal file
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* Implementation of array copy support routines.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2004 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, Sean Kelly
|
||||
*
|
||||
* Copyright Digital Mars 2004 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.arraycat;
|
||||
|
||||
private
|
||||
{
|
||||
import core.stdc.string;
|
||||
debug import core.stdc.stdio;
|
||||
}
|
||||
|
||||
extern (C):
|
||||
|
||||
byte[] _d_arraycopy(size_t size, byte[] from, byte[] to)
|
||||
{
|
||||
debug printf("f = %p,%d, t = %p,%d, size = %d\n",
|
||||
from.ptr, from.length, to.ptr, to.length, size);
|
||||
|
||||
if (to.length != from.length)
|
||||
{
|
||||
throw new Exception("lengths don't match for array copy");
|
||||
}
|
||||
else if (to.ptr + to.length * size <= from.ptr ||
|
||||
from.ptr + from.length * size <= to.ptr)
|
||||
{
|
||||
memcpy(to.ptr, from.ptr, to.length * size);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new Exception("overlapping array copy");
|
||||
}
|
||||
return to;
|
||||
}
|
||||
1720
druntime/src/compiler/dmd/arraydouble.d
Normal file
1720
druntime/src/compiler/dmd/arraydouble.d
Normal file
File diff suppressed because it is too large
Load Diff
2309
druntime/src/compiler/dmd/arrayfloat.d
Normal file
2309
druntime/src/compiler/dmd/arrayfloat.d
Normal file
File diff suppressed because it is too large
Load Diff
2430
druntime/src/compiler/dmd/arrayint.d
Normal file
2430
druntime/src/compiler/dmd/arrayint.d
Normal file
File diff suppressed because it is too large
Load Diff
241
druntime/src/compiler/dmd/arrayreal.d
Normal file
241
druntime/src/compiler/dmd/arrayreal.d
Normal file
@@ -0,0 +1,241 @@
|
||||
/**
|
||||
* Contains SSE2 and MMX versions of certain operations for real.
|
||||
*
|
||||
* Copyright: Copyright Digital Mars 2008 - 2009.
|
||||
* License: <a href="http://www.boost.org/LICENSE_1_0.txt>Boost License 1.0</a>.
|
||||
* Authors: Walter Bright, based on code originally written by Burton Radons
|
||||
*
|
||||
* Copyright Digital Mars 2008 - 2009.
|
||||
* Distributed under the Boost Software License, Version 1.0.
|
||||
* (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
module rt.arrayreal;
|
||||
|
||||
import rt.util.cpuid;
|
||||
|
||||
version (unittest)
|
||||
{
|
||||
private import core.stdc.stdio : printf;
|
||||
/* This is so unit tests will test every CPU variant
|
||||
*/
|
||||
int cpuid;
|
||||
const int CPUID_MAX = 1;
|
||||
bool mmx() { return cpuid == 1 && rt.util.cpuid.mmx(); }
|
||||
bool sse() { return cpuid == 2 && rt.util.cpuid.sse(); }
|
||||
bool sse2() { return cpuid == 3 && rt.util.cpuid.sse2(); }
|
||||
bool amd3dnow() { return cpuid == 4 && rt.util.cpuid.amd3dnow(); }
|
||||
}
|
||||
else
|
||||
{
|
||||
alias rt.util.cpuid.mmx mmx;
|
||||
alias rt.util.cpuid.sse sse;
|
||||
alias rt.util.cpuid.sse2 sse2;
|
||||
alias rt.util.cpuid.amd3dnow amd3dnow;
|
||||
}
|
||||
|
||||
//version = log;
|
||||
|
||||
bool disjoint(T)(T[] a, T[] b)
|
||||
{
|
||||
return (a.ptr + a.length <= b.ptr || b.ptr + b.length <= a.ptr);
|
||||
}
|
||||
|
||||
alias real T;
|
||||
|
||||
extern (C):
|
||||
|
||||
/* ======================================================================== */
|
||||
|
||||
/***********************
|
||||
* Computes:
|
||||
* a[] = b[] + c[]
|
||||
*/
|
||||
|
||||
T[] _arraySliceSliceAddSliceAssign_r(T[] a, T[] c, T[] b)
|
||||
in
|
||||
{
|
||||
assert(a.length == b.length && b.length == c.length);
|
||||
assert(disjoint(a, b));
|
||||
assert(disjoint(a, c));
|
||||
assert(disjoint(b, c));
|
||||
}
|
||||
body
|
||||
{
|
||||
for (int i = 0; i < a.length; i++)
|
||||
a[i] = b[i] + c[i];
|
||||
return a;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
printf("_arraySliceSliceAddSliceAssign_r unittest\n");
|
||||
for (cpuid = 0; cpuid < CPUID_MAX; cpuid++)
|
||||
{
|
||||
version (log) printf(" cpuid %d\n", cpuid);
|
||||
|
||||
for (int j = 0; j < 2; j++)
|
||||
{
|
||||
const int dim = 67;
|
||||
T[] a = new T[dim + j]; // aligned on 16 byte boundary
|
||||
a = a[j .. dim + j]; // misalign for second iteration
|
||||
T[] b = new T[dim + j];
|
||||
b = b[j .. dim + j];
|
||||
T[] c = new T[dim + j];
|
||||
c = c[j .. dim + j];
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{ a[i] = cast(T)i;
|
||||
b[i] = cast(T)(i + 7);
|
||||
c[i] = cast(T)(i * 2);
|
||||
}
|
||||
|
||||
c[] = a[] + b[];
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{
|
||||
if (c[i] != cast(T)(a[i] + b[i]))
|
||||
{
|
||||
printf("[%d]: %Lg != %Lg + %Lg\n", i, c[i], a[i], b[i]);
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
|
||||
/***********************
|
||||
* Computes:
|
||||
* a[] = b[] - c[]
|
||||
*/
|
||||
|
||||
T[] _arraySliceSliceMinSliceAssign_r(T[] a, T[] c, T[] b)
|
||||
in
|
||||
{
|
||||
assert(a.length == b.length && b.length == c.length);
|
||||
assert(disjoint(a, b));
|
||||
assert(disjoint(a, c));
|
||||
assert(disjoint(b, c));
|
||||
}
|
||||
body
|
||||
{
|
||||
for (int i = 0; i < a.length; i++)
|
||||
a[i] = b[i] - c[i];
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
unittest
|
||||
{
|
||||
printf("_arraySliceSliceMinSliceAssign_r unittest\n");
|
||||
for (cpuid = 0; cpuid < CPUID_MAX; cpuid++)
|
||||
{
|
||||
version (log) printf(" cpuid %d\n", cpuid);
|
||||
|
||||
for (int j = 0; j < 2; j++)
|
||||
{
|
||||
const int dim = 67;
|
||||
T[] a = new T[dim + j]; // aligned on 16 byte boundary
|
||||
a = a[j .. dim + j]; // misalign for second iteration
|
||||
T[] b = new T[dim + j];
|
||||
b = b[j .. dim + j];
|
||||
T[] c = new T[dim + j];
|
||||
c = c[j .. dim + j];
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{ a[i] = cast(T)i;
|
||||
b[i] = cast(T)(i + 7);
|
||||
c[i] = cast(T)(i * 2);
|
||||
}
|
||||
|
||||
c[] = a[] - b[];
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{
|
||||
if (c[i] != cast(T)(a[i] - b[i]))
|
||||
{
|
||||
printf("[%d]: %Lg != %Lg - %Lg\n", i, c[i], a[i], b[i]);
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ======================================================================== */
|
||||
|
||||
/***********************
|
||||
* Computes:
|
||||
* a[] -= b[] * value
|
||||
*/
|
||||
|
||||
T[] _arraySliceExpMulSliceMinass_r(T[] a, T value, T[] b)
|
||||
{
|
||||
return _arraySliceExpMulSliceAddass_r(a, -value, b);
|
||||
}
|
||||
|
||||
/***********************
|
||||
* Computes:
|
||||
* a[] += b[] * value
|
||||
*/
|
||||
|
||||
T[] _arraySliceExpMulSliceAddass_r(T[] a, T value, T[] b)
|
||||
in
|
||||
{
|
||||
assert(a.length == b.length);
|
||||
assert(disjoint(a, b));
|
||||
}
|
||||
body
|
||||
{
|
||||
auto aptr = a.ptr;
|
||||
auto aend = aptr + a.length;
|
||||
auto bptr = b.ptr;
|
||||
|
||||
// Handle remainder
|
||||
while (aptr < aend)
|
||||
*aptr++ += *bptr++ * value;
|
||||
|
||||
return a;
|
||||
}
|
||||
|
||||
unittest
|
||||
{
|
||||
printf("_arraySliceExpMulSliceAddass_r unittest\n");
|
||||
|
||||
cpuid = 1;
|
||||
{
|
||||
version (log) printf(" cpuid %d\n", cpuid);
|
||||
|
||||
for (int j = 0; j < 1; j++)
|
||||
{
|
||||
const int dim = 67;
|
||||
T[] a = new T[dim + j]; // aligned on 16 byte boundary
|
||||
a = a[j .. dim + j]; // misalign for second iteration
|
||||
T[] b = new T[dim + j];
|
||||
b = b[j .. dim + j];
|
||||
T[] c = new T[dim + j];
|
||||
c = c[j .. dim + j];
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{ a[i] = cast(T)i;
|
||||
b[i] = cast(T)(i + 7);
|
||||
c[i] = cast(T)(i * 2);
|
||||
}
|
||||
|
||||
b[] = c[];
|
||||
c[] += a[] * 6;
|
||||
|
||||
for (int i = 0; i < dim; i++)
|
||||
{
|
||||
//printf("[%d]: %Lg ?= %Lg + %Lg * 6\n", i, c[i], b[i], a[i]);
|
||||
if (c[i] != cast(T)(b[i] + a[i] * 6))
|
||||
{
|
||||
printf("[%d]: %Lg ?= %Lg + %Lg * 6\n", i, c[i], b[i], a[i]);
|
||||
assert(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
2303
druntime/src/compiler/dmd/arrayshort.d
Normal file
2303
druntime/src/compiler/dmd/arrayshort.d
Normal file
File diff suppressed because it is too large
Load Diff
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user