D/ldc
1
0
Fork 0
mirror of https://github.com/xomboverlord/ldc.git synced 2026-01-11 18:33:14 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

D2 changes!

Browse Source 
Removed druntime from the repository again.. Sorry :/
Updated the druntime port a bit, now requires druntime from trunk.
Added info in runtime/README on how to get druntime from trunk.
Added patch to add LDC support to druntime.
Removed some debug logging from D2 builds.
Fixed broken typeinfo for const/invariant in D2.
This commit is contained in:
Tomas Lindquist Olsen
2008-11-12 07:22:05 +01:00
parent fae4b56ec3
commit 582deb9827
247 changed files with 13186 additions and 61805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
dmd2/mtype.c
View File

@@ -2759,8 +2759,7 @@ Expression *TypeAArray::dotExp(Scope *sc, Expression *e, Identifier *ident)
ec = new VarExp(0, aaRehash_fd);
arguments = new Expressions();
arguments->push(e->addressOf(sc));
arguments->push(index->getTypeInfo(sc)); // LDC, we don't support the getInternalTypeInfo
// optimization arbitrarily, not yet at least...
arguments->push(index->getInternalTypeInfo(sc));
e = new CallExp(e->loc, ec, arguments);
e->type = this;
}

0
druntime/doc/.empty
View File

262
druntime/import/core/bitmanip.di
View File

@@ -1,262 +0,0 @@
/**
* 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 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;
}
}

114
druntime/import/core/exception.di
View File

@@ -1,114 +0,0 @@
// D import file generated from 'core/exception.d'
module core.exception;
private
{
alias void function(string file, size_t line, string msg = null) assertHandlerType;
assertHandlerType assertHandler = null;
}
class ArrayBoundsException : Exception
{
this(string file, size_t line)
{
super("Array index out of bounds",file,line);
}
}
class AssertException : Exception
{
this(string file, size_t line)
{
super("Assertion failure",file,line);
}
this(string msg, string file, size_t line)
{
super(msg,file,line);
}
}
class FinalizeException : Exception
{
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;
}
}
}
class HiddenFuncException : Exception
{
this(ClassInfo ci)
{
super("Hidden method called for " ~ ci.name);
}
}
class OutOfMemoryException : Exception
{
this(string file, size_t line)
{
super("Memory allocation failed",file,line);
}
override
{
string toString()
{
return msg ? super.toString() : "Memory allocation failed";
}
}
}
class SwitchException : Exception
{
this(string file, size_t line)
{
super("No appropriate switch clause found",file,line);
}
}
class UnicodeException : Exception
{
size_t idx;
this(string msg, size_t idx)
{
super(msg);
this.idx = idx;
}
}
void setAssertHandler(assertHandlerType h)
{
assertHandler = h;
}
extern (C)
{
void onAssertError(string file, size_t line);
}
extern (C)
{
void onAssertErrorMsg(string file, size_t line, string msg);
}
extern (C)
{
void onArrayBoundsError(string file, size_t line);
}
extern (C)
{
void onFinalizeError(ClassInfo info, Exception ex);
}
extern (C)
{
void onHiddenFuncError(Object o);
}
extern (C)
{
void onOutOfMemoryError();
}
extern (C)
{
void onSwitchError(string file, size_t line);
}
extern (C)
{
void onUnicodeError(string msg, size_t idx);
}

282
druntime/import/core/memory.di
View File

@@ -1,282 +0,0 @@
// D import file generated from 'core\memory.d'
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);
}
extern (C)
{
void* gc_getHandle();
}
extern (C)
{
void gc_setHandle(void* p);
}
extern (C)
{
void gc_endHandle();
}
}
struct GC
{
static
{
void enable()
{
gc_enable();
}
}
static
{
void disable()
{
gc_disable();
}
}
static
{
void collect()
{
gc_collect();
}
}
static
{
void minimize()
{
gc_minimize();
}
}
enum BlkAttr : uint
{
FINALIZE = 1,
NO_SCAN = 2,
NO_MOVE = 4,
}
alias BlkInfo_ BlkInfo;
static
{
uint getAttr(void* p)
{
return gc_getAttr(p);
}
}
static
{
uint setAttr(void* p, uint a)
{
return gc_setAttr(p,a);
}
}
static
{
uint clrAttr(void* p, uint a)
{
return gc_clrAttr(p,a);
}
}
static
{
void* malloc(size_t sz, uint ba = 0)
{
return gc_malloc(sz,ba);
}
}
static
{
void* calloc(size_t sz, uint ba = 0)
{
return gc_calloc(sz,ba);
}
}
static
{
void* realloc(void* p, size_t sz, uint ba = 0)
{
return gc_realloc(p,sz,ba);
}
}
static
{
size_t extend(void* p, size_t mx, size_t sz)
{
return gc_extend(p,mx,sz);
}
}
static
{
size_t reserve(size_t sz)
{
return gc_reserve(sz);
}
}
static
{
void free(void* p)
{
gc_free(p);
}
}
static
{
void* addrOf(void* p)
{
return gc_addrOf(p);
}
}
static
{
size_t sizeOf(void* p)
{
return gc_sizeOf(p);
}
}
static
{
BlkInfo query(void* p)
{
return gc_query(p);
}
}
static
{
void addRoot(void* p)
{
gc_addRoot(p);
}
}
static
{
void addRange(void* p, size_t sz)
{
gc_addRange(p,sz);
}
}
static
{
void removeRoot(void* p)
{
gc_removeRoot(p);
}
}
static
{
void removeRange(void* p)
{
gc_removeRange(p);
}
}
static
{
void* getHandle()
{
return gc_getHandle();
}
}
static
{
void setHandle(void* p)
{
gc_setHandle(p);
}
}
static
{
void endHandle()
{
gc_endHandle();
}
}
}

282
druntime/import/core/memory_.di
View File

@@ -1,282 +0,0 @@
// D import file generated from 'core/memory.d'
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);
}
extern (C)
{
void* gc_getHandle();
}
extern (C)
{
void gc_setHandle(void* p);
}
extern (C)
{
void gc_endHandle();
}
}
struct GC
{
static
{
void enable()
{
gc_enable();
}
}
static
{
void disable()
{
gc_disable();
}
}
static
{
void collect()
{
gc_collect();
}
}
static
{
void minimize()
{
gc_minimize();
}
}
enum BlkAttr : uint
{
FINALIZE = 1,
NO_SCAN = 2,
NO_MOVE = 4,
}
alias BlkInfo_ BlkInfo;
static
{
uint getAttr(void* p)
{
return gc_getAttr(p);
}
}
static
{
uint setAttr(void* p, uint a)
{
return gc_setAttr(p,a);
}
}
static
{
uint clrAttr(void* p, uint a)
{
return gc_clrAttr(p,a);
}
}
static
{
void* malloc(size_t sz, uint ba = 0)
{
return gc_malloc(sz,ba);
}
}
static
{
void* calloc(size_t sz, uint ba = 0)
{
return gc_calloc(sz,ba);
}
}
static
{
void* realloc(void* p, size_t sz, uint ba = 0)
{
return gc_realloc(p,sz,ba);
}
}
static
{
size_t extend(void* p, size_t mx, size_t sz)
{
return gc_extend(p,mx,sz);
}
}
static
{
size_t reserve(size_t sz)
{
return gc_reserve(sz);
}
}
static
{
void free(void* p)
{
gc_free(p);
}
}
static
{
void* addrOf(void* p)
{
return gc_addrOf(p);
}
}
static
{
size_t sizeOf(void* p)
{
return gc_sizeOf(p);
}
}
static
{
BlkInfo query(void* p)
{
return gc_query(p);
}
}
static
{
void addRoot(void* p)
{
gc_addRoot(p);
}
}
static
{
void addRange(void* p, size_t sz)
{
gc_addRange(p,sz);
}
}
static
{
void removeRoot(void* p)
{
gc_removeRoot(p);
}
}
static
{
void removeRange(void* p)
{
gc_removeRange(p);
}
}
static
{
void* getHandle()
{
return gc_getHandle();
}
}
static
{
void setHandle(void* p)
{
gc_setHandle(p);
}
}
static
{
void endHandle()
{
gc_endHandle();
}
}
}

85
druntime/import/core/runtime.di
View File

@@ -1,85 +0,0 @@
// D import file generated from 'core/runtime.d'
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(Exception) ExceptionHandler;
extern (C)
{
bool rt_init(ExceptionHandler dg = null);
}
extern (C)
{
bool rt_term(ExceptionHandler dg = null);
}
}
struct Runtime
{
static
{
bool initialize(void delegate(Exception) dg = null)
{
return rt_init(dg);
}
}
static
{
bool terminate(void delegate(Exception) dg = null)
{
return rt_term(dg);
}
}
static
{
bool isHalting()
{
return rt_isHalting();
}
}
static
{
void traceHandler(TraceHandler h)
{
rt_setTraceHandler(h);
}
}
static
{
void collectHandler(CollectHandler h)
{
rt_setCollectHandler(h);
}
}
static
{
void moduleUnitTester(ModuleUnitTester h)
{
sm_moduleUnitTester = h;
}
}
private
{
static
{
ModuleUnitTester sm_moduleUnitTester = null;
}
}
}
extern (C)
{
bool runModuleUnitTests();
}

792
druntime/import/core/thread.di
View File

@@ -1,792 +0,0 @@
// D import file generated from 'core/thread.d'
module core.thread;
version = StackGrowsDown;
class ThreadException : Exception
{
this(string msg)
{
super(msg);
}
}
class FiberException : Exception
{
this(string msg)
{
super(msg);
}
}
private
{
extern (C)
{
void* rt_stackBottom();
}
extern (C)
{
void* rt_stackTop();
}
void* getStackBottom()
{
return rt_stackBottom();
}
void* getStackTop();
}
version (Windows)
{
private
{
import stdc.stdint;
import sys.windows.windows;
const
{
DWORD TLS_OUT_OF_INDEXES = -1u;
}
extern (Windows)
{
alias uint function(void*) btex_fptr;
}
extern (C)
{
uintptr_t _beginthreadex(void*, uint, btex_fptr, void*, uint, uint*);
}
extern (Windows)
{
uint thread_entryPoint(void* arg);
}
HANDLE GetCurrentThreadHandle()
{
const uint DUPLICATE_SAME_ACCESS = 2;
HANDLE curr = GetCurrentThread();
HANDLE proc = GetCurrentProcess();
HANDLE hndl;
DuplicateHandle(proc,curr,proc,&hndl,0,TRUE,DUPLICATE_SAME_ACCESS);
return hndl;
}
}
}
else
{
version (Posix)
{
private
{
import stdc.posix.semaphore;
import stdc.posix.pthread;
import stdc.posix.signal;
import stdc.posix.time;
import stdc.errno;
extern (C)
{
int getErrno();
}
version (GNU)
{
import gcc.builtins;
}
extern (C)
{
void* thread_entryPoint(void* arg);
}
sem_t suspendCount;
extern (C)
{
void thread_suspendHandler(int sig);
}
extern (C)
{
void thread_resumeHandler(int sig)
in
{
assert(sig == SIGUSR2);
}
body
{
}
}
}
}
else
{
static assert(false,"Unknown threading implementation.");
}
}
class Thread
{
this(void function() fn, size_t sz = 0)
in
{
assert(fn);
}
body
{
m_fn = fn;
m_sz = sz;
m_call = Call.FN;
m_curr = &m_main;
}
this(void delegate() dg, size_t sz = 0)
in
{
assert(dg);
}
body
{
m_dg = dg;
m_sz = sz;
m_call = Call.DG;
m_curr = &m_main;
}
final
{
void start();
}
final
{
Object join(bool rethrow = true);
}
final
{
char[] name();
}
final
{
void name(char[] val);
}
final
{
bool isDaemon();
}
final
{
void isDaemon(bool val);
}
final
{
bool isRunning();
}
static const
{
int PRIORITY_MIN;
}
static const
{
int PRIORITY_MAX;
}
final
{
int priority();
}
final
{
void priority(int val);
}
static
{
void sleep(long period);
}
static
{
void yield();
}
static
{
Thread getThis();
}
static
{
Thread[] getAll();
}
static
{
int opApply(int delegate(ref Thread) dg);
}
static const
{
uint LOCAL_MAX = 64;
}
static
{
uint createLocal();
}
static
{
void deleteLocal(uint key);
}
static
{
void* getLocal(uint key)
{
return getThis().m_local[key];
}
}
static
{
void* setLocal(uint key, void* val)
{
return getThis().m_local[key] = val;
}
}
static this();
private
{
this()
{
m_call = Call.NO;
m_curr = &m_main;
}
final
{
void run();
}
private
{
enum Call
{
NO,
FN,
DG,
}
version (Win32)
{
alias uint TLSKey;
alias uint ThreadAddr;
}
else
{
version (Posix)
{
alias pthread_key_t TLSKey;
alias pthread_t ThreadAddr;
}
}
static
{
bool[LOCAL_MAX] sm_local;
}
static
{
TLSKey sm_this;
}
void*[LOCAL_MAX] m_local;
version (Win32)
{
HANDLE m_hndl;
}
ThreadAddr m_addr;
Call m_call;
char[] m_name;
union
{
void function() m_fn;
void delegate() m_dg;
}
size_t m_sz;
version (Posix)
{
bool m_isRunning;
}
bool m_isDaemon;
Object m_unhandled;
private
{
static
{
void setThis(Thread t);
}
private
{
final
{
void pushContext(Context* c)
in
{
assert(!c.within);
}
body
{
c.within = m_curr;
m_curr = c;
}
}
final
{
void popContext()
in
{
assert(m_curr && m_curr.within);
}
body
{
Context* c = m_curr;
m_curr = c.within;
c.within = null;
}
}
final
{
Context* topContext()
in
{
assert(m_curr);
}
body
{
return m_curr;
}
}
static
{
struct Context
{
void* bstack;
void* tstack;
Context* within;
Context* next;
Context* prev;
}
}
Context m_main;
Context* m_curr;
bool m_lock;
version (Win32)
{
uint[8] m_reg;
}
private
{
static
{
Object slock()
{
return Thread.classinfo;
}
}
static
{
Context* sm_cbeg;
}
static
{
size_t sm_clen;
}
static
{
Thread sm_tbeg;
}
static
{
size_t sm_tlen;
}
Thread prev;
Thread next;
static
{
void add(Context* c);
}
static
{
void remove(Context* c);
}
static
{
void add(Thread t);
}
static
{
void remove(Thread t);
}
}
}
}
}
}
}
extern (C)
{
void thread_init();
}
extern (C)
{
void thread_attachThis();
}
extern (C)
{
void thread_detachThis()
{
Thread.remove(Thread.getThis());
}
}
extern (C)
{
void thread_joinAll();
}
private
{
bool multiThreadedFlag = false;
}
extern (C)
{
bool thread_needLock()
{
return multiThreadedFlag;
}
}
private
{
uint suspendDepth = 0;
}
extern (C)
{
void thread_suspendAll();
}
extern (C)
{
void thread_resumeAll();
}
private
{
alias void delegate(void*, void*) scanAllThreadsFn;
}
extern (C)
{
void thread_scanAll(scanAllThreadsFn scan, void* curStackTop = null);
}
template ThreadLocal(T)
{
class ThreadLocal
{
this(T def = T.init)
{
m_def = def;
m_key = Thread.createLocal();
}
T val()
{
Wrap* wrap = cast(Wrap*)Thread.getLocal(m_key);
return wrap ? wrap.val : m_def;
}
T val(T newval)
{
Wrap* wrap = cast(Wrap*)Thread.getLocal(m_key);
if (wrap is null)
{
wrap = new Wrap;
Thread.setLocal(m_key,wrap);
}
wrap.val = newval;
return newval;
}
private
{
struct Wrap
{
T val;
}
T m_def;
uint m_key;
}
}
}
class ThreadGroup
{
final
{
Thread create(void function() fn);
}
final
{
Thread create(void delegate() dg);
}
final
{
void add(Thread t);
}
final
{
void remove(Thread t);
}
final
{
int opApply(int delegate(ref Thread) dg);
}
final
{
void joinAll(bool rethrow = true);
}
private
{
Thread[Thread] m_all;
}
}
private
{
version (D_InlineAsm_X86)
{
version (X86_64)
{
}
else
{
version (Win32)
{
version = AsmX86_Win32;
}
else
{
version (Posix)
{
version = AsmX86_Posix;
}
}
}
}
else
{
version (PPC)
{
version (Posix)
{
version = AsmPPC_Posix;
}
}
}
version (LLVM_InlineAsm_X86)
{
version (Win32)
{
version = LLVM_AsmX86_Win32;
}
else
{
version (Posix)
{
version = LLVM_AsmX86_Posix;
}
}
}
else
{
version (LLVM_InlineAsm_X86_64)
{
version (Posix)
{
version = LLVM_AsmX86_64_Posix;
}
}
}
version (Posix)
{
import stdc.posix.unistd;
import stdc.posix.sys.mman;
import stdc.posix.stdlib;
version (AsmX86_Win32)
{
}
else
{
version (AsmX86_Posix)
{
}
else
{
version (AsmPPC_Posix)
{
}
else
{
version (LLVM_AsmX86_Win32)
{
}
else
{
version (LLVM_AsmX86_Posix)
{
}
else
{
import stdc.posix.ucontext;
}
}
}
}
}
}
const
{
size_t PAGESIZE;
}
}
static this();
private
{
extern (C)
{
void fiber_entryPoint();
}
version (AsmPPC_Posix)
{
extern (C)
{
void fiber_switchContext(void** oldp, void* newp);
}
}
else
{
extern (C)
{
void fiber_switchContext(void** oldp, void* newp);
}
}
}
class Fiber
{
this(void function() fn, size_t sz = PAGESIZE)
in
{
assert(fn);
}
body
{
m_fn = fn;
m_call = Call.FN;
m_state = State.HOLD;
allocStack(sz);
initStack();
}
this(void delegate() dg, size_t sz = PAGESIZE)
in
{
assert(dg);
}
body
{
m_dg = dg;
m_call = Call.DG;
m_state = State.HOLD;
allocStack(sz);
initStack();
}
final
{
Object call(bool rethrow = true);
}
final
{
void reset()
in
{
assert(m_state == State.TERM);
assert(m_ctxt.tstack == m_ctxt.bstack);
}
body
{
m_state = State.HOLD;
initStack();
m_unhandled = null;
}
}
enum State
{
HOLD,
EXEC,
TERM,
}
final
{
State state()
{
return m_state;
}
}
static
{
void yield();
}
static
{
void yieldAndThrow(Object obj);
}
static
{
Fiber getThis();
}
static this();
private
{
this()
{
m_call = Call.NO;
}
final
{
void run();
}
private
{
enum Call
{
NO,
FN,
DG,
}
Call m_call;
union
{
void function() m_fn;
void delegate() m_dg;
}
bool m_isRunning;
Object m_unhandled;
State m_state;
private
{
final
{
void allocStack(size_t sz);
}
final
{
void freeStack();
}
final
{
void initStack();
}
Thread.Context* m_ctxt;
size_t m_size;
void* m_pmem;
static if(is(ucontext_t))
{
static
{
ucontext_t sm_utxt = void;
}
ucontext_t m_utxt = void;
ucontext_t* m_ucur = null;
}
private
{
static
{
void setThis(Fiber f);
}
static
{
Thread.TLSKey sm_this;
}
private
{
final
{
void switchIn();
}
final
{
void switchOut();
}
}
}
}
}
}
}

49
druntime/import/ldc/bitmanip.di
View File

@@ -1,49 +0,0 @@
// D import file generated from 'bitmanip.d'
module ldc.bitmanip;
version (LDC)
{
}
else
{
static assert(false,"This module is only valid for LDC");
}
int bsf(uint v);
int bsr(uint v);
int bt(uint* p, uint bitnum)
{
return p[bitnum / ((uint).sizeof * 8)] & 1 << (bitnum & (uint).sizeof * 8 - 1) ? -1 : 0;
}
int btc(uint* p, uint bitnum)
{
uint* q = p + bitnum / ((uint).sizeof * 8);
uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
int result = *q & mask;
*q ^= mask;
return result ? -1 : 0;
}
int btr(uint* p, uint bitnum)
{
uint* q = p + bitnum / ((uint).sizeof * 8);
uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
int result = *q & mask;
*q &= ~mask;
return result ? -1 : 0;
}
int bts(uint* p, uint bitnum)
{
uint* q = p + bitnum / ((uint).sizeof * 8);
uint mask = 1 << (bitnum & (uint).sizeof * 8 - 1);
int result = *q & mask;
*q |= mask;
return result ? -1 : 0;
}
pragma (intrinsic, "llvm.bswap.i32")
{
uint bswap(uint val);
}
ubyte inp(uint p);
ushort inpw(uint p);
uint inpl(uint p);
ubyte outp(uint p, ubyte v);
ushort outpw(uint p, ushort v);
uint outpl(uint p, uint v);

29
druntime/import/ldc/cstdarg.di
View File

@@ -1,29 +0,0 @@
/*
* vararg support for extern(C) functions
*/
module ldc.cstdarg;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
alias void* va_list;
pragma(va_start)
void va_start(T)(va_list ap, ref T);
pragma(va_arg)
T va_arg(T)(va_list ap);
pragma(va_end)
void va_end(va_list args);
pragma(va_copy)
void va_copy(va_list dst, va_list src);

343
druntime/import/ldc/intrinsics.di
View File

@@ -1,343 +0,0 @@
/*
* This module holds declarations to LLVM intrinsics.
*
* See the LLVM language reference for more information:
*
* - http://llvm.org/docs/LangRef.html#intrinsics
*
*/
module ldc.intrinsics;
// Check for the right compiler
version(LDC)
{
// OK
}
else
{
static assert(false, "This module is only valid for LDC");
}
//
// CODE GENERATOR INTRINSICS
//
// The 'llvm.returnaddress' intrinsic attempts to compute a target-specific value indicating the return address of the current function or one of its callers.
pragma(intrinsic, "llvm.returnaddress")
void* llvm_returnaddress(uint level);
// The 'llvm.frameaddress' intrinsic attempts to return the target-specific frame pointer value for the specified stack frame.
pragma(intrinsic, "llvm.frameaddress")
void* llvm_frameaddress(uint level);
// The 'llvm.stacksave' intrinsic is used to remember the current state of the function stack, for use with llvm.stackrestore. This is useful for implementing language features like scoped automatic variable sized arrays in C99.
pragma(intrinsic, "llvm.stacksave")
void* llvm_stacksave();
// The 'llvm.stackrestore' intrinsic is used to restore the state of the function stack to the state it was in when the corresponding llvm.stacksave intrinsic executed. This is useful for implementing language features like scoped automatic variable sized arrays in C99.
pragma(intrinsic, "llvm.stackrestore")
void llvm_stackrestore(void* ptr);
// The 'llvm.prefetch' intrinsic is a hint to the code generator to insert a prefetch instruction if supported; otherwise, it is a noop. Prefetches have no effect on the behavior of the program but can change its performance characteristics.
pragma(intrinsic, "llvm.prefetch")
void llvm_prefetch(void* ptr, uint rw, uint locality);
// The 'llvm.pcmarker' intrinsic is a method to export a Program Counter (PC) in a region of code to simulators and other tools. The method is target specific, but it is expected that the marker will use exported symbols to transmit the PC of the marker. The marker makes no guarantees that it will remain with any specific instruction after optimizations. It is possible that the presence of a marker will inhibit optimizations. The intended use is to be inserted after optimizations to allow correlations of simulation runs.
pragma(intrinsic, "llvm.pcmarker")
void llvm_pcmarker(uint id);
// The 'llvm.readcyclecounter' intrinsic provides access to the cycle counter register (or similar low latency, high accuracy clocks) on those targets that support it. On X86, it should map to RDTSC. On Alpha, it should map to RPCC. As the backing counters overflow quickly (on the order of 9 seconds on alpha), this should only be used for small timings.
pragma(intrinsic, "llvm.readcyclecounter")
ulong readcyclecounter();
//
// STANDARD C LIBRARY INTRINSICS
//
// The 'llvm.memcpy.*' intrinsics copy a block of memory from the source location to the destination location.
// Note that, unlike the standard libc function, the llvm.memcpy.* intrinsics do not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memcpy.i32")
void llvm_memcpy_i32(void* dst, void* src, uint len, uint alignment);
pragma(intrinsic, "llvm.memcpy.i64")
void llvm_memcpy_i64(void* dst, void* src, ulong len, uint alignment);
// The 'llvm.memmove.*' intrinsics move a block of memory from the source location to the destination location. It is similar to the 'llvm.memcpy' intrinsic but allows the two memory locations to overlap.
// Note that, unlike the standard libc function, the llvm.memmove.* intrinsics do not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memmove.i32")
void llvm_memmove_i32(void* dst, void* src, uint len, uint alignment);
pragma(intrinsic, "llvm.memmove.i64")
void llvm_memmove_i64(void* dst, void* src, ulong len, int alignment);
// The 'llvm.memset.*' intrinsics fill a block of memory with a particular byte value.
// Note that, unlike the standard libc function, the llvm.memset intrinsic does not return a value, and takes an extra alignment argument.
pragma(intrinsic, "llvm.memset.i32")
void llvm_memset_i32(void* dst, ubyte val, uint len, uint alignment);
pragma(intrinsic, "llvm.memset.i64")
void llvm_memset_i64(void* dst, ubyte val, ulong len, uint alignment);
// The 'llvm.sqrt' intrinsics return the sqrt of the specified operand, returning the same value as the libm 'sqrt' functions would. Unlike sqrt in libm, however, llvm.sqrt has undefined behavior for negative numbers other than -0.0 (which allows for better optimization, because there is no need to worry about errno being set). llvm.sqrt(-0.0) is defined to return -0.0 like IEEE sqrt.
pragma(intrinsic, "llvm.sqrt.f32")
float llvm_sqrt_f32(float val);
pragma(intrinsic, "llvm.sqrt.f64")
double llvm_sqrt_f64(double val);
version(X86)
{
pragma(intrinsic, "llvm.sqrt.f80")
real llvm_sqrt_f80(real val);
}
version(X86_64)
{
pragma(intrinsic, "llvm.sqrt.f80")
real llvm_sqrt_f80(real val);
}
// The 'llvm.sin.*' intrinsics return the sine of the operand.
pragma(intrinsic, "llvm.sin.f32")
float llvm_sin_f32(float val);
pragma(intrinsic, "llvm.sin.f64")
double llvm_sin_f64(double val);
version(X86)
{
pragma(intrinsic, "llvm.sin.f80")
real llvm_sin_f80(real val);
}
version(X86_64)
{
pragma(intrinsic, "llvm.sin.f80")
real llvm_sin_f80(real val);
}
// The 'llvm.cos.*' intrinsics return the cosine of the operand.
pragma(intrinsic, "llvm.cos.f32")
float llvm_cos_f32(float val);
pragma(intrinsic, "llvm.cos.f64")
double llvm_cos_f64(double val);
version(X86)
{
pragma(intrinsic, "llvm.cos.f80")
real llvm_cos_f80(real val);
}
version(X86_64)
{
pragma(intrinsic, "llvm.cos.f80")
real llvm_cos_f80(real val);
}
// The 'llvm.powi.*' intrinsics return the first operand raised to the specified (positive or negative) power. The order of evaluation of multiplications is not defined. When a vector of floating point type is used, the second argument remains a scalar integer value.
pragma(intrinsic, "llvm.powi.f32")
float llvm_powi_f32(float val, int power);
pragma(intrinsic, "llvm.powi.f64")
double llvm_powi_f64(double val, int power);
version(X86)
{
pragma(intrinsic, "llvm.powi.f80")
real llvm_powi_f80(real val, int power);
}
version(X86_64)
{
pragma(intrinsic, "llvm.powi.f80")
real llvm_powi_f80(real val, int power);
}
// The 'llvm.pow.*' intrinsics return the first operand raised to the specified (positive or negative) power.
pragma(intrinsic, "llvm.pow.f32")
float llvm_pow_f32(float val, float power);
pragma(intrinsic, "llvm.pow.f64")
double llvm_pow_f64(double val, double power);
version(X86)
{
pragma(intrinsic, "llvm.pow.f80")
real llvm_pow_f80(real val, real power);
}
version(X86_64)
{
pragma(intrinsic, "llvm.pow.f80")
real llvm_pow_f80(real val, real power);
}
//
// BIT MANIPULATION INTRINSICS
//
// The 'llvm.bswap' family of intrinsics is used to byte swap integer values with an even number of bytes (positive multiple of 16 bits). These are useful for performing operations on data that is not in the target's native byte order.
pragma(intrinsic, "llvm.bswap.i16.i16")
ushort llvm_bswap_i16(ushort val);
pragma(intrinsic, "llvm.bswap.i32.i32")
uint llvm_bswap_i32(uint val);
pragma(intrinsic, "llvm.bswap.i64.i64")
ulong llvm_bswap_i64(ulong val);
// The 'llvm.ctpop' family of intrinsics counts the number of bits set in a value.
pragma(intrinsic, "llvm.ctpop.i8")
ubyte llvm_ctpop_i8(ubyte src);
pragma(intrinsic, "llvm.ctpop.i16")
ushort llvm_ctpop_i16(ushort src);
pragma(intrinsic, "llvm.ctpop.i32")
uint llvm_ctpop_i32(uint src);
pragma(intrinsic, "llvm.ctpop.i64")
ulong llvm_ctpop_i64(ulong src);
// The 'llvm.ctlz' family of intrinsic functions counts the number of leading zeros in a variable.
pragma(intrinsic, "llvm.ctlz.i8")
ubyte llvm_ctlz_i8(ubyte src);
pragma(intrinsic, "llvm.ctlz.i16")
ushort llvm_ctlz_i16(ushort src);
pragma(intrinsic, "llvm.ctlz.i32")
uint llvm_ctlz_i32(uint src);
pragma(intrinsic, "llvm.ctlz.i64")
ulong llvm_ctlz_i64(ulong src);
// The 'llvm.cttz' family of intrinsic functions counts the number of trailing zeros.
pragma(intrinsic, "llvm.cttz.i8")
ubyte llvm_cttz_i8(ubyte src);
pragma(intrinsic, "llvm.cttz.i16")
ushort llvm_cttz_i16(ushort src);
pragma(intrinsic, "llvm.cttz.i32")
uint llvm_cttz_i32(uint src);
pragma(intrinsic, "llvm.cttz.i64")
ulong llvm_cttz_i64(ulong src);
// The 'llvm.part.select' family of intrinsic functions selects a range of bits from an integer value and returns them in the same bit width as the original value.
pragma(intrinsic, "llvm.part.select.i8")
ubyte llvm_part_select_i(ubyte val, uint loBit, uint hiBit);
pragma(intrinsic, "llvm.part.select.i16")
ushort llvm_part_select_i(ushort val, uint loBit, uint hiBit);
pragma(intrinsic, "llvm.part.select.i32")
uint llvm_part_select_i(uint val, uint loBit, uint hiBit);
pragma(intrinsic, "llvm.part.select.i64")
ulong llvm_part_select_i(ulong val, uint loBit, uint hiBit);
// The 'llvm.part.set' family of intrinsic functions replaces a range of bits in an integer value with another integer value. It returns the integer with the replaced bits.
// TODO
// declare i17 @llvm.part.set.i17.i9 (i17 %val, i9 %repl, i32 %lo, i32 %hi)
// declare i29 @llvm.part.set.i29.i9 (i29 %val, i9 %repl, i32 %lo, i32 %hi)
//
// ATOMIC OPERATIONS AND SYNCHRONIZATION INTRINSICS
//
// The llvm.memory.barrier intrinsic guarantees ordering between specific pairs of memory access types.
pragma(intrinsic, "llvm.memory.barrier")
void llvm_memory_barrier(bool ll, bool ls, bool sl, bool ss, bool device);
// This loads a value in memory and compares it to a given value. If they are equal, it stores a new value into the memory.
pragma(intrinsic, "llvm.atomic.cmp.swap.i#.p0i#")
T llvm_atomic_cmp_swap(T)(T* ptr, T cmp, T val);
// This intrinsic loads the value stored in memory at ptr and yields the value from memory. It then stores the value in val in the memory at ptr.
pragma(intrinsic, "llvm.atomic.swap.i#.p0i#")
T llvm_atomic_swap(T)(T* ptr, T val);
// This intrinsic adds delta to the value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.add.i#.p0i#")
T llvm_atomic_load_add(T)(T* ptr, T val);
// This intrinsic subtracts delta to the value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.sub.i#.p0i#")
T llvm_atomic_load_sub(T)(T* ptr, T val);
// These intrinsics bitwise the operation (and, nand, or, xor) delta to the value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.and.i#.p0i#")
T llvm_atomic_load_and(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.nand.i#.p0i#")
T llvm_atomic_load_nand(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.or.i#.p0i#")
T llvm_atomic_load_or(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.xor.i#.p0i#")
T llvm_atomic_load_xor(T)(T* ptr, T val);
// These intrinsics takes the signed or unsigned minimum or maximum of delta and the value stored in memory at ptr. It yields the original value at ptr.
pragma(intrinsic, "llvm.atomic.load.max.i#.p0i#")
T llvm_atomic_load_max(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.min.i#.p0i#")
T llvm_atomic_load_min(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.umax.i#.p0i#")
T llvm_atomic_load_umax(T)(T* ptr, T val);
pragma(intrinsic, "llvm.atomic.load.umin.i#.p0i#")
T llvm_atomic_load_umin(T)(T* ptr, T val);
//
// GENERAL INTRINSICS
//
// This intrinsics is lowered to the target dependent trap instruction. If the target does not have a trap instruction, this intrinsic will be lowered to the call of the abort() function.
pragma(intrinsic, "llvm.trap")
void llvm_trap();

32
druntime/import/ldc/vararg.di
View File

@@ -1,32 +0,0 @@
// D import file generated from 'vararg.d'
module ldc.Vararg;
version (LDC)
{
}
else
{
static assert(false,"This module is only valid for LDC");
}
alias void* va_list;
template va_start(T)
{
void va_start(out va_list ap, ref T parmn)
{
}
}
template va_arg(T)
{
T va_arg(ref va_list vp)
{
T* arg = cast(T*)vp;
vp = cast(va_list)(cast(void*)vp + (T.sizeof + size_t.sizeof - 1 & ~(size_t.sizeof - 1)));
return *arg;
}
}
void va_end(va_list ap)
{
}
void va_copy(out va_list dst, va_list src)
{
dst = src;
}

248
druntime/import/object.di
View File

@@ -1,248 +0,0 @@
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 invariant(char)[] string;
alias invariant(wchar)[] wstring;
alias invariant(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
void* deallocator;
OffsetTypeInfo[] offTi;
void* defaultConstructor;
const(MemberInfo[]) function(string) xgetMembers;
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
{
}
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; // module getMembers() function
void function() ictor; // module static constructor (order independent)
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
View File

@@ -1,32 +0,0 @@
/**
* 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
View File

@@ -1,176 +0,0 @@
/**
* 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.
*/
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
*/
int bsr( uint v );
/**
* Tests the bit.
*/
int bt( const 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 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>
*/
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 );

32
druntime/import/std/stdarg.di
View File

@@ -1,32 +0,0 @@
/**
* 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;
}
}

99
druntime/import/stdc/complex.d
View File

@@ -1,99 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.complex;
extern (C):
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);

30
druntime/import/stdc/config.d
View File

@@ -1,30 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module 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;
}
}

26
druntime/import/stdc/ctype.d
View File

@@ -1,26 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module 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);

375
druntime/import/stdc/errno.d
View File

@@ -1,375 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.errno;
private
{
extern (C) int getErrno();
extern (C) int setErrno(int);
}
int errno() { return getErrno(); }
int errno( int val ) { return setErrno( val ); }
extern (C):
version( Windows )
{
const EPERM = 1; // Operation not permitted
const ENOENT = 2; // No such file or directory
const ESRCH = 3; // No such process
const EINTR = 4; // Interrupted system call
const EIO = 5; // I/O error
const ENXIO = 6; // No such device or address
const E2BIG = 7; // Argument list too long
const ENOEXEC = 8; // Exec format error
const EBADF = 9; // Bad file number
const ECHILD = 10; // No child processes
const EAGAIN = 11; // Try again
const ENOMEM = 12; // Out of memory
const EACCES = 13; // Permission denied
const EFAULT = 14; // Bad address
const EBUSY = 16; // Device or resource busy
const EEXIST = 17; // File exists
const EXDEV = 18; // Cross-device link
const ENODEV = 19; // No such device
const ENOTDIR = 20; // Not a directory
const EISDIR = 21; // Is a directory
const EINVAL = 22; // Invalid argument
const ENFILE = 23; // File table overflow
const EMFILE = 24; // Too many open files
const ENOTTY = 25; // Not a typewriter
const EFBIG = 27; // File too large
const ENOSPC = 28; // No space left on device
const ESPIPE = 29; // Illegal seek
const EROFS = 30; // Read-only file system
const EMLINK = 31; // Too many links
const EPIPE = 32; // Broken pipe
const EDOM = 33; // Math argument out of domain of func
const ERANGE = 34; // Math result not representable
const EDEADLK = 36; // Resource deadlock would occur
const ENAMETOOLONG = 38; // File name too long
const ENOLCK = 39; // No record locks available
const ENOSYS = 40; // Function not implemented
const ENOTEMPTY = 41; // Directory not empty
const EILSEQ = 42; // Illegal byte sequence
const EDEADLOCK = EDEADLK;
}
else version( linux )
{
const EPERM = 1; // Operation not permitted
const ENOENT = 2; // No such file or directory
const ESRCH = 3; // No such process
const EINTR = 4; // Interrupted system call
const EIO = 5; // I/O error
const ENXIO = 6; // No such device or address
const E2BIG = 7; // Argument list too long
const ENOEXEC = 8; // Exec format error
const EBADF = 9; // Bad file number
const ECHILD = 10; // No child processes
const EAGAIN = 11; // Try again
const ENOMEM = 12; // Out of memory
const EACCES = 13; // Permission denied
const EFAULT = 14; // Bad address
const ENOTBLK = 15; // Block device required
const EBUSY = 16; // Device or resource busy
const EEXIST = 17; // File exists
const EXDEV = 18; // Cross-device link
const ENODEV = 19; // No such device
const ENOTDIR = 20; // Not a directory
const EISDIR = 21; // Is a directory
const EINVAL = 22; // Invalid argument
const ENFILE = 23; // File table overflow
const EMFILE = 24; // Too many open files
const ENOTTY = 25; // Not a typewriter
const ETXTBSY = 26; // Text file busy
const EFBIG = 27; // File too large
const ENOSPC = 28; // No space left on device
const ESPIPE = 29; // Illegal seek
const EROFS = 30; // Read-only file system
const EMLINK = 31; // Too many links
const EPIPE = 32; // Broken pipe
const EDOM = 33; // Math argument out of domain of func
const ERANGE = 34; // Math result not representable
const EDEADLK = 35; // Resource deadlock would occur
const ENAMETOOLONG = 36; // File name too long
const ENOLCK = 37; // No record locks available
const ENOSYS = 38; // Function not implemented
const ENOTEMPTY = 39; // Directory not empty
const ELOOP = 40; // Too many symbolic links encountered
const EWOULDBLOCK = EAGAIN; // Operation would block
const ENOMSG = 42; // No message of desired type
const EIDRM = 43; // Identifier removed
const ECHRNG = 44; // Channel number out of range
const EL2NSYNC = 45; // Level 2 not synchronized
const EL3HLT = 46; // Level 3 halted
const EL3RST = 47; // Level 3 reset
const ELNRNG = 48; // Link number out of range
const EUNATCH = 49; // Protocol driver not attached
const ENOCSI = 50; // No CSI structure available
const EL2HLT = 51; // Level 2 halted
const EBADE = 52; // Invalid exchange
const EBADR = 53; // Invalid request descriptor
const EXFULL = 54; // Exchange full
const ENOANO = 55; // No anode
const EBADRQC = 56; // Invalid request code
const EBADSLT = 57; // Invalid slot
const EDEADLOCK = EDEADLK;
const EBFONT = 59; // Bad font file format
const ENOSTR = 60; // Device not a stream
const ENODATA = 61; // No data available
const ETIME = 62; // Timer expired
const ENOSR = 63; // Out of streams resources
const ENONET = 64; // Machine is not on the network
const ENOPKG = 65; // Package not installed
const EREMOTE = 66; // Object is remote
const ENOLINK = 67; // Link has been severed
const EADV = 68; // Advertise error
const ESRMNT = 69; // Srmount error
const ECOMM = 70; // Communication error on send
const EPROTO = 71; // Protocol error
const EMULTIHOP = 72; // Multihop attempted
const EDOTDOT = 73; // RFS specific error
const EBADMSG = 74; // Not a data message
const EOVERFLOW = 75; // Value too large for defined data type
const ENOTUNIQ = 76; // Name not unique on network
const EBADFD = 77; // File descriptor in bad state
const EREMCHG = 78; // Remote address changed
const ELIBACC = 79; // Can not access a needed shared library
const ELIBBAD = 80; // Accessing a corrupted shared library
const ELIBSCN = 81; // .lib section in a.out corrupted
const ELIBMAX = 82; // Attempting to link in too many shared libraries
const ELIBEXEC = 83; // Cannot exec a shared library directly
const EILSEQ = 84; // Illegal byte sequence
const ERESTART = 85; // Interrupted system call should be restarted
const ESTRPIPE = 86; // Streams pipe error
const EUSERS = 87; // Too many users
const ENOTSOCK = 88; // Socket operation on non-socket
const EDESTADDRREQ = 89; // Destination address required
const EMSGSIZE = 90; // Message too long
const EPROTOTYPE = 91; // Protocol wrong type for socket
const ENOPROTOOPT = 92; // Protocol not available
const EPROTONOSUPPORT = 93; // Protocol not supported
const ESOCKTNOSUPPORT = 94; // Socket type not supported
const EOPNOTSUPP = 95; // Operation not supported on transport endpoint
const EPFNOSUPPORT = 96; // Protocol family not supported
const EAFNOSUPPORT = 97; // Address family not supported by protocol
const EADDRINUSE = 98; // Address already in use
const EADDRNOTAVAIL = 99; // Cannot assign requested address
const ENETDOWN = 100; // Network is down
const ENETUNREACH = 101; // Network is unreachable
const ENETRESET = 102; // Network dropped connection because of reset
const ECONNABORTED = 103; // Software caused connection abort
const ECONNRESET = 104; // Connection reset by peer
const ENOBUFS = 105; // No buffer space available
const EISCONN = 106; // Transport endpoint is already connected
const ENOTCONN = 107; // Transport endpoint is not connected
const ESHUTDOWN = 108; // Cannot send after transport endpoint shutdown
const ETOOMANYREFS = 109; // Too many references: cannot splice
const ETIMEDOUT = 110; // Connection timed out
const ECONNREFUSED = 111; // Connection refused
const EHOSTDOWN = 112; // Host is down
const EHOSTUNREACH = 113; // No route to host
const EALREADY = 114; // Operation already in progress
const EINPROGRESS = 115; // Operation now in progress
const ESTALE = 116; // Stale NFS file handle
const EUCLEAN = 117; // Structure needs cleaning
const ENOTNAM = 118; // Not a XENIX named type file
const ENAVAIL = 119; // No XENIX semaphores available
const EISNAM = 120; // Is a named type file
const EREMOTEIO = 121; // Remote I/O error
const EDQUOT = 122; // Quota exceeded
const ENOMEDIUM = 123; // No medium found
const EMEDIUMTYPE = 124; // Wrong medium type
const ECANCELED = 125; // Operation Canceled
const ENOKEY = 126; // Required key not available
const EKEYEXPIRED = 127; // Key has expired
const EKEYREVOKED = 128; // Key has been revoked
const EKEYREJECTED = 129; // Key was rejected by service
const EOWNERDEAD = 130; // Owner died
const ENOTRECOVERABLE = 131; // State not recoverable
}
else version( darwin )
{
const EPERM = 1; // Operation not permitted
const ENOENT = 2; // No such file or directory
const ESRCH = 3; // No such process
const EINTR = 4; // Interrupted system call
const EIO = 5; // Input/output error
const ENXIO = 6; // Device not configured
const E2BIG = 7; // Argument list too long
const ENOEXEC = 8; // Exec format error
const EBADF = 9; // Bad file descriptor
const ECHILD = 10; // No child processes
const EDEADLK = 11; // Resource deadlock avoided
const ENOMEM = 12; // Cannot allocate memory
const EACCES = 13; // Permission denied
const EFAULT = 14; // Bad address
const EBUSY = 16; // Device busy
const EEXIST = 17; // File exists
const EXDEV = 18; // Cross-device link
const ENODEV = 19; // Operation not supported by device
const ENOTDIR = 20; // Not a directory
const EISDIR = 21; // Is a directory
const EINVAL = 22; // Invalid argument
const ENFILE = 23; // Too many open files in system
const EMFILE = 24; // Too many open files
const ENOTTY = 25; // Inappropriate ioctl for device
const ETXTBSY = 26; // Text file busy
const EFBIG = 27; // File too large
const ENOSPC = 28; // No space left on device
const ESPIPE = 29; // Illegal seek
const EROFS = 30; // Read-only file system
const EMLINK = 31; // Too many links
const EPIPE = 32; // Broken pipe
const EDOM = 33; // Numerical argument out of domain
const ERANGE = 34; // Result too large
const EAGAIN = 35; // Resource temporarily unavailable
const EWOULDBLOCK = EAGAIN; // Operation would block
const EINPROGRESS = 36; // Operation now in progress
const EALREADY = 37; // Operation already in progress
const ENOTSOCK = 38; // Socket operation on non-socket
const EDESTADDRREQ = 39; // Destination address required
const EMSGSIZE = 40; // Message too long
const EPROTOTYPE = 41; // Protocol wrong type for socket
const ENOPROTOOPT = 42; // Protocol not available
const EPROTONOSUPPORT = 43; // Protocol not supported
const ENOTSUP = 45; // Operation not supported
const EOPNOTSUPP = ENOTSUP; // Operation not supported on socket
const EAFNOSUPPORT = 47; // Address family not supported by protocol family
const EADDRINUSE = 48; // Address already in use
const EADDRNOTAVAIL = 49; // Can't assign requested address
const ENETDOWN = 50; // Network is down
const ENETUNREACH = 51; // Network is unreachable
const ENETRESET = 52; // Network dropped connection on reset
const ECONNABORTED = 53; // Software caused connection abort
const ECONNRESET = 54; // Connection reset by peer
const ENOBUFS = 55; // No buffer space available
const EISCONN = 56; // Socket is already connected
const ENOTCONN = 57; // Socket is not connected
const ETIMEDOUT = 60; // Operation timed out
const ECONNREFUSED = 61; // Connection refused
const ELOOP = 62; // Too many levels of symbolic links
const ENAMETOOLONG = 63; // File name too long
const EHOSTUNREACH = 65; // No route to host
const ENOTEMPTY = 66; // Directory not empty
const EDQUOT = 69; // Disc quota exceeded
const ESTALE = 70; // Stale NFS file handle
const ENOLCK = 77; // No locks available
const ENOSYS = 78; // Function not implemented
const EOVERFLOW = 84; // Value too large to be stored in data type
const ECANCELED = 89; // Operation canceled
const EIDRM = 90; // Identifier removed
const ENOMSG = 91; // No message of desired type
const EILSEQ = 92; // Illegal byte sequence
const EBADMSG = 94; // Bad message
const EMULTIHOP = 95; // Reserved
const ENODATA = 96; // No message available on STREAM
const ENOLINK = 97; // Reserved
const ENOSR = 98; // No STREAM resources
const ENOSTR = 99; // Not a STREAM
const EPROTO = 100; // Protocol error
const ETIME = 101; // STREAM ioctl timeout
const ELAST = 101; // Must be equal largest errno
}
else version( freebsd )
{
const EPERM = 1; // Operation not permitted
const ENOENT = 2; // No such file or directory
const ESRCH = 3; // No such process
const EINTR = 4; // Interrupted system call
const EIO = 5; // Input/output error
const ENXIO = 6; // Device not configured
const E2BIG = 7; // Argument list too long
const ENOEXEC = 8; // Exec format error
const EBADF = 9; // Bad file descriptor
const ECHILD = 10; // No child processes
const EDEADLK = 11; // Resource deadlock avoided
const ENOMEM = 12; // Cannot allocate memory
const EACCES = 13; // Permission denied
const EFAULT = 14; // Bad address
const ENOTBLK = 15; // Block device required
const EBUSY = 16; // Device busy
const EEXIST = 17; // File exists
const EXDEV = 18; // Cross-device link
const ENODEV = 19; // Operation not supported by device
const ENOTDIR = 20; // Not a directory
const EISDIR = 21; // Is a directory
const EINVAL = 22; // Invalid argument
const ENFILE = 23; // Too many open files in system
const EMFILE = 24; // Too many open files
const ENOTTY = 25; // Inappropriate ioctl for device
const ETXTBSY = 26; // Text file busy
const EFBIG = 27; // File too large
const ENOSPC = 28; // No space left on device
const ESPIPE = 29; // Illegal seek
const EROFS = 30; // Read-only file system
const EMLINK = 31; // Too many links
const EPIPE = 32; // Broken pipe
const EDOM = 33; // Numerical argument out of domain
const ERANGE = 34; // Result too large
const EAGAIN = 35; // Resource temporarily unavailable
const EWOULDBLOCK = EAGAIN; // Operation would block
const EINPROGRESS = 36; // Operation now in progress
const EALREADY = 37; // Operation already in progress
const ENOTSOCK = 38; // Socket operation on non-socket
const EDESTADDRREQ = 39; // Destination address required
const EMSGSIZE = 40; // Message too long
const EPROTOTYPE = 41; // Protocol wrong type for socket
const ENOPROTOOPT = 42; // Protocol not available
const EPROTONOSUPPORT = 43; // Protocol not supported
const ENOTSUP = 45; // Operation not supported
const EOPNOTSUPP = ENOTSUP; // Operation not supported on socket
const EAFNOSUPPORT = 47; // Address family not supported by protocol family
const EADDRINUSE = 48; // Address already in use
const EADDRNOTAVAIL = 49; // Can't assign requested address
const ENETDOWN = 50; // Network is down
const ENETUNREACH = 51; // Network is unreachable
const ENETRESET = 52; // Network dropped connection on reset
const ECONNABORTED = 53; // Software caused connection abort
const ECONNRESET = 54; // Connection reset by peer
const ENOBUFS = 55; // No buffer space available
const EISCONN = 56; // Socket is already connected
const ENOTCONN = 57; // Socket is not connected
const ESHUTDOWN = 58; // Can't send after socket shutdown
const ETOOMANYREFS = 59; // Too many refrences; can't splice
const ETIMEDOUT = 60; // Operation timed out
const ECONNREFUSED = 61; // Connection refused
const ELOOP = 62; // Too many levels of symbolic links
const ENAMETOOLONG = 63; // File name too long
const EHOSTUNREACH = 65; // No route to host
const ENOTEMPTY = 66; // Directory not empty
const EPROCLIM = 67; // Too many processes
const EUSERS = 68; // Too many users
const EDQUOT = 69; // Disc quota exceeded
const ESTALE = 70; // Stale NFS file handle
const EREMOTE = 71; // Too many levels of remote in path
const EBADRPC = 72; // RPC struct is bad
const ERPCMISMATCH = 73; // RPC version wrong
const EPROGUNAVAIL = 74; // RPC prog. not avail
const EPROGMISMATCH = 75; // Program version wrong
const EPROCUNAVAIL = 76; // Bad procedure for program
const ENOLCK = 77; // No locks available
const ENOSYS = 78; // Function not implemented
const EFTYPE = 79; // Inappropriate file type or format
const EAUTH = 80; // Authentication error
const ENEEDAUTH = 81; // Need authenticator
const EIDRM = 82; // Itendifier removed
const ENOMSG = 83; // No message of desired type
const EOVERFLOW = 84; // Value too large to be stored in data type
const ECANCELED = 85; // Operation canceled
const EILSEQ = 86; // Illegal byte sequence
const ENOATTR = 87; // Attribute not found
const EDOOFUS = 88; // Programming error
const EBADMSG = 89; // Bad message
const EMULTIHOP = 90; // Multihop attempted
const ENOLINK = 91; // Link has been severed
const EPROTO = 92; // Protocol error
const ELAST = 92; // Must be equal largest errno
}

137
druntime/import/stdc/fenv.d
View File

@@ -1,137 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly, Walter Bright
* Standards: ISO/IEC 9899:1999 (E)
*/
module 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 ( darwin )
{
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( darwin )
{
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);

252
druntime/import/stdc/inttypes.d
View File

@@ -1,252 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.inttypes;
public import stdc.stddef;
public import stdc.stdint;
extern (C):
struct imaxdiv_t
{
intmax_t quot,
rem;
}
version( VerboseC )
{
const char* PRId8 = "hhd";
const char* PRId16 = "hd";
const char* PRId32 = "ld";
const char* PRId64 = "lld";
const char* PRIdLEAST8 = "hhd";
const char* PRIdLEAST16 = "hd";
const char* PRIdLEAST32 = "ld";
const char* PRIdLEAST64 = "lld";
const char* PRIdFAST8 = "hhd";
const char* PRIdFAST16 = "d";
const char* PRIdFAST32 = "ld";
const char* PRIdFAST64 = "lld";
const char* PRIi8 = "hhi";
const char* PRIi16 = "hi";
const char* PRIi32 = "li";
const char* PRIi64 = "lli";
const char* PRIiLEAST8 = "hhi";
const char* PRIiLEAST16 = "hi";
const char* PRIiLEAST32 = "li";
const char* PRIiLEAST64 = "lli";
const char* PRIiFAST8 = "hhi";
const char* PRIiFAST16 = "i";
const char* PRIiFAST32 = "li";
const char* PRIiFAST64 = "lli";
const char* PRIo8 = "hho";
const char* PRIo16 = "ho";
const char* PRIo32 = "lo";
const char* PRIo64 = "llo";
const char* PRIoLEAST8 = "hho";
const char* PRIoLEAST16 = "ho";
const char* PRIoLEAST32 = "lo";
const char* PRIoLEAST64 = "llo";
const char* PRIoFAST8 = "hho";
const char* PRIoFAST16 = "o";
const char* PRIoFAST32 = "lo";
const char* PRIoFAST64 = "llo";
const char* PRIu8 = "hhu";
const char* PRIu16 = "hu";
const char* PRIu32 = "lu";
const char* PRIu64 = "llu";
const char* PRIuLEAST8 = "hhu";
const char* PRIuLEAST16 = "hu";
const char* PRIuLEAST32 = "lu";
const char* PRIuLEAST64 = "llu";
const char* PRIuFAST8 = "hhu";
const char* PRIuFAST16 = "u";
const char* PRIuFAST32 = "lu";
const char* PRIuFAST64 = "llu";
const char* PRIx8 = "hhx";
const char* PRIx16 = "hx";
const char* PRIx32 = "lx";
const char* PRIx64 = "llx";
const char* PRIxLEAST8 = "hhx";
const char* PRIxLEAST16 = "hx";
const char* PRIxLEAST32 = "lx";
const char* PRIxLEAST64 = "llx";
const char* PRIxFAST8 = "hhx";
const char* PRIxFAST16 = "x";
const char* PRIxFAST32 = "lx";
const char* PRIxFAST64 = "llx";
const char* PRIX8 = "hhX";
const char* PRIX16 = "hX";
const char* PRIX32 = "lX";
const char* PRIX64 = "llX";
const char* PRIXLEAST8 = "hhX";
const char* PRIXLEAST16 = "hX";
const char* PRIXLEAST32 = "lX";
const char* PRIXLEAST64 = "llX";
const char* PRIXFAST8 = "hhX";
const char* PRIXFAST16 = "X";
const char* PRIXFAST32 = "lX";
const char* PRIXFAST64 = "llX";
const char* SCNd8 = "hhd";
const char* SCNd16 = "hd";
const char* SCNd32 = "ld";
const char* SCNd64 = "lld";
const char* SCNdLEAST8 = "hhd";
const char* SCNdLEAST16 = "hd";
const char* SCNdLEAST32 = "ld";
const char* SCNdLEAST64 = "lld";
const char* SCNdFAST8 = "hhd";
const char* SCNdFAST16 = "d";
const char* SCNdFAST32 = "ld";
const char* SCNdFAST64 = "lld";
const char* SCNi8 = "hhd";
const char* SCNi16 = "hi";
const char* SCNi32 = "li";
const char* SCNi64 = "lli";
const char* SCNiLEAST8 = "hhd";
const char* SCNiLEAST16 = "hi";
const char* SCNiLEAST32 = "li";
const char* SCNiLEAST64 = "lli";
const char* SCNiFAST8 = "hhd";
const char* SCNiFAST16 = "i";
const char* SCNiFAST32 = "li";
const char* SCNiFAST64 = "lli";
const char* SCNo8 = "hhd";
const char* SCNo16 = "ho";
const char* SCNo32 = "lo";
const char* SCNo64 = "llo";
const char* SCNoLEAST8 = "hhd";
const char* SCNoLEAST16 = "ho";
const char* SCNoLEAST32 = "lo";
const char* SCNoLEAST64 = "llo";
const char* SCNoFAST8 = "hhd";
const char* SCNoFAST16 = "o";
const char* SCNoFAST32 = "lo";
const char* SCNoFAST64 = "llo";
const char* SCNu8 = "hhd";
const char* SCNu16 = "hu";
const char* SCNu32 = "lu";
const char* SCNu64 = "llu";
const char* SCNuLEAST8 = "hhd";
const char* SCNuLEAST16 = "hu";
const char* SCNuLEAST32 = "lu";
const char* SCNuLEAST64 = "llu";
const char* SCNuFAST8 = "hhd";
const char* SCNuFAST16 = "u";
const char* SCNuFAST32 = "lu";
const char* SCNuFAST64 = "llu";
const char* SCNx8 = "hhd";
const char* SCNx16 = "hx";
const char* SCNx32 = "lx";
const char* SCNx64 = "llx";
const char* SCNxLEAST8 = "hhd";
const char* SCNxLEAST16 = "hx";
const char* SCNxLEAST32 = "lx";
const char* SCNxLEAST64 = "llx";
const char* SCNxFAST8 = "hhd";
const char* SCNxFAST16 = "x";
const char* SCNxFAST32 = "lx";
const char* SCNxFAST64 = "llx";
version( X86_64 )
{
const char* PRIdMAX = PRId64;
const char* PRIiMAX = PRIi64;
const char* PRIoMAX = PRIo64;
const char* PRIuMAX = PRIu64;
const char* PRIxMAX = PRIx64;
const char* PRIXMAX = PRIX64;
const char* SCNdMAX = SCNd64;
const char* SCNiMAX = SCNi64;
const char* SCNoMAX = SCNo64;
const char* SCNuMAX = SCNu64;
const char* SCNxMAX = SCNx64;
const char* PRIdPTR = PRId64;
const char* PRIiPTR = PRIi64;
const char* PRIoPTR = PRIo64;
const char* PRIuPTR = PRIu64;
const char* PRIxPTR = PRIx64;
const char* PRIXPTR = PRIX64;
const char* SCNdPTR = SCNd64;
const char* SCNiPTR = SCNi64;
const char* SCNoPTR = SCNo64;
const char* SCNuPTR = SCNu64;
const char* SCNxPTR = SCNx64;
}
else
{
const char* PRIdMAX = PRId32;
const char* PRIiMAX = PRIi32;
const char* PRIoMAX = PRIo32;
const char* PRIuMAX = PRIu32;
const char* PRIxMAX = PRIx32;
const char* PRIXMAX = PRIX32;
const char* SCNdMAX = SCNd32;
const char* SCNiMAX = SCNi32;
const char* SCNoMAX = SCNo32;
const char* SCNuMAX = SCNu32;
const char* SCNxMAX = SCNx32;
const char* PRIdPTR = PRId32;
const char* PRIiPTR = PRIi32;
const char* PRIoPTR = PRIo32;
const char* PRIuPTR = PRIu32;
const char* PRIxPTR = PRIx32;
const char* PRIXPTR = PRIX32;
const char* SCNdPTR = SCNd32;
const char* SCNiPTR = SCNi32;
const char* SCNoPTR = SCNo32;
const char* SCNuPTR = SCNu32;
const char* 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);

33
druntime/import/stdc/limits.d
View File

@@ -1,33 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.limits;
private import stdc.config;
extern (C):
const CHAR_BIT = 8;
const SCHAR_MIN = byte.min;
const SCHAR_MAX = byte.max;
const UCHAR_MAX = ubyte.min;
const CHAR_MIN = char.max;
const CHAR_MAX = char.max;
const MB_LEN_MAX = 2;
const SHRT_MIN = short.min;
const SHRT_MAX = short.max;
const USHRT_MAX = ushort.max;
const INT_MIN = int.min;
const INT_MAX = int.max;
const UINT_MAX = uint.max;
const LONG_MIN = c_long.min;
const LONG_MAX = c_long.max;
const ULONG_MAX = c_ulong.max;
const LLONG_MIN = long.min;
const LLONG_MAX = long.max;
const ULLONG_MAX = ulong.max;

55
druntime/import/stdc/locale.d
View File

@@ -1,55 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module 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;
}
const LC_CTYPE = 0;
const LC_NUMERIC = 1;
const LC_TIME = 2;
const LC_COLLATE = 3;
const LC_MONETARY = 4;
const LC_ALL = 6;
const LC_PAPER = 7;
const LC_NAME = 8;
const LC_ADDRESS = 9;
const LC_TELEPHONE = 10;
const LC_MEASUREMENT = 11;
const LC_IDENTIFICATION = 12;
char* setlocale(int category, in char* locale);
lconv* localeconv();

928
druntime/import/stdc/math.d
View File

@@ -1,928 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly, Walter Bright
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.math;
private import stdc.config;
extern (C):
alias float float_t;
alias double double_t;
const double HUGE_VAL = double.infinity;
const double HUGE_VALF = float.infinity;
const double HUGE_VALL = real.infinity;
const float INFINITY = float.infinity;
const float NAN = float.nan;
const int FP_ILOGB0 = int.min;
const int FP_ILOGBNAN = int.min;
const int MATH_ERRNO = 1;
const int MATH_ERREXCEPT = 2;
const 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( darwin )
{
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 const 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);
}

127
druntime/import/stdc/posix/arpa/inet.d
View File

@@ -1,127 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.arpa.inet;
private import stdc.posix.config;
public import stdc.inttypes : uint32_t, uint16_t;
public import stdc.posix.sys.socket : socklen_t;
extern (C):
//
// Required
//
/*
in_port_t // from stdc.posix.netinet.in_
in_addr_t // from stdc.posix.netinet.in_
struct in_addr // from stdc.posix.netinet.in_
INET_ADDRSTRLEN // from stdc.posix.netinet.in_
uint32_t // from stdc.inttypes
uint16_t // from 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;
}
const 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( darwin )
{
alias uint16_t in_port_t; // TODO: verify
alias uint32_t in_addr_t; // TODO: verify
struct in_addr
{
in_addr_t s_addr;
}
const 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;
}
const 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 stdc.posix.netinet.in_
*/
version( linux )
{
const INET6_ADDRSTRLEN = 46;
}
else version( darwin )
{
const INET6_ADDRSTRLEN = 46;
}
else version( freebsd )
{
const INET6_ADDRSTRLEN = 46;
}

27
druntime/import/stdc/posix/config.d
View File

@@ -1,27 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.config;
public import stdc.config;
extern (C):
version( linux )
{
version( none /* X86_64 */ )
{
const bool __USE_LARGEFILE64 = true;
}
else
{
const bool __USE_LARGEFILE64 = false;
}
const bool __USE_FILE_OFFSET64 = __USE_LARGEFILE64;
const bool __REDIRECT = false;
}

198
druntime/import/stdc/posix/dirent.d
View File

@@ -1,198 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.dirent;
private import stdc.posix.config;
public import stdc.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( darwin )
{
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 readdir_r64(DIR*, dirent*, dirent**);
alias readdir_r64 readdir_r;
}
else
{
int readdir_r(DIR*, dirent*, dirent**);
}
}
else version( darwin )
{
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*);
}

65
druntime/import/stdc/posix/dlfcn.d
View File

@@ -1,65 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.dlfcn;
private import stdc.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 )
{
const RTLD_LAZY = 0x00001;
const RTLD_NOW = 0x00002;
const RTLD_GLOBAL = 0x00100;
const RTLD_LOCAL = 0x00000;
int dlclose(void*);
char* dlerror();
void* dlopen(in char*, int);
void* dlsym(void*, in char*);
}
else version( darwin )
{
const RTLD_LAZY = 0x00001;
const RTLD_NOW = 0x00002;
const RTLD_GLOBAL = 0x00100;
const RTLD_LOCAL = 0x00000;
int dlclose(void*);
char* dlerror();
void* dlopen(in char*, int);
void* dlsym(void*, in char*);
}
else version( freebsd )
{
const RTLD_LAZY = 1;
const RTLD_NOW = 2;
const RTLD_GLOBAL = 0x100;
const RTLD_LOCAL = 0;
int dlclose(void*);
char* dlerror();
void* dlopen(in char*, int);
void* dlsym(void*, in char*);
}

248
druntime/import/stdc/posix/fcntl.d
View File

@@ -1,248 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.fcntl;
private import stdc.posix.config;
private import stdc.stdint;
public import stdc.stddef; // for size_t
public import stdc.posix.sys.types; // for off_t, mode_t
public import stdc.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 )
{
const F_DUPFD = 0;
const F_GETFD = 1;
const F_SETFD = 2;
const F_GETFL = 3;
const F_SETFL = 4;
static if( __USE_FILE_OFFSET64 )
{
const F_GETLK = 12;
const F_SETLK = 13;
const F_SETLKW = 14;
}
else
{
const F_GETLK = 5;
const F_SETLK = 6;
const F_SETLKW = 7;
}
const F_GETOWN = 9;
const F_SETOWN = 8;
const FD_CLOEXEC = 1;
const F_RDLCK = 0;
const F_UNLCK = 2;
const F_WRLCK = 1;
const O_CREAT = 0100;
const O_EXCL = 0200;
const O_NOCTTY = 0400;
const O_TRUNC = 01000;
const O_APPEND = 02000;
const O_NONBLOCK = 04000;
const O_SYNC = 010000;
const O_DSYNC = O_SYNC;
const O_RSYNC = O_SYNC;
const O_ACCMODE = 0003;
const O_RDONLY = 00;
const O_WRONLY = 01;
const 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( darwin )
{
const F_DUPFD = 0;
const F_GETFD = 1;
const F_SETFD = 2;
const F_GETFL = 3;
const F_SETFL = 4;
const F_GETOWN = 5;
const F_SETOWN = 6;
const F_GETLK = 7;
const F_SETLK = 8;
const F_SETLKW = 9;
const FD_CLOEXEC = 1;
const F_RDLCK = 1;
const F_UNLCK = 2;
const F_WRLCK = 3;
const O_CREAT = 0x0200;
const O_EXCL = 0x0800;
const O_NOCTTY = 0;
const O_TRUNC = 0x0400;
const O_RDONLY = 0x0000;
const O_WRONLY = 0x0001;
const O_RDWR = 0x0002;
const O_ACCMODE = 0x0003;
const O_NONBLOCK = 0x0004;
const O_APPEND = 0x0008;
const O_SYNC = 0x0080;
//const O_DSYNC
//const 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 )
{
const F_DUPFD = 0;
const F_GETFD = 1;
const F_SETFD = 2;
const F_GETFL = 3;
const F_SETFL = 4;
const F_GETOWN = 5;
const F_SETOWN = 6;
const F_GETLK = 7;
const F_SETLK = 8;
const F_SETLKW = 9;
const FD_CLOEXEC = 1;
const F_RDLCK = 1;
const F_UNLCK = 2;
const F_WRLCK = 3;
const O_CREAT = 0x0200;
const O_EXCL = 0x0800;
const O_NOCTTY = 0;
const O_TRUNC = 0x0400;
const O_RDONLY = 0x0000;
const O_WRONLY = 0x0001;
const O_RDWR = 0x0002;
const O_ACCMODE = 0x0003;
const O_NONBLOCK = 0x0004;
const O_APPEND = 0x0008;
const O_SYNC = 0x0080;
//const O_DSYNC
//const 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);
*/

30
druntime/import/stdc/posix/inttypes.d
View File

@@ -1,30 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.inttypes;
private import stdc.posix.config;
public import 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);

77
druntime/import/stdc/posix/net/if_.d
View File

@@ -1,77 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.net.if_;
private import stdc.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;
}
const 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( darwin )
{
struct if_nameindex_t
{
uint if_index;
char* if_name;
}
const 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;
}
const IF_NAMESIZE = 16;
uint if_nametoindex(in char*);
char* if_indextoname(uint, char*);
if_nameindex_t* if_nameindex();
void if_freenameindex(if_nameindex_t*);
}

327
druntime/import/stdc/posix/netinet/in_.d
View File

@@ -1,327 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.netinet.in_;
private import stdc.posix.config;
public import stdc.inttypes : uint32_t, uint16_t, uint8_t;
public import stdc.posix.arpa.inet;
public import stdc.posix.sys.socket; // for sa_family_t
extern (C):
//
// Required
//
/*
NOTE: The following must must be defined in stdc.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 stdc.posix.sys.socket
uint8_t // from stdc.inttypes
uint32_t // from 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 stdc.posix.arpa.inet
htons() // from stdc.posix.arpa.inet
ntohl() // from stdc.posix.arpa.inet
ntohs() // from stdc.posix.arpa.inet
*/
version( linux )
{
private const __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
}
const uint INADDR_ANY = 0x00000000;
const uint INADDR_BROADCAST = 0xffffffff;
}
else version( darwin )
{
private const __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
}
const uint INADDR_ANY = 0x00000000;
const uint INADDR_BROADCAST = 0xffffffff;
}
else version( freebsd )
{
private const __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
}
const uint INADDR_ANY = 0x00000000;
const uint INADDR_BROADCAST = 0xffffffff;
}
//
// IPV6 (IP6)
//
/*
NOTE: The following must must be defined in stdc.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;
}
}
//
// Raw Sockets (RS)
//
/*
IPPROTO_RAW
*/
version (linux )
{
const uint IPPROTO_RAW = 255;
}

33
druntime/import/stdc/posix/netinet/tcp.d
View File

@@ -1,33 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.netinet.tcp;
private import stdc.posix.config;
extern (C):
//
// Required
//
/*
TCP_NODELAY
*/
version( linux )
{
const TCP_NODELAY = 1;
}
else version( darwin )
{
const TCP_NODELAY = 1;
}
else version( freebsd )
{
const TCP_NODELAY = 1;
}

133
druntime/import/stdc/posix/poll.d
View File

@@ -1,133 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.poll;
private import stdc.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;
const POLLIN = 0x001;
const POLLRDNORM = 0x040;
const POLLRDBAND = 0x080;
const POLLPRI = 0x002;
const POLLOUT = 0x004;
const POLLWRNORM = 0x100;
const POLLWRBAND = 0x200;
const POLLERR = 0x008;
const POLLHUP = 0x010;
const POLLNVAL = 0x020;
int poll(pollfd*, nfds_t, int);
}
else version( darwin )
{
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);
}

580
druntime/import/stdc/posix/pthread.d
View File

@@ -1,580 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.pthread;
private import stdc.posix.config;
public import stdc.posix.sys.types;
public import stdc.posix.sched;
public import stdc.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
}
const PTHREAD_CANCELED = cast(void*) -1;
//const 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
}
//const pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
const PTHREAD_ONCE_INIT = 0;
enum
{
PTHREAD_PROCESS_PRIVATE,
PTHREAD_PROCESS_SHARED
}
}
else version( darwin )
{
enum
{
PTHREAD_CANCEL_ENABLE = 1,
PTHREAD_CANCEL_DISABLE = 0
}
enum
{
PTHREAD_CANCEL_DEFERRED = 2,
PTHREAD_CANCEL_ASYNCHRONOUS = 0
}
const PTHREAD_CANCELED = cast(void*) -1;
//const 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
}
//const pthread_mutex_t PTHREAD_MUTEX_INITIALIZER = { 0, 0, null, PTHREAD_MUTEX_NORMAL, { 0, 0 } };
const 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( darwin )
{
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 )
{
const 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 )
{
const PTHREAD_MUTEX_NORMAL = 0;
const PTHREAD_MUTEX_RECURSIVE = 1;
const PTHREAD_MUTEX_ERRORCHECK = 2;
const 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( darwin )
{
const PTHREAD_MUTEX_NORMAL = 0;
const PTHREAD_MUTEX_ERRORCHECK = 1;
const PTHREAD_MUTEX_RECURSIVE = 2;
const 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
}
const 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( darwin )
{
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( darwin )
{
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( darwin )
{
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);
*/

132
druntime/import/stdc/posix/pwd.d
View File

@@ -1,132 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.pwd;
private import stdc.posix.config;
public import stdc.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( darwin )
{
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( darwin )
{
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 ( darwin )
{
void endpwent();
passwd* getpwent();
void setpwent();
}
else version ( freebsd )
{
void endpwent();
passwd* getpwent();
void setpwent();
}

132
druntime/import/stdc/posix/sched.d
View File

@@ -1,132 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sched;
private import stdc.posix.config;
public import stdc.posix.time;
public import stdc.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;
}
const SCHED_OTHER = 0;
const SCHED_FIFO = 1;
const SCHED_RR = 2;
//SCHED_SPORADIC (SS|TSP)
}
else version( darwin )
{
const SCHED_OTHER = 1;
const SCHED_FIFO = 4;
const SCHED_RR = 2;
// SCHED_SPORADIC seems to be unavailable
private const __SCHED_PARAM_SIZE__ = 4;
struct sched_param
{
int sched_priority;
byte[__SCHED_PARAM_SIZE__] opaque;
}
}
else version( freebsd )
{
struct sched_param
{
int sched_priority;
}
const SCHED_FIFO = 1;
const SCHED_OTHER = 2;
const 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( darwin )
{
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( darwin )
{
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*);
}

97
druntime/import/stdc/posix/semaphore.d
View File

@@ -1,97 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.semaphore;
private import stdc.posix.config;
private import stdc.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;
}
const SEM_FAILED = cast(sem_t*) null;
}
else version( darwin )
{
alias int sem_t;
const SEM_FAILED = cast(sem_t*) null;
}
else version( freebsd )
{
const uint SEM_MAGIC = 0x09fa4012;
const SEM_USER = 0;
alias void* sem_t;
const 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( darwin )
{
int sem_timedwait(sem_t*, in timespec*);
}
else version( freebsd )
{
int sem_timedwait(sem_t*, in timespec*);
}

103
druntime/import/stdc/posix/setjmp.d
View File

@@ -1,103 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.setjmp;
private import stdc.posix.config;
private import stdc.posix.signal; // for sigset_t
extern (C):
//
// Required
//
/*
jmp_buf
int setjmp(jmp_buf);
void longjmp(jmp_buf, int);
*/
version( linux )
{
version( X86_64 )
{
//const JB_BX = 0;
//const JB_BP = 1;
//const JB_12 = 2;
//const JB_13 = 3;
//const JB_14 = 4;
//const JB_15 = 5;
//const JB_SP = 6;
//const JB_PC = 7;
//const JB_SIZE = 64;
alias long[8] __jmp_buf;
}
else version( X86 )
{
//const JB_BX = 0;
//const JB_SI = 1;
//const JB_DI = 2;
//const JB_BP = 3;
//const JB_SP = 4;
//const JB_PC = 5;
//const 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);
}

837
druntime/import/stdc/posix/signal.d
View File

@@ -1,837 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.signal;
private import stdc.posix.config;
public import stdc.signal;
public import stdc.stddef; // for size_t
public import stdc.posix.sys.types; // for pid_t
//public import stdc.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 stdc.signal)
SIG_ERR (defined in stdc.signal)
SIG_IGN (defined in stdc.signal)
sig_atomic_t (defined in stdc.signal)
SIGEV_NONE
SIGEV_SIGNAL
SIGEV_THREAD
union sigval
{
int sival_int;
void* sival_ptr;
}
SIGRTMIN
SIGRTMAX
SIGABRT (defined in stdc.signal)
SIGALRM
SIGBUS
SIGCHLD
SIGCONT
SIGFPE (defined in stdc.signal)
SIGHUP
SIGILL (defined in stdc.signal)
SIGINT (defined in stdc.signal)
SIGKILL
SIGPIPE
SIGQUIT
SIGSEGV (defined in stdc.signal)
SIGSTOP
SIGTERM (defined in 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 stdc.signal)
int raise(int sig); (defined in stdc.signal)
*/
//SIG_DFL (defined in stdc.signal)
//SIG_ERR (defined in stdc.signal)
//SIG_IGN (defined in stdc.signal)
//sig_atomic_t (defined in 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 stdc.signal)
const SIGALRM = 14;
const SIGBUS = 7;
const SIGCHLD = 17;
const SIGCONT = 18;
//SIGFPE (defined in stdc.signal)
const SIGHUP = 1;
//SIGILL (defined in stdc.signal)
//SIGINT (defined in stdc.signal)
const SIGKILL = 9;
const SIGPIPE = 13;
const SIGQUIT = 3;
//SIGSEGV (defined in stdc.signal)
const SIGSTOP = 19;
//SIGTERM (defined in stdc.signal)
const SIGTSTP = 20;
const SIGTTIN = 21;
const SIGTTOU = 22;
const SIGUSR1 = 10;
const SIGUSR2 = 12;
const SIGURG = 23;
}
else version( darwin )
{
//SIGABRT (defined in stdc.signal)
const SIGALRM = 14;
const SIGBUS = 10;
const SIGCHLD = 20;
const SIGCONT = 19;
//SIGFPE (defined in stdc.signal)
const SIGHUP = 1;
//SIGILL (defined in stdc.signal)
//SIGINT (defined in stdc.signal)
const SIGKILL = 9;
const SIGPIPE = 13;
const SIGQUIT = 3;
//SIGSEGV (defined in stdc.signal)
const SIGSTOP = 17;
//SIGTERM (defined in stdc.signal)
const SIGTSTP = 18;
const SIGTTIN = 21;
const SIGTTOU = 22;
const SIGUSR1 = 30;
const SIGUSR2 = 31;
const SIGURG = 16;
}
else version( freebsd )
{
//SIGABRT (defined in stdc.signal)
const SIGALRM = 14;
const SIGBUS = 10;
const SIGCHLD = 20;
const SIGCONT = 19;
//SIGFPE (defined in stdc.signal)
const SIGHUP = 1;
//SIGILL (defined in stdc.signal)
//SIGINT (defined in stdc.signal)
const SIGKILL = 9;
const SIGPIPE = 13;
const SIGQUIT = 3;
//SIGSEGV (defined in stdc.signal)
const SIGSTOP = 17;
//SIGTERM (defined in stdc.signal)
const SIGTSTP = 18;
const SIGTTIN = 21;
const SIGTTOU = 22;
const SIGUSR1 = 30;
const SIGUSR2 = 31;
const 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( darwin ) {} else {
void function() sa_restorer;
}
}
//
// C Extension (CX)
//
/*
SIG_HOLD
sigset_t
pid_t (defined in sys.types)
SIGABRT (defined in stdc.signal)
SIGFPE (defined in stdc.signal)
SIGILL (defined in stdc.signal)
SIGINT (defined in stdc.signal)
SIGSEGV (defined in stdc.signal)
SIGTERM (defined in 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 )
{
const SIG_HOLD = cast(sigfn_t) 1;
private const _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof);
struct sigset_t
{
c_ulong[_SIGSET_NWORDS] __val;
}
// pid_t (defined in sys.types)
//SIGABRT (defined in stdc.signal)
//SIGFPE (defined in stdc.signal)
//SIGILL (defined in stdc.signal)
//SIGINT (defined in stdc.signal)
//SIGSEGV (defined in stdc.signal)
//SIGTERM (defined in stdc.signal)
const SA_NOCLDSTOP = 1; // (CX|XSI)
const SIG_BLOCK = 0;
const SIG_UNBLOCK = 1;
const SIG_SETMASK = 2;
private const __SI_MAX_SIZE = 128;
static if( false /* __WORDSIZE == 64 */ )
{
private const __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
}
else
{
private const __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( darwin )
{
//SIG_HOLD
alias uint sigset_t;
// pid_t (defined in sys.types)
//SIGABRT (defined in stdc.signal)
//SIGFPE (defined in stdc.signal)
//SIGILL (defined in stdc.signal)
//SIGINT (defined in stdc.signal)
//SIGSEGV (defined in stdc.signal)
//SIGTERM (defined in 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 )
{
const SIGPOLL = 29;
const SIGPROF = 27;
const SIGSYS = 31;
const SIGTRAP = 5;
const SIGVTALRM = 26;
const SIGXCPU = 24;
const SIGXFSZ = 25;
const SA_ONSTACK = 0x08000000;
const SA_RESETHAND = 0x80000000;
const SA_RESTART = 0x10000000;
const SA_SIGINFO = 4;
const SA_NOCLDWAIT = 2;
const SA_NODEFER = 0x40000000;
const SS_ONSTACK = 1;
const SS_DISABLE = 2;
const MINSIGSTKSZ = 2048;
const SIGSTKSZ = 8192;
//ucontext_t (defined in stdc.posix.ucontext)
//mcontext_t (defined in stdc.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 stdc.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( darwin )
{
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 const __SIGEV_MAX_SIZE = 64;
static if( false /* __WORDSIZE == 64 */ )
{
private const __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
}
else
{
private const __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( darwin )
{
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*);
}

214
druntime/import/stdc/posix/stdio.d
View File

@@ -1,214 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.stdio;
private import stdc.posix.config;
public import stdc.stdio;
public import stdc.posix.sys.types; // for off_t
extern (C):
//
// Required (defined in 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 )
{
const 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 stdc.stdarg)
char* tempnam(in char*, in char*);
*/
version( linux )
{
const P_tmpdir = "/tmp";
char* tempnam(in char*, in char*);
}

305
druntime/import/stdc/posix/stdlib.d
View File

@@ -1,305 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.stdlib;
private import stdc.posix.config;
public import stdc.stdlib;
public import stdc.posix.sys.wait;
extern (C):
//
// Required (defined in 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( darwin )
{
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( darwin )
{
int rand_r(uint*);
}
else version( freebsd )
{
int rand_r(uint*);
}
//
// XOpen (XSI)
//
/*
WNOHANG (defined in stdc.posix.sys.wait)
WUNTRACED (defined in stdc.posix.sys.wait)
WEXITSTATUS (defined in stdc.posix.sys.wait)
WIFEXITED (defined in stdc.posix.sys.wait)
WIFSIGNALED (defined in stdc.posix.sys.wait)
WIFSTOPPED (defined in stdc.posix.sys.wait)
WSTOPSIG (defined in stdc.posix.sys.wait)
WTERMSIG (defined in stdc.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 stdc.posix.sys.wait)
//WUNTRACED (defined in stdc.posix.sys.wait)
//WEXITSTATUS (defined in stdc.posix.sys.wait)
//WIFEXITED (defined in stdc.posix.sys.wait)
//WIFSIGNALED (defined in stdc.posix.sys.wait)
//WIFSTOPPED (defined in stdc.posix.sys.wait)
//WSTOPSIG (defined in stdc.posix.sys.wait)
//WTERMSIG (defined in stdc.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( darwin )
{
//WNOHANG (defined in stdc.posix.sys.wait)
//WUNTRACED (defined in stdc.posix.sys.wait)
//WEXITSTATUS (defined in stdc.posix.sys.wait)
//WIFEXITED (defined in stdc.posix.sys.wait)
//WIFSIGNALED (defined in stdc.posix.sys.wait)
//WIFSTOPPED (defined in stdc.posix.sys.wait)
//WSTOPSIG (defined in stdc.posix.sys.wait)
//WTERMSIG (defined in stdc.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 stdc.posix.sys.wait)
//WUNTRACED (defined in stdc.posix.sys.wait)
//WEXITSTATUS (defined in stdc.posix.sys.wait)
//WIFEXITED (defined in stdc.posix.sys.wait)
//WIFSIGNALED (defined in stdc.posix.sys.wait)
//WIFSTOPPED (defined in stdc.posix.sys.wait)
//WSTOPSIG (defined in stdc.posix.sys.wait)
//WTERMSIG (defined in stdc.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);
}

99
druntime/import/stdc/posix/sys/ipc.d
View File

@@ -1,99 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.ipc;
private import stdc.posix.config;
public import stdc.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;
}
const IPC_CREAT = 01000;
const IPC_EXCL = 02000;
const IPC_NOWAIT = 04000;
const key_t IPC_PRIVATE = 0;
const IPC_RMID = 0;
const IPC_SET = 1;
const IPC_STAT = 2;
key_t ftok(in char*, int);
}
else version( darwin )
{
}
else version( freebsd )
{
struct ipc_perm
{
ushort cuid;
ushort cguid;
ushort uid;
ushort gid;
ushort mode;
ushort seq;
key_t key;
}
const IPC_CREAT = 01000;
const IPC_EXCL = 02000;
const IPC_NOWAIT = 04000;
const key_t IPC_PRIVATE = 0;
const IPC_RMID = 0;
const IPC_SET = 1;
const IPC_STAT = 2;
key_t ftok(in char*, int);
}

308
druntime/import/stdc/posix/sys/mman.d
View File

@@ -1,308 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.mman;
private import stdc.posix.config;
public import stdc.stddef; // for size_t
public import stdc.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 )
{
const POSIX_MADV_NORMAL = 0;
const POSIX_MADV_RANDOM = 1;
const POSIX_MADV_SEQUENTIAL = 2;
const POSIX_MADV_WILLNEED = 3;
const POSIX_MADV_DONTNEED = 4;
}
else version( darwin )
{
const POSIX_MADV_NORMAL = 0;
const POSIX_MADV_RANDOM = 1;
const POSIX_MADV_SEQUENTIAL = 2;
const POSIX_MADV_WILLNEED = 3;
const POSIX_MADV_DONTNEED = 4;
}
else version( freebsd )
{
const POSIX_MADV_NORMAL = 0;
const POSIX_MADV_RANDOM = 1;
const POSIX_MADV_SEQUENTIAL = 2;
const POSIX_MADV_WILLNEED = 3;
const POSIX_MADV_DONTNEED = 4;
}
//
// Memory Mapped Files, Shared Memory Objects, or Memory Protection (MC2)
//
/*
PROT_READ
PROT_WRITE
PROT_EXEC
PROT_NONE
*/
version( linux )
{
const PROT_NONE = 0x0;
const PROT_READ = 0x1;
const PROT_WRITE = 0x2;
const PROT_EXEC = 0x4;
}
else version( darwin )
{
const PROT_NONE = 0x00;
const PROT_READ = 0x01;
const PROT_WRITE = 0x02;
const PROT_EXEC = 0x04;
}
else version( freebsd )
{
const PROT_NONE = 0x00;
const PROT_READ = 0x01;
const PROT_WRITE = 0x02;
const 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( darwin )
{
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 )
{
const MAP_SHARED = 0x01;
const MAP_PRIVATE = 0x02;
const MAP_FIXED = 0x10;
const MAP_ANON = 0x20; // non-standard
const MAP_FAILED = cast(void*) -1;
enum
{
MS_ASYNC = 1,
MS_SYNC = 4,
MS_INVALIDATE = 2
}
int msync(void*, size_t, int);
}
else version( darwin )
{
const MAP_SHARED = 0x0001;
const MAP_PRIVATE = 0x0002;
const MAP_FIXED = 0x0010;
const MAP_ANON = 0x1000; // non-standard
const MAP_FAILED = cast(void*)-1;
const MS_ASYNC = 0x0001;
const MS_INVALIDATE = 0x0002;
const MS_SYNC = 0x0010;
int msync(void*, size_t, int);
}
else version( freebsd )
{
const MAP_SHARED = 0x0001;
const MAP_PRIVATE = 0x0002;
const MAP_FIXED = 0x0010;
const MAP_ANON = 0x1000; // non-standard
const MAP_FAILED = cast(void*)-1;
const MS_SYNC = 0x0000;
const MS_ASYNC = 0x0001;
const MS_INVALIDATE = 0x0002;
int msync(void*, size_t, int);
}
//
// Process Memory Locking (ML)
//
/*
MCL_CURRENT
MCL_FUTURE
int mlockall(int);
int munlockall();
*/
version( linux )
{
const MCL_CURRENT = 1;
const MCL_FUTURE = 2;
int mlockall(int);
int munlockall();
}
else version( darwin )
{
const MCL_CURRENT = 0x0001;
const MCL_FUTURE = 0x0002;
int mlockall(int);
int munlockall();
}
else version( freebsd )
{
const MCL_CURRENT = 0x0001;
const 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( darwin )
{
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( darwin )
{
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( darwin )
{
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);
*/

150
druntime/import/stdc/posix/sys/select.d
View File

@@ -1,150 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.select;
private import stdc.posix.config;
public import stdc.time; // for timespec
public import stdc.posix.sys.time; // for timeval
public import stdc.posix.sys.types; // for time_t
public import stdc.posix.signal; // for sigset_t
extern (C):
//
// Required
//
/*
NOTE: This module requires timeval from stdc.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;
const __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 );
}
}
const 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( darwin )
{
private
{
const uint __DARWIN_NBBY = 8; /* bits in a byte */
const uint __DARWIN_NFDBITS = (int.sizeof * __DARWIN_NBBY); /* bits per mask */
}
const FD_SETSIZE = 1024;
struct fd_set
{
int fds_bits[(((FD_SETSIZE) + ((__DARWIN_NFDBITS) - 1)) / (__DARWIN_NFDBITS))];
}
}
else version( freebsd )
{
private
{
const uint FD_SETSIZE = 1024;
const uint _NFDBITS = c_ulong.sizeof * 8;
}
struct fd_set
{
c_ulong fds_bits[((FD_SETSIZE + (_NFDBITS - 1)) / _NFDBITS)];
}
}

111
druntime/import/stdc/posix/sys/shm.d
View File

@@ -1,111 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.shm;
private import stdc.posix.config;
public import stdc.posix.sys.types; // for pid_t, time_t, key_t, size_t
public import stdc.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 )
{
const SHM_RDONLY = 010000;
const 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 )
{
const SHM_RDONLY = 010000;
const SHM_RND = 020000;
const 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( darwin )
{
}

642
druntime/import/stdc/posix/sys/socket.d
View File

@@ -1,642 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.socket;
private import stdc.posix.config;
public import stdc.posix.sys.types; // for ssize_t, size_t
public import stdc.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 stdc.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( darwin )
{
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 = 0x1006,
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
{
const _SS_ALIGNSIZE = long.sizeof;
const uint _SS_MAXSIZE = 128;
const _SS_PAD1SIZE = _SS_ALIGNSIZE - ubyte.sizeof - sa_family_t.sizeof;
const _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 = 0x1006,
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( darwin )
{
enum
{
AF_INET6 = 30
}
}
else version( freebsd )
{
enum
{
AF_INET6 = 28
}
}
//
// Raw Sockets (RS)
//
/*
SOCK_RAW
*/
version( linux )
{
enum
{
SOCK_RAW = 3
}
}
else version( darwin )
{
enum
{
SOCK_RAW = 3
}
}
else version( freebsd )
{
enum
{
SOCK_RAW = 3
}
}

411
druntime/import/stdc/posix/sys/stat.d
View File

@@ -1,411 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.stat;
private import stdc.posix.config;
private import stdc.stdint;
private import stdc.posix.time; // for timespec
public import stdc.stddef; // for size_t
public import stdc.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;
}
}
const S_IRUSR = 0400;
const S_IWUSR = 0200;
const S_IXUSR = 0100;
const S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
const S_IRGRP = S_IRUSR >> 3;
const S_IWGRP = S_IWUSR >> 3;
const S_IXGRP = S_IXUSR >> 3;
const S_IRWXG = S_IRWXU >> 3;
const S_IROTH = S_IRGRP >> 3;
const S_IWOTH = S_IWGRP >> 3;
const S_IXOTH = S_IXGRP >> 3;
const S_IRWXO = S_IRWXG >> 3;
const S_ISUID = 04000;
const S_ISGID = 02000;
const 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( darwin )
{
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;
time_t st_atime;
c_ulong st_atimensec;
time_t st_mtime;
c_ulong st_mtimensec;
time_t st_ctime;
c_ulong 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];
}
const S_IRUSR = 0400;
const S_IWUSR = 0200;
const S_IXUSR = 0100;
const S_IRWXU = S_IRUSR | S_IWUSR | S_IXUSR;
const S_IRGRP = S_IRUSR >> 3;
const S_IWGRP = S_IWUSR >> 3;
const S_IXGRP = S_IXUSR >> 3;
const S_IRWXG = S_IRWXU >> 3;
const S_IROTH = S_IRGRP >> 3;
const S_IWOTH = S_IWGRP >> 3;
const S_IXOTH = S_IXGRP >> 3;
const S_IRWXO = S_IRWXG >> 3;
const S_ISUID = 04000;
const S_ISGID = 02000;
const 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;
}
const S_IRUSR = 0000400;
const S_IWUSR = 0000200;
const S_IXUSR = 0000100;
const S_IRWXU = 0000700;
const S_IRGRP = 0000040;
const S_IWGRP = 0000020;
const S_IXGRP = 0000010;
const S_IRWXG = 0000070;
const S_IROTH = 0000004;
const S_IWOTH = 0000002;
const S_IXOTH = 0000001;
const S_IRWXO = 0000007;
const S_ISUID = 0004000;
const S_ISGID = 0002000;
const 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 )
{
const S_IFMT = 0170000;
const S_IFBLK = 0060000;
const S_IFCHR = 0020000;
const S_IFIFO = 0010000;
const S_IFREG = 0100000;
const S_IFDIR = 0040000;
const S_IFLNK = 0120000;
const S_IFSOCK = 0140000;
int mknod(in char*, mode_t, dev_t);
}
else version( darwin )
{
const S_IFMT = 0170000;
const S_IFBLK = 0060000;
const S_IFCHR = 0020000;
const S_IFIFO = 0010000;
const S_IFREG = 0100000;
const S_IFDIR = 0040000;
const S_IFLNK = 0120000;
const S_IFSOCK = 0140000;
int mknod(in char*, mode_t, dev_t);
}
else version( freebsd )
{
const S_IFMT = 0170000;
const S_IFBLK = 0060000;
const S_IFCHR = 0020000;
const S_IFIFO = 0010000;
const S_IFREG = 0100000;
const S_IFDIR = 0040000;
const S_IFLNK = 0120000;
const S_IFSOCK = 0140000;
int mknod(in char*, mode_t, dev_t);
}

121
druntime/import/stdc/posix/sys/time.d
View File

@@ -1,121 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.time;
private import stdc.posix.config;
public import stdc.posix.sys.types; // for time_t, suseconds_t
public import stdc.posix.sys.select; // for fd_set, FD_CLR() FD_ISSET() FD_SET() FD_ZERO() FD_SETSIZE
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*);
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;
}
const ITIMER_REAL = 0;
const ITIMER_VIRTUAL = 1;
const ITIMER_PROF = 2;
int getitimer(int, itimerval*);
int gettimeofday(timeval*, void*);
int select(int, fd_set*, fd_set*, fd_set*, timeval*);
int setitimer(int, in itimerval*, itimerval*);
int utimes(in char*, in timeval[2]); // LEGACY
}
else version( darwin )
{
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 select(int, fd_set*, fd_set*, fd_set*, timeval*);
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 select(int, fd_set*, fd_set*, fd_set*, timeval*);
int setitimer(int, in itimerval*, itimerval*);
int utimes(in char*, in timeval[2]);
}

429
druntime/import/stdc/posix/sys/types.d
View File

@@ -1,429 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.types;
private import stdc.posix.config;
private import stdc.stdint;
public import stdc.stddef; // for size_t
public import 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 stdc.stddef)
alias c_long ssize_t;
//time_t (defined in stdc.time)
alias uint uid_t;
}
else version( darwin )
{
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 stdc.stddef)
alias size_t ssize_t;
//time_t (defined in 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 stdc.stddef)
alias size_t ssize_t;
//time_t (defined in 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 stdc.time)
alias uint id_t;
alias int key_t;
alias c_long suseconds_t;
alias uint useconds_t;
}
else version( darwin )
{
//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( darwin )
{
private
{
// #if defined(__LP64__)
// FIXME: what is LP64, is it important enough to be included?
version( LP64 )
{
const __PTHREAD_SIZE__ = 1168;
const __PTHREAD_ATTR_SIZE__ = 56;
const __PTHREAD_MUTEXATTR_SIZE__ = 8;
const __PTHREAD_MUTEX_SIZE__ = 56;
const __PTHREAD_CONDATTR_SIZE__ = 8;
const __PTHREAD_COND_SIZE__ = 40;
const __PTHREAD_ONCE_SIZE__ = 8;
const __PTHREAD_RWLOCK_SIZE__ = 192;
const __PTHREAD_RWLOCKATTR_SIZE__ = 16;
}
else
{
const __PTHREAD_SIZE__ = 596;
const __PTHREAD_ATTR_SIZE__ = 36;
const __PTHREAD_MUTEXATTR_SIZE__ = 8;
const __PTHREAD_MUTEX_SIZE__ = 40;
const __PTHREAD_CONDATTR_SIZE__ = 4;
const __PTHREAD_COND_SIZE__ = 24;
const __PTHREAD_ONCE_SIZE__ = 4;
const __PTHREAD_RWLOCK_SIZE__ = 124;
const __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( darwin )
{
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
*/

65
druntime/import/stdc/posix/sys/uio.d
View File

@@ -1,65 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.uio;
private import stdc.posix.config;
public import stdc.posix.sys.types; // for ssize_t, size_t
extern (C):
//
// Required
//
/*
struct iovec
{
void* iov_base;
size_t iov_len;
}
ssize_t // from stdc.posix.sys.types
size_t // from stdc.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( darwin )
{
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);
}

136
druntime/import/stdc/posix/sys/wait.d
View File

@@ -1,136 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.sys.wait;
private import stdc.posix.config;
public import stdc.posix.sys.types; // for id_t, pid_t
public import stdc.posix.signal; // for siginfo_t (XSI)
//public import stdc.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 )
{
const WNOHANG = 1;
const WUNTRACED = 2;
private
{
const __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( darwin )
{
const WNOHANG = 1;
const WUNTRACED = 2;
private
{
const _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 )
{
const WNOHANG = 1;
const WUNTRACED = 2;
const WCONTINUED = 4;
private
{
const _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);
*/

523
druntime/import/stdc/posix/termios.d
View File

@@ -1,523 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.termios;
private import stdc.posix.config;
public import stdc.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( darwin )
{
alias ubyte cc_t;
alias uint speed_t;
alias uint tcflag_t;
const 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;
}
const VEOF = 0;
const VEOL = 1;
const VERASE = 3;
const VINTR = 8;
const VKILL = 5;
const VMIN = 16;
const VQUIT = 9;
const VSTART = 12;
const VSTOP = 13;
const VSUSP = 10;
const VTIME = 17;
const BRKINT = 0x0000002;
const ICRNL = 0x0000100;
const IGNBRK = 0x0000001;
const IGNCR = 0x0000080;
const IGNPAR = 0x0000004;
const INLCR = 0x0000040;
const INPCK = 0x0000010;
const ISTRIP = 0x0000020;
const IXOFF = 0x0000400;
const IXON = 0x0000200;
const PARMRK = 0x0000008;
const OPOST = 0x0000001;
const B0 = 0;
const B50 = 50;
const B75 = 75;
const B110 = 110;
const B134 = 134;
const B150 = 150;
const B200 = 200;
const B300 = 300;
const B600 = 600;
const B1200 = 1200;
const B1800 = 1800;
const B2400 = 2400;
const B4800 = 4800;
const B9600 = 9600;
const B19200 = 19200;
const B38400 = 38400;
const CSIZE = 0x0000300;
const CS5 = 0x0000000;
const CS6 = 0x0000100;
const CS7 = 0x0000200;
const CS8 = 0x0000300;
const CSTOPB = 0x0000400;
const CREAD = 0x0000800;
const PARENB = 0x0001000;
const PARODD = 0x0002000;
const HUPCL = 0x0004000;
const CLOCAL = 0x0008000;
const ECHO = 0x00000008;
const ECHOE = 0x00000002;
const ECHOK = 0x00000004;
const ECHONL = 0x00000010;
const ICANON = 0x00000100;
const IEXTEN = 0x00000400;
const ISIG = 0x00000080;
const NOFLSH = 0x80000000;
const TOSTOP = 0x00400000;
const TCSANOW = 0;
const TCSADRAIN = 1;
const TCSAFLUSH = 2;
const TCIFLUSH = 1;
const TCOFLUSH = 2;
const TCIOFLUSH = 3;
const TCIOFF = 3;
const TCION = 4;
const TCOOFF = 1;
const 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;
const 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;
}
const VEOF = 4;
const VEOL = 11;
const VERASE = 2;
const VINTR = 0;
const VKILL = 3;
const VMIN = 6;
const VQUIT = 1;
const VSTART = 8;
const VSTOP = 9;
const VSUSP = 10;
const VTIME = 5;
const BRKINT = 0000002;
const ICRNL = 0000400;
const IGNBRK = 0000001;
const IGNCR = 0000200;
const IGNPAR = 0000004;
const INLCR = 0000100;
const INPCK = 0000020;
const ISTRIP = 0000040;
const IXOFF = 0010000;
const IXON = 0002000;
const PARMRK = 0000010;
const OPOST = 0000001;
const B0 = 0000000;
const B50 = 0000001;
const B75 = 0000002;
const B110 = 0000003;
const B134 = 0000004;
const B150 = 0000005;
const B200 = 0000006;
const B300 = 0000007;
const B600 = 0000010;
const B1200 = 0000011;
const B1800 = 0000012;
const B2400 = 0000013;
const B4800 = 0000014;
const B9600 = 0000015;
const B19200 = 0000016;
const B38400 = 0000017;
const CSIZE = 0000060;
const CS5 = 0000000;
const CS6 = 0000020;
const CS7 = 0000040;
const CS8 = 0000060;
const CSTOPB = 0000100;
const CREAD = 0000200;
const PARENB = 0000400;
const PARODD = 0001000;
const HUPCL = 0002000;
const CLOCAL = 0004000;
const ECHO = 0000010;
const ECHOE = 0000020;
const ECHOK = 0000040;
const ECHONL = 0000100;
const ICANON = 0000002;
const IEXTEN = 0100000;
const ISIG = 0000001;
const NOFLSH = 0000200;
const TOSTOP = 0000400;
const TCSANOW = 0;
const TCSADRAIN = 1;
const TCSAFLUSH = 2;
const TCIFLUSH = 0;
const TCOFLUSH = 1;
const TCIOFLUSH = 2;
const TCIOFF = 2;
const TCION = 3;
const TCOOFF = 0;
const 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;
const 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;
}
const VEOF = 0;
const VEOL = 1;
const VERASE = 3;
const VINTR = 8;
const VKILL = 5;
const VMIN = 16;
const VQUIT = 9;
const VSTART = 12;
const VSTOP = 13;
const VSUSP = 10;
const VTIME = 17;
const BRKINT = 0x0000002;
const ICRNL = 0x0000100;
const IGNBRK = 0x0000001;
const IGNCR = 0x0000080;
const IGNPAR = 0x0000004;
const INLCR = 0x0000040;
const INPCK = 0x0000010;
const ISTRIP = 0x0000020;
const IXOFF = 0x0000400;
const IXON = 0x0000200;
const PARMRK = 0x0000008;
const OPOST = 0x0000001;
const B0 = 0;
const B50 = 50;
const B75 = 75;
const B110 = 110;
const B134 = 134;
const B150 = 150;
const B200 = 200;
const B300 = 300;
const B600 = 600;
const B1200 = 1200;
const B1800 = 1800;
const B2400 = 2400;
const B4800 = 4800;
const B9600 = 9600;
const B19200 = 19200;
const B38400 = 38400;
const CSIZE = 0x0000300;
const CS5 = 0x0000000;
const CS6 = 0x0000100;
const CS7 = 0x0000200;
const CS8 = 0x0000300;
const CSTOPB = 0x0000400;
const CREAD = 0x0000800;
const PARENB = 0x0001000;
const PARODD = 0x0002000;
const HUPCL = 0x0004000;
const CLOCAL = 0x0008000;
const ECHO = 0x00000008;
const ECHOE = 0x00000002;
const ECHOK = 0x00000004;
const ECHONL = 0x00000010;
const ICANON = 0x00000100;
const IEXTEN = 0x00000400;
const ISIG = 0x00000080;
const NOFLSH = 0x80000000;
const TOSTOP = 0x00400000;
const TCSANOW = 0;
const TCSADRAIN = 1;
const TCSAFLUSH = 2;
const TCIFLUSH = 1;
const TCOFLUSH = 2;
const TCIOFLUSH = 3;
const TCIOFF = 3;
const TCION = 4;
const TCOOFF = 1;
const 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 )
{
const IXANY = 0004000;
const ONLCR = 0000004;
const OCRNL = 0000010;
const ONOCR = 0000020;
const ONLRET = 0000040;
const OFILL = 0000100;
const NLDLY = 0000400;
const NL0 = 0000000;
const NL1 = 0000400;
const CRDLY = 0003000;
const CR0 = 0000000;
const CR1 = 0001000;
const CR2 = 0002000;
const CR3 = 0003000;
const TABDLY = 0014000;
const TAB0 = 0000000;
const TAB1 = 0004000;
const TAB2 = 0010000;
const TAB3 = 0014000;
const BSDLY = 0020000;
const BS0 = 0000000;
const BS1 = 0020000;
const VTDLY = 0040000;
const VT0 = 0000000;
const VT1 = 0040000;
const FFDLY = 0100000;
const FF0 = 0000000;
const FF1 = 0100000;
pid_t tcgetsid(int);
}

257
druntime/import/stdc/posix/time.d
View File

@@ -1,257 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.time;
private import stdc.posix.config;
public import stdc.time;
public import stdc.posix.sys.types;
public import stdc.posix.signal; // for sigevent
extern (C):
//
// Required (defined in 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( darwin )
{
time_t timegm(tm*); // non-standard
}
else version( freebsd )
{
time_t timegm(tm*); // non-standard
}
//
// C Extension (CX)
// (defined in 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 stdc.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 )
{
const CLOCK_PROCESS_CPUTIME_ID = 2; // (TMR|CPT)
const 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;
}
const CLOCK_REALTIME = 0;
const 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( darwin )
{
int nanosleep(in timespec*, timespec*);
}
else version( freebsd )
{
const CLOCK_PROCESS_CPUTIME_ID = 2; // (TMR|CPT)
const 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;
}
const CLOCK_REALTIME = 0;
const 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( darwin )
{
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 int daylight;
extern c_long timezone;
tm* getdate(in char*);
char* strptime(in char*, in char*, tm*);
}
else version( darwin )
{
extern c_long timezone;
tm* getdate(in char*);
char* strptime(in char*, in char*, tm*);
}
else version( freebsd )
{
extern c_long timezone;
//tm* getdate(in char*);
char* strptime(in char*, in char*, tm*);
}

155
druntime/import/stdc/posix/ucontext.d
View File

@@ -1,155 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.ucontext;
private import stdc.posix.config;
public import stdc.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;
}
const 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;
}
const 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*);
}

594
druntime/import/stdc/posix/unistd.d
View File

@@ -1,594 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.unistd;
private import stdc.posix.config;
private import stdc.stddef;
public import stdc.posix.inttypes; // for intptr_t
public import stdc.posix.sys.types; // for size_t, ssize_t, uid_t, gid_t, off_t, pid_t, useconds_t
extern (C):
const STDIN_FILENO = 0;
const STDOUT_FILENO = 1;
const 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 )
{
const F_OK = 0;
const R_OK = 4;
const W_OK = 2;
const X_OK = 1;
const F_ULOCK = 0;
const F_LOCK = 1;
const F_TLOCK = 2;
const 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( darwin )
{
const F_OK = 0;
const R_OK = 4;
const W_OK = 2;
const X_OK = 1;
const F_ULOCK = 0;
const F_LOCK = 1;
const F_TLOCK = 2;
const F_TEST = 3;
}
else version( freebsd )
{
const F_OK = 0;
const R_OK = 0x04;
const W_OK = 0x02;
const X_OK = 0x01;
const F_ULOCK = 0;
const F_LOCK = 1;
const F_TLOCK = 2;
const 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 (darwin)
{
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();
}

58
druntime/import/stdc/posix/utime.d
View File

@@ -1,58 +0,0 @@
/**
* D header file for POSIX.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
*/
module stdc.posix.utime;
private import stdc.posix.config;
public import stdc.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( darwin )
{
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*);
}

48
druntime/import/stdc/signal.d
View File

@@ -1,48 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.signal;
extern (C):
// this should be volatile
alias int sig_atomic_t;
private alias void function(int) sigfn_t;
version( Posix )
{
const SIG_ERR = cast(sigfn_t) -1;
const SIG_DFL = cast(sigfn_t) 0;
const SIG_IGN = cast(sigfn_t) 1;
// standard C signals
const SIGABRT = 6; // Abnormal termination
const SIGFPE = 8; // Floating-point error
const SIGILL = 4; // Illegal hardware instruction
const SIGINT = 2; // Terminal interrupt character
const SIGSEGV = 11; // Invalid memory reference
const SIGTERM = 15; // Termination
}
else
{
const SIG_ERR = cast(sigfn_t) -1;
const SIG_DFL = cast(sigfn_t) 0;
const SIG_IGN = cast(sigfn_t) 1;
// standard C signals
const SIGABRT = 22; // Abnormal termination
const SIGFPE = 8; // Floating-point error
const SIGILL = 4; // Illegal hardware instruction
const SIGINT = 2; // Terminal interrupt character
const SIGSEGV = 11; // Invalid memory reference
const SIGTERM = 15; // Termination
}
sigfn_t signal(int sig, sigfn_t func);
int raise(int sig);

51
druntime/import/stdc/stdarg.d
View File

@@ -1,51 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Hauke Duden, Walter Bright
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.stdarg;
version( LDC )
{
public import ldc.cstdarg;
}
version( GNU )
{
public import std.c.stdarg;
}
else
{
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;
}
}

33
druntime/import/stdc/stddef.d
View File

@@ -1,33 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.stddef;
extern (C):
//alias typeof(int.sizeof) size_t;
//alias typeof(cast(void*)0 - cast(void*)0) ptrdiff_t;
version( Windows )
{
alias wchar wint_t;
alias wchar wchar_t;
alias wchar wctype_t;
alias wchar wctrans_t;
const wchar WEOF = 0xFFFF;
}
else
{
alias dchar wint_t;
alias dchar wchar_t;
alias dchar wctype_t;
alias dchar wctrans_t;
const dchar WEOF = 0xFFFF;
}

151
druntime/import/stdc/stdint.d
View File

@@ -1,151 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.stdint;
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;
version( VerboseC )
{
private import stdc.stddef;
private import stdc.signal; // for sig_atomic_t
const int8_t INT8_MIN = int8_t.min;
const int8_t INT8_MAX = int8_t.max;
const int16_t INT16_MIN = int16_t.min;
const int16_t INT16_MAX = int16_t.max;
const int32_t INT32_MIN = int32_t.min;
const int32_t INT32_MAX = int32_t.max;
const int64_t INT64_MIN = int64_t.min;
const int64_t INT64_MAX = int64_t.max;
const uint8_t UINT8_MAX = uint8_t.max;
const uint16_t UINT16_MAX = uint16_t.max;
const uint32_t UINT32_MAX = uint32_t.max;
const uint64_t UINT64_MAX = uint64_t.max;
const int_least8_t INT_LEAST8_MIN = int_least8_t.min;
const int_least8_t INT_LEAST8_MAX = int_least8_t.max;
const int_least16_t INT_LEAST16_MIN = int_least16_t.min;
const int_least16_t INT_LEAST16_MAX = int_least16_t.max;
const int_least32_t INT_LEAST32_MIN = int_least32_t.min;
const int_least32_t INT_LEAST32_MAX = int_least32_t.max;
const int_least64_t INT_LEAST64_MIN = int_least64_t.min;
const int_least64_t INT_LEAST64_MAX = int_least64_t.max;
const uint_least8_t UINT_LEAST8_MAX = uint_least8_t.max;
const uint_least16_t UINT_LEAST16_MAX = uint_least16_t.max;
const uint_least32_t UINT_LEAST32_MAX = uint_least32_t.max;
const uint_least64_t UINT_LEAST64_MAX = uint_least64_t.max;
const int_fast8_t INT_FAST8_MIN = int_fast8_t.min;
const int_fast8_t INT_FAST8_MAX = int_fast8_t.max;
const int_fast16_t INT_FAST16_MIN = int_fast16_t.min;
const int_fast16_t INT_FAST16_MAX = int_fast16_t.max;
const int_fast32_t INT_FAST32_MIN = int_fast32_t.min;
const int_fast32_t INT_FAST32_MAX = int_fast32_t.max;
const int_fast64_t INT_FAST64_MIN = int_fast64_t.min;
const int_fast64_t INT_FAST64_MAX = int_fast64_t.max;
const uint_fast8_t UINT_FAST8_MAX = uint_fast8_t.max;
const uint_fast16_t UINT_FAST16_MAX = uint_fast16_t.max;
const uint_fast32_t UINT_FAST32_MAX = uint_fast32_t.max;
const uint_fast64_t UINT_FAST64_MAX = uint_fast64_t.max;
const intptr_t INTPTR_MIN = intptr_t.min;
const intptr_t INTPTR_MAX = intptr_t.max;
const uintptr_t UINTPTR_MIN = uintptr_t.min;
const uintptr_t UINTPTR_MAX = uintptr_t.max;
const intmax_t INTMAX_MIN = intmax_t.min;
const intmax_t INTMAX_MAX = intmax_t.max;
const uintmax_t UINTMAX_MAX = uintmax_t.max;
const ptrdiff_t PTRDIFF_MIN = ptrdiff_t.min;
const ptrdiff_t PTRDIFF_MAX = ptrdiff_t.max;
const sig_atomic_t SIG_ATOMIC_MIN = sig_atomic_t.min;
const sig_atomic_t SIG_ATOMIC_MAX = sig_atomic_t.max;
const size_t SIZE_MAX = size_t.max;
const wchar_t WCHAR_MIN = wchar_t.min;
const wchar_t WCHAR_MAX = wchar_t.max;
const wint_t WINT_MIN = wint_t.min;
const 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;

445
druntime/import/stdc/stdio.d
View File

@@ -1,445 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly, Walter Bright
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.stdio;
private
{
import stdc.stdarg;
import stdc.stddef;
import stdc.config;
}
extern (C):
version( Windows )
{
const int BUFSIZ = 0x4000;
const int EOF = -1;
const int FOPEN_MAX = 20;
const int FILENAME_MAX = 256; // 255 plus NULL
const int TMP_MAX = 32767;
const int _SYS_OPEN = 20;
const int SYS_OPEN = _SYS_OPEN;
const int _NFILE = 60;
const char[] _P_tmpdir = "\\";
const wchar[] _wP_tmpdir = "\\";
const int L_tmpnam = _P_tmpdir.length + 12;
}
else version( linux )
{
//const int BUFSIZ = 0x4000;
const int EOF = -1;
const int FOPEN_MAX = 16;
const int FILENAME_MAX = 4095;
const int TMP_MAX = 238328;
const int L_tmpnam = 20;
}
else version( darwin )
{
const int EOF = -1;
const int FOPEN_MAX = 20;
const int FILENAME_MAX = 1024;
const int TMP_MAX = 308915776;
const int L_tmpnam = 1024;
private
{
struct __sbuf
{
ubyte* _base;
int _size;
}
struct __sFILEX
{
}
}
}
else version ( freebsd )
{
const int EOF = -1;
const int FOPEN_MAX = 20;
const int FILENAME_MAX = 1024;
const int TMP_MAX = 308915776;
const int 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( darwin )
{
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 _iobuf FILE;
enum
{
_F_RDWR = 0x0003,
_F_READ = 0x0001,
_F_WRIT = 0x0002,
_F_BUF = 0x0004,
_F_LBUF = 0x0008,
_F_ERR = 0x0010,
_F_EOF = 0x0020,
_F_BIN = 0x0040,
_F_IN = 0x0080,
_F_OUT = 0x0100,
_F_TERM = 0x0200,
}
version( Windows )
{
enum
{
_IOFBF = 0,
_IOREAD = 1,
_IOWRT = 2,
_IONBF = 4,
_IOMYBUF = 8,
_IOEOF = 0x10,
_IOERR = 0x20,
_IOLBF = 0x40,
_IOSTRG = 0x40,
_IORW = 0x80,
_IOTRAN = 0x100,
_IOAPP = 0x200,
}
extern void function() _fcloseallp;
version (GNU)
{
extern FILE[_NFILE]* _imp___iob;
auto FILE* stdin;
auto FILE* stdout;
auto FILE* stderr;
auto FILE* stdaux;
auto FILE* stdprn;
static this()
{
stdin = &(*_imp___iob)[0];
stdout = &(*_imp___iob)[1];
stderr = &(*_imp___iob)[2];
stdaux = &(*_imp___iob)[3];
stdprn = &(*_imp___iob)[4];
}
}
else
{
extern FILE[_NFILE] _iob;
auto FILE* stdin = &_iob[0];
auto FILE* stdout = &_iob[1];
auto FILE* stderr = &_iob[2];
auto FILE* stdaux = &_iob[3];
auto FILE* stdprn = &_iob[4];
}
}
else version( linux )
{
enum
{
_IOFBF = 0,
_IOLBF = 1,
_IONBF = 2,
}
extern FILE* stdin;
extern FILE* stdout;
extern FILE* stderr;
}
else version( darwin )
{
extern FILE* __stdinp;
extern FILE* __stdoutp;
extern FILE* __stderrp;
auto FILE* stdin;
auto FILE* stdout;
auto FILE* stderr;
static this()
{
stdin = __stdinp;
stdout = __stdoutp;
stderr = __stderrp;
}
}
else version( freebsd )
{
extern FILE[3] __sF;
auto FILE* stdin = &__sF[0];
auto FILE* stdout = &__sF[1];
auto FILE* 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( darwin )
{
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);
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);

101
druntime/import/stdc/stdlib.d
View File

@@ -1,101 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.stdlib;
private import stdc.stddef;
private import stdc.config;
extern (C):
struct div_t
{
int quot,
rem;
}
struct ldiv_t
{
int quot,
rem;
}
struct lldiv_t
{
long quot,
rem;
}
const EXIT_SUCCESS = 0;
const EXIT_FAILURE = 1;
const RAND_MAX = 32767;
const 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);
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);
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);
}
else version( GNU )
{
private import gcc.builtins;
alias gcc.builtins.__builtin_alloca alloca;
}

76
druntime/import/stdc/string.d
View File

@@ -1,76 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.string;
private import stdc.stddef;
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);
version( Posix )
{
char* strdup(char*);
}
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);
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);
alias int mbstate_t;
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);

652
druntime/import/stdc/tgmath.d
View File

@@ -1,652 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly, Walter Bright
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.tgmath;
private import stdc.config;
private static import stdc.math;
private static import stdc.complex;
extern (C):
version( freebsd )
{
alias stdc.math.acos acos;
alias stdc.math.acosf acos;
alias stdc.math.acosl acos;
alias stdc.complex.cacos acos;
alias stdc.complex.cacosf acos;
alias stdc.complex.cacosl acos;
alias stdc.math.asin asin;
alias stdc.math.asinf asin;
alias stdc.math.asinl asin;
alias stdc.complex.casin asin;
alias stdc.complex.casinf asin;
alias stdc.complex.casinl asin;
alias stdc.math.atan atan;
alias stdc.math.atanf atan;
alias stdc.math.atanl atan;
alias stdc.complex.catan atan;
alias stdc.complex.catanf atan;
alias stdc.complex.catanl atan;
alias stdc.math.atan2 atan2;
alias stdc.math.atan2f atan2;
alias stdc.math.atan2l atan2;
alias stdc.math.cos cos;
alias stdc.math.cosf cos;
alias stdc.math.cosl cos;
alias stdc.complex.ccos cos;
alias stdc.complex.ccosf cos;
alias stdc.complex.ccosl cos;
alias stdc.math.sin sin;
alias stdc.math.sinf sin;
alias stdc.math.sinl sin;
alias stdc.complex.csin csin;
alias stdc.complex.csinf csin;
alias stdc.complex.csinl csin;
alias stdc.math.tan tan;
alias stdc.math.tanf tan;
alias stdc.math.tanl tan;
alias stdc.complex.ctan tan;
alias stdc.complex.ctanf tan;
alias stdc.complex.ctanl tan;
alias stdc.math.acosh acosh;
alias stdc.math.acoshf acosh;
alias stdc.math.acoshl acosh;
alias stdc.complex.cacosh acosh;
alias stdc.complex.cacoshf acosh;
alias stdc.complex.cacoshl acosh;
alias stdc.math.asinh asinh;
alias stdc.math.asinhf asinh;
alias stdc.math.asinhl asinh;
alias stdc.complex.casinh asinh;
alias stdc.complex.casinhf asinh;
alias stdc.complex.casinhl asinh;
alias stdc.math.atanh atanh;
alias stdc.math.atanhf atanh;
alias stdc.math.atanhl atanh;
alias stdc.complex.catanh atanh;
alias stdc.complex.catanhf atanh;
alias stdc.complex.catanhl atanh;
alias stdc.math.cosh cosh;
alias stdc.math.coshf cosh;
alias stdc.math.coshl cosh;
alias stdc.complex.ccosh cosh;
alias stdc.complex.ccoshf cosh;
alias stdc.complex.ccoshl cosh;
alias stdc.math.sinh sinh;
alias stdc.math.sinhf sinh;
alias stdc.math.sinhl sinh;
alias stdc.complex.csinh sinh;
alias stdc.complex.csinhf sinh;
alias stdc.complex.csinhl sinh;
alias stdc.math.tanh tanh;
alias stdc.math.tanhf tanh;
alias stdc.math.tanhl tanh;
alias stdc.complex.ctanh tanh;
alias stdc.complex.ctanhf tanh;
alias stdc.complex.ctanhl tanh;
alias stdc.math.exp exp;
alias stdc.math.expf exp;
alias stdc.math.expl exp;
alias stdc.complex.cexp exp;
alias stdc.complex.cexpf exp;
alias stdc.complex.cexpl exp;
alias stdc.math.exp2 exp2;
alias stdc.math.exp2f exp2;
alias stdc.math.exp2l exp2;
alias stdc.math.expm1 expm1;
alias stdc.math.expm1f expm1;
alias stdc.math.expm1l expm1;
alias stdc.math.frexp frexp;
alias stdc.math.frexpf frexp;
alias stdc.math.frexpl frexp;
alias stdc.math.ilogb ilogb;
alias stdc.math.ilogbf ilogb;
alias stdc.math.ilogbl ilogb;
alias stdc.math.ldexp ldexp;
alias stdc.math.ldexpf ldexp;
alias stdc.math.ldexpl ldexp;
alias stdc.math.log log;
alias stdc.math.logf log;
alias stdc.math.logl log;
alias stdc.complex.clog log;
alias stdc.complex.clogf log;
alias stdc.complex.clogl log;
alias stdc.math.log10 log10;
alias stdc.math.log10f log10;
alias stdc.math.log10l log10;
alias stdc.math.log1p log1p;
alias stdc.math.log1pf log1p;
alias stdc.math.log1pl log1p;
alias stdc.math.log2 log1p;
alias stdc.math.log2f log1p;
alias stdc.math.log2l log1p;
alias stdc.math.logb log1p;
alias stdc.math.logbf log1p;
alias stdc.math.logbl log1p;
alias stdc.math.modf modf;
alias stdc.math.modff modf;
// alias stdc.math.modfl modf;
alias stdc.math.scalbn scalbn;
alias stdc.math.scalbnf scalbn;
alias stdc.math.scalbnl scalbn;
alias stdc.math.scalbln scalbln;
alias stdc.math.scalblnf scalbln;
alias stdc.math.scalblnl scalbln;
alias stdc.math.cbrt cbrt;
alias stdc.math.cbrtf cbrt;
alias stdc.math.cbrtl cbrt;
alias stdc.math.fabs fabs;
alias stdc.math.fabsf fabs;
alias stdc.math.fabsl fabs;
alias stdc.complex.cabs fabs;
alias stdc.complex.cabsf fabs;
alias stdc.complex.cabsl fabs;
alias stdc.math.hypot hypot;
alias stdc.math.hypotf hypot;
alias stdc.math.hypotl hypot;
alias stdc.math.pow pow;
alias stdc.math.powf pow;
alias stdc.math.powl pow;
alias stdc.complex.cpow pow;
alias stdc.complex.cpowf pow;
alias stdc.complex.cpowl pow;
alias stdc.math.sqrt sqrt;
alias stdc.math.sqrtf sqrt;
alias stdc.math.sqrtl sqrt;
alias stdc.complex.csqrt sqrt;
alias stdc.complex.csqrtf sqrt;
alias stdc.complex.csqrtl sqrt;
alias stdc.math.erf erf;
alias stdc.math.erff erf;
alias stdc.math.erfl erf;
alias stdc.math.erfc erfc;
alias stdc.math.erfcf erfc;
alias stdc.math.erfcl erfc;
alias stdc.math.lgamma lgamma;
alias stdc.math.lgammaf lgamma;
alias stdc.math.lgammal lgamma;
alias stdc.math.tgamma tgamma;
alias stdc.math.tgammaf tgamma;
alias stdc.math.tgammal tgamma;
alias stdc.math.ceil ceil;
alias stdc.math.ceilf ceil;
alias stdc.math.ceill ceil;
alias stdc.math.floor floor;
alias stdc.math.floorf floor;
alias stdc.math.floorl floor;
alias stdc.math.nearbyint nearbyint;
alias stdc.math.nearbyintf nearbyint;
alias stdc.math.nearbyintl nearbyint;
alias stdc.math.rint rint;
alias stdc.math.rintf rint;
alias stdc.math.rintl rint;
alias stdc.math.lrint lrint;
alias stdc.math.lrintf lrint;
alias stdc.math.lrintl lrint;
alias stdc.math.llrint llrint;
alias stdc.math.llrintf llrint;
alias stdc.math.llrintl llrint;
alias stdc.math.round round;
alias stdc.math.roundf round;
alias stdc.math.roundl round;
alias stdc.math.lround lround;
alias stdc.math.lroundf lround;
alias stdc.math.lroundl lround;
alias stdc.math.llround llround;
alias stdc.math.llroundf llround;
alias stdc.math.llroundl llround;
alias stdc.math.trunc trunc;
alias stdc.math.truncf trunc;
alias stdc.math.truncl trunc;
alias stdc.math.fmod fmod;
alias stdc.math.fmodf fmod;
alias stdc.math.fmodl fmod;
alias stdc.math.remainder remainder;
alias stdc.math.remainderf remainder;
alias stdc.math.remainderl remainder;
alias stdc.math.remquo remquo;
alias stdc.math.remquof remquo;
alias stdc.math.remquol remquo;
alias stdc.math.copysign copysign;
alias stdc.math.copysignf copysign;
alias stdc.math.copysignl copysign;
// alias stdc.math.nan nan;
// alias stdc.math.nanf nan;
// alias stdc.math.nanl nan;
alias stdc.math.nextafter nextafter;
alias stdc.math.nextafterf nextafter;
alias stdc.math.nextafterl nextafter;
alias stdc.math.nexttoward nexttoward;
alias stdc.math.nexttowardf nexttoward;
alias stdc.math.nexttowardl nexttoward;
alias stdc.math.fdim fdim;
alias stdc.math.fdimf fdim;
alias stdc.math.fdiml fdim;
alias stdc.math.fmax fmax;
alias stdc.math.fmaxf fmax;
alias stdc.math.fmaxl fmax;
alias stdc.math.fmin fmin;
alias stdc.math.fmin fmin;
alias stdc.math.fminl fmin;
alias stdc.math.fma fma;
alias stdc.math.fmaf fma;
alias stdc.math.fmal fma;
alias stdc.complex.carg carg;
alias stdc.complex.cargf carg;
alias stdc.complex.cargl carg;
alias stdc.complex.cimag cimag;
alias stdc.complex.cimagf cimag;
alias stdc.complex.cimagl cimag;
alias stdc.complex.conj conj;
alias stdc.complex.conjf conj;
alias stdc.complex.conjl conj;
alias stdc.complex.cproj cproj;
alias stdc.complex.cprojf cproj;
alias stdc.complex.cprojl cproj;
// alias stdc.complex.creal creal;
// alias stdc.complex.crealf creal;
// alias stdc.complex.creall creal;
}
else
{
alias stdc.math.acos acos;
alias stdc.math.acosf acos;
alias stdc.math.acosl acos;
alias stdc.complex.cacos acos;
alias stdc.complex.cacosf acos;
alias stdc.complex.cacosl acos;
alias stdc.math.asin asin;
alias stdc.math.asinf asin;
alias stdc.math.asinl asin;
alias stdc.complex.casin asin;
alias stdc.complex.casinf asin;
alias stdc.complex.casinl asin;
alias stdc.math.atan atan;
alias stdc.math.atanf atan;
alias stdc.math.atanl atan;
alias stdc.complex.catan atan;
alias stdc.complex.catanf atan;
alias stdc.complex.catanl atan;
alias stdc.math.atan2 atan2;
alias stdc.math.atan2f atan2;
alias stdc.math.atan2l atan2;
alias stdc.math.cos cos;
alias stdc.math.cosf cos;
alias stdc.math.cosl cos;
alias stdc.complex.ccos cos;
alias stdc.complex.ccosf cos;
alias stdc.complex.ccosl cos;
alias stdc.math.sin sin;
alias stdc.math.sinf sin;
alias stdc.math.sinl sin;
alias stdc.complex.csin csin;
alias stdc.complex.csinf csin;
alias stdc.complex.csinl csin;
alias stdc.math.tan tan;
alias stdc.math.tanf tan;
alias stdc.math.tanl tan;
alias stdc.complex.ctan tan;
alias stdc.complex.ctanf tan;
alias stdc.complex.ctanl tan;
alias stdc.math.acosh acosh;
alias stdc.math.acoshf acosh;
alias stdc.math.acoshl acosh;
alias stdc.complex.cacosh acosh;
alias stdc.complex.cacoshf acosh;
alias stdc.complex.cacoshl acosh;
alias stdc.math.asinh asinh;
alias stdc.math.asinhf asinh;
alias stdc.math.asinhl asinh;
alias stdc.complex.casinh asinh;
alias stdc.complex.casinhf asinh;
alias stdc.complex.casinhl asinh;
alias stdc.math.atanh atanh;
alias stdc.math.atanhf atanh;
alias stdc.math.atanhl atanh;
alias stdc.complex.catanh atanh;
alias stdc.complex.catanhf atanh;
alias stdc.complex.catanhl atanh;
alias stdc.math.cosh cosh;
alias stdc.math.coshf cosh;
alias stdc.math.coshl cosh;
alias stdc.complex.ccosh cosh;
alias stdc.complex.ccoshf cosh;
alias stdc.complex.ccoshl cosh;
alias stdc.math.sinh sinh;
alias stdc.math.sinhf sinh;
alias stdc.math.sinhl sinh;
alias stdc.complex.csinh sinh;
alias stdc.complex.csinhf sinh;
alias stdc.complex.csinhl sinh;
alias stdc.math.tanh tanh;
alias stdc.math.tanhf tanh;
alias stdc.math.tanhl tanh;
alias stdc.complex.ctanh tanh;
alias stdc.complex.ctanhf tanh;
alias stdc.complex.ctanhl tanh;
alias stdc.math.exp exp;
alias stdc.math.expf exp;
alias stdc.math.expl exp;
alias stdc.complex.cexp exp;
alias stdc.complex.cexpf exp;
alias stdc.complex.cexpl exp;
alias stdc.math.exp2 exp2;
alias stdc.math.exp2f exp2;
alias stdc.math.exp2l exp2;
alias stdc.math.expm1 expm1;
alias stdc.math.expm1f expm1;
alias stdc.math.expm1l expm1;
alias stdc.math.frexp frexp;
alias stdc.math.frexpf frexp;
alias stdc.math.frexpl frexp;
alias stdc.math.ilogb ilogb;
alias stdc.math.ilogbf ilogb;
alias stdc.math.ilogbl ilogb;
alias stdc.math.ldexp ldexp;
alias stdc.math.ldexpf ldexp;
alias stdc.math.ldexpl ldexp;
alias stdc.math.log log;
alias stdc.math.logf log;
alias stdc.math.logl log;
alias stdc.complex.clog log;
alias stdc.complex.clogf log;
alias stdc.complex.clogl log;
alias stdc.math.log10 log10;
alias stdc.math.log10f log10;
alias stdc.math.log10l log10;
alias stdc.math.log1p log1p;
alias stdc.math.log1pf log1p;
alias stdc.math.log1pl log1p;
alias stdc.math.log2 log1p;
alias stdc.math.log2f log1p;
alias stdc.math.log2l log1p;
alias stdc.math.logb log1p;
alias stdc.math.logbf log1p;
alias stdc.math.logbl log1p;
alias stdc.math.modf modf;
alias stdc.math.modff modf;
alias stdc.math.modfl modf;
alias stdc.math.scalbn scalbn;
alias stdc.math.scalbnf scalbn;
alias stdc.math.scalbnl scalbn;
alias stdc.math.scalbln scalbln;
alias stdc.math.scalblnf scalbln;
alias stdc.math.scalblnl scalbln;
alias stdc.math.cbrt cbrt;
alias stdc.math.cbrtf cbrt;
alias stdc.math.cbrtl cbrt;
alias stdc.math.fabs fabs;
alias stdc.math.fabsf fabs;
alias stdc.math.fabsl fabs;
alias stdc.complex.cabs fabs;
alias stdc.complex.cabsf fabs;
alias stdc.complex.cabsl fabs;
alias stdc.math.hypot hypot;
alias stdc.math.hypotf hypot;
alias stdc.math.hypotl hypot;
alias stdc.math.pow pow;
alias stdc.math.powf pow;
alias stdc.math.powl pow;
alias stdc.complex.cpow pow;
alias stdc.complex.cpowf pow;
alias stdc.complex.cpowl pow;
alias stdc.math.sqrt sqrt;
alias stdc.math.sqrtf sqrt;
alias stdc.math.sqrtl sqrt;
alias stdc.complex.csqrt sqrt;
alias stdc.complex.csqrtf sqrt;
alias stdc.complex.csqrtl sqrt;
alias stdc.math.erf erf;
alias stdc.math.erff erf;
alias stdc.math.erfl erf;
alias stdc.math.erfc erfc;
alias stdc.math.erfcf erfc;
alias stdc.math.erfcl erfc;
alias stdc.math.lgamma lgamma;
alias stdc.math.lgammaf lgamma;
alias stdc.math.lgammal lgamma;
alias stdc.math.tgamma tgamma;
alias stdc.math.tgammaf tgamma;
alias stdc.math.tgammal tgamma;
alias stdc.math.ceil ceil;
alias stdc.math.ceilf ceil;
alias stdc.math.ceill ceil;
alias stdc.math.floor floor;
alias stdc.math.floorf floor;
alias stdc.math.floorl floor;
alias stdc.math.nearbyint nearbyint;
alias stdc.math.nearbyintf nearbyint;
alias stdc.math.nearbyintl nearbyint;
alias stdc.math.rint rint;
alias stdc.math.rintf rint;
alias stdc.math.rintl rint;
alias stdc.math.lrint lrint;
alias stdc.math.lrintf lrint;
alias stdc.math.lrintl lrint;
alias stdc.math.llrint llrint;
alias stdc.math.llrintf llrint;
alias stdc.math.llrintl llrint;
alias stdc.math.round round;
alias stdc.math.roundf round;
alias stdc.math.roundl round;
alias stdc.math.lround lround;
alias stdc.math.lroundf lround;
alias stdc.math.lroundl lround;
alias stdc.math.llround llround;
alias stdc.math.llroundf llround;
alias stdc.math.llroundl llround;
alias stdc.math.trunc trunc;
alias stdc.math.truncf trunc;
alias stdc.math.truncl trunc;
alias stdc.math.fmod fmod;
alias stdc.math.fmodf fmod;
alias stdc.math.fmodl fmod;
alias stdc.math.remainder remainder;
alias stdc.math.remainderf remainder;
alias stdc.math.remainderl remainder;
alias stdc.math.remquo remquo;
alias stdc.math.remquof remquo;
alias stdc.math.remquol remquo;
alias stdc.math.copysign copysign;
alias stdc.math.copysignf copysign;
alias stdc.math.copysignl copysign;
alias stdc.math.nan nan;
alias stdc.math.nanf nan;
alias stdc.math.nanl nan;
alias stdc.math.nextafter nextafter;
alias stdc.math.nextafterf nextafter;
alias stdc.math.nextafterl nextafter;
alias stdc.math.nexttoward nexttoward;
alias stdc.math.nexttowardf nexttoward;
alias stdc.math.nexttowardl nexttoward;
alias stdc.math.fdim fdim;
alias stdc.math.fdimf fdim;
alias stdc.math.fdiml fdim;
alias stdc.math.fmax fmax;
alias stdc.math.fmaxf fmax;
alias stdc.math.fmaxl fmax;
alias stdc.math.fmin fmin;
alias stdc.math.fmin fmin;
alias stdc.math.fminl fmin;
alias stdc.math.fma fma;
alias stdc.math.fmaf fma;
alias stdc.math.fmal fma;
alias stdc.complex.carg carg;
alias stdc.complex.cargf carg;
alias stdc.complex.cargl carg;
alias stdc.complex.cimag cimag;
alias stdc.complex.cimagf cimag;
alias stdc.complex.cimagl cimag;
alias stdc.complex.conj conj;
alias stdc.complex.conjf conj;
alias stdc.complex.conjl conj;
alias stdc.complex.cproj cproj;
alias stdc.complex.cprojf cproj;
alias stdc.complex.cprojl cproj;
// alias stdc.complex.creal creal;
// alias stdc.complex.crealf creal;
// alias stdc.complex.creall creal;
}

99
druntime/import/stdc/time.d
View File

@@ -1,99 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.time;
private import stdc.config;
private import stdc.stddef;
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( darwin )
{
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);
size_t wcsftime(wchar_t* s, size_t maxsize, in wchar_t* format, in tm* timeptr);
version( Windows )
{
void tzset();
void _tzset();
char* _strdate(char* s);
char* _strtime(char* s);
wchar_t* _wasctime(tm*);
wchar_t* _wctime(time_t*);
wchar_t* _wstrdate(wchar_t*);
wchar_t* _wstrtime(wchar_t*);
}
else version( linux )
{
void tzset();
}
else version( freebsd )
{
void tzset();
}

33
druntime/import/stdc/wctype.d
View File

@@ -1,33 +0,0 @@
/**
* D header file for C99.
*
* Copyright: Public Domain
* License: Public Domain
* Authors: Sean Kelly
* Standards: ISO/IEC 9899:1999 (E)
*/
module stdc.wctype;
private import stdc.stddef;
extern (C):
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);

0
druntime/lib/.empty
View File

10
druntime/license.txt
View File

@@ -1,10 +0,0 @@
Copyright (c) 2008, The D Runtime Project
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

10
druntime/readme.txt
View File

@@ -1,10 +0,0 @@
Druntime
The source code repository for druntime is: http://dsource.org/projects/druntime
Druntime is the minimum library required to support the D programming
language. It includes the system code required to support the garbage collector,
associative arrays, exception handling, array vector operations,
startup/shutdown, etc.
Druntime forms a common layer underlying the Phobos and Tango user libraries.

7
druntime/src/build-dmd.bat
View File

@@ -1,7 +0,0 @@
@echo off
set OLDHOME=%HOME%
set HOME=%CD%
make clean -fdmd-win32.mak
make lib install -fdmd-win32.mak
make clean -fdmd-win32.mak
set HOME=%OLDHOME%

19
druntime/src/build-dmd.sh
View File

@@ -1,19 +0,0 @@
#!/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 lib doc install -fdmd-posix.mak || goerror
make clean -fdmd-posix.mak || goerror
chmod 644 ../import/*.di || goerror
export HOME=$OLDHOME

19
druntime/src/build-ldc.sh
View File

@@ -1,19 +0,0 @@
#!/usr/bin/env bash
OLDHOME=$HOME
export HOME=`pwd`
goerror(){
export HOME=$OLDHOME
echo "="
echo "= *** Error ***"
echo "="
exit 1
}
make clean -fldc-gcc.mak || goerror
make lib doc install -fldc-gcc.mak || goerror
make clean -fldc-gcc.mak || goerror
chmod 644 ../import/*.di || goerror
export HOME=$OLDHOME

290
druntime/src/common/core/bitmanip.d
View File

@@ -1,290 +0,0 @@
/**
* 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 version( LDC )
{
public import ldc.bitmanip;
}
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 );
}
}

276
druntime/src/common/core/exception.d
View File

@@ -1,276 +0,0 @@
/**
* The exception module defines all system-level exceptions and provides a
* mechanism to alter system-level error handling.
*
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
* License: BSD Style, see LICENSE
* Authors: Sean Kelly
*/
module core.exception;
private
{
alias void function( string file, size_t line, string msg = null ) assertHandlerType;
assertHandlerType assertHandler = null;
}
/**
* Thrown on an array bounds error.
*/
class ArrayBoundsException : Exception
{
this( string file, size_t line )
{
super( "Array index out of bounds", file, line );
}
}
/**
* Thrown on an assert error.
*/
class AssertException : Exception
{
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 FinalizeException : Exception
{
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 HiddenFuncException : Exception
{
this( ClassInfo ci )
{
super( "Hidden method called for " ~ ci.name );
}
}
/**
* Thrown on an out of memory error.
*/
class OutOfMemoryException : Exception
{
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 SwitchException : Exception
{
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 AssertException 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 AssertException( 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 AssertException 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 AssertException( msg, file, line );
assertHandler( file, line, msg );
}
///////////////////////////////////////////////////////////////////////////////
// Internal Error Callbacks
///////////////////////////////////////////////////////////////////////////////
/**
* A callback for array bounds errors in D. An ArrayBoundsException will be
* thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* ArrayBoundsException.
*/
extern (C) void onArrayBoundsError( string file, size_t line )
{
throw new ArrayBoundsException( file, line );
}
/**
* A callback for finalize errors in D. A FinalizeException will be thrown.
*
* Params:
* e = The exception thrown during finalization.
*
* Throws:
* FinalizeException.
*/
extern (C) void onFinalizeError( ClassInfo info, Exception ex )
{
throw new FinalizeException( info, ex );
}
/**
* A callback for hidden function errors in D. A HiddenFuncException will be
* thrown.
*
* Throws:
* HiddenFuncException.
*/
extern (C) void onHiddenFuncError( Object o )
{
throw new HiddenFuncException( o.classinfo );
}
/**
* A callback for out of memory errors in D. An OutOfMemoryException will be
* thrown.
*
* Throws:
* OutOfMemoryException.
*/
extern (C) void onOutOfMemoryError()
{
// NOTE: Since an out of memory condition exists, no allocation must occur
// while generating this object.
throw cast(OutOfMemoryException) cast(void*) OutOfMemoryException.classinfo.init;
}
/**
* A callback for switch errors in D. A SwitchException will be thrown.
*
* Params:
* file = The name of the file that signaled this error.
* line = The line number on which this error occurred.
*
* Throws:
* SwitchException.
*/
extern (C) void onSwitchError( string file, size_t line )
{
throw new SwitchException( 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 );
}

484
druntime/src/common/core/memory.d
View File

@@ -1,484 +0,0 @@
/**
* The memory module provides an interface to the garbage collector and to
* any other OS or API-level memory management facilities.
*
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
* License: BSD Style, see LICENSE
* Authors: Sean Kelly
*/
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 );
extern (C) void* gc_getHandle();
extern (C) void gc_setHandle( void* p );
extern (C) void gc_endHandle();
}
/**
* This struct encapsulates all garbage collection functionality for the D
* programming language.
*/
struct GC
{
/**
* Enables the garbage collector 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 the garbage
* collector is enabled.
*/
static void enable()
{
gc_enable();
}
/**
* Disables the garbage collector. 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 );
}
/**
* Get handle to the collector.
* The only thing that can be done with this handle is pass it to
* setHandle(). getHandle/setHandle/endHandle work together so that
* if there are multiple instances of the gc running, only one instance
* can be set to run.
* The most common case of this is under Windows where a D application
* calls functions in a DLL that is implemented in D.
*/
static void* getHandle()
{
return gc_getHandle();
}
/**
* Set handle to the collector.
* The handle p is an opaque handle, acquired by a call to
* getHandle().
*/
static void setHandle(void* p)
{
gc_setHandle(p);
}
/**
* Call when done using the collector specified by the
* call to setHandle().
*/
static void endHandle()
{
gc_endHandle();
}
}

171
druntime/src/common/core/runtime.d
View File

@@ -1,171 +0,0 @@
/**
* The runtime module exposes information specific to the D runtime code.
*
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
* License: BSD Style, see LICENSE
* Authors: Sean Kelly
*/
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( Exception ) ExceptionHandler;
extern (C) bool rt_init( ExceptionHandler dg = null );
extern (C) bool rt_term( ExceptionHandler dg = null );
}
///////////////////////////////////////////////////////////////////////////////
// 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( void delegate( Exception ) 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( void delegate( Exception ) 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();
}
/**
* 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:
static 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();
}

3322
druntime/src/common/core/thread.d
View File

File diff suppressed because it is too large Load Diff

139
druntime/src/common/ldc.mak
View File

@@ -1,139 +0,0 @@
# Makefile to build the D runtime library core components for Posix
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the common library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET=libdruntime-core.a
LIB_MASK=libdruntime-core*.a
CP=cp -f
RM=rm -f
MD=mkdir -p
ADD_CFLAGS=
ADD_DFLAGS=
CFLAGS=-O $(ADD_CFLAGS)
#CFLAGS=-g $(ADD_CFLAGS)
DFLAGS=-release -O -inline -w $(ADD_DFLAGS)
#DFLAGS=-g -w $(ADD_DFLAGS)
TFLAGS=-O -inline -w $(ADD_DFLAGS)
#TFLAGS=-g -w $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=$(AR) -qsv
DC=ldc2
INC_DEST=../../import
LIB_DEST=../../lib
DOC_DEST=../../doc
.SUFFIXES: .s .S .c .cpp .d .html .o
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.o:
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@
# $(DC) -c $(DFLAGS) $< -of$@
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
targets : lib doc
all : lib doc
core : lib
lib : core.lib
doc : core.doc
######################################################
OBJ_CORE= \
core/bitmanip.o \
core/exception.o \
core/memory_.o \
core/runtime.o \
core/thread.o
OBJ_STDC= \
stdc/errno.o
ALL_OBJS= \
$(OBJ_CORE) \
$(OBJ_STDC)
######################################################
DOC_CORE= \
core/bitmanip.html \
core/exception.html \
core/memory.html \
core/runtime.html \
core/thread.html
ALL_DOCS=
######################################################
core.lib : $(LIB_TARGET)
$(LIB_TARGET) : $(ALL_OBJS)
$(RM) $@
$(LC) $@ $(ALL_OBJS)
core.doc : $(ALL_DOCS)
echo Documentation generated.
######################################################
### bitmanip
core/bitmanip.o : core/bitmanip.d
$(DC) -c $(DFLAGS) core/bitmanip.d -of$@
### memory
core/memory_.o : core/memory.d
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@
### thread
core/thread.o : core/thread.d
$(DC) -c $(DFLAGS) -d -Hf$*.di core/thread.d -of$@
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS)
$(RM) $(ALL_DOCS)
find . -name "$(LIB_MASK)" | xargs $(RM)
install :
$(MD) $(INC_DEST)
find . -name "*.di" -exec cp -f {} $(INC_DEST)/{} \;
$(MD) $(DOC_DEST)
find . -name "*.html" -exec cp -f {} $(DOC_DEST)/{} \;
$(MD) $(LIB_DEST)
find . -name "$(LIB_MASK)" -exec cp -f {} $(LIB_DEST)/{} \;

139
druntime/src/common/posix.mak
View File

@@ -1,139 +0,0 @@
# Makefile to build the D runtime library core components for Posix
# Designed to work with GNU make
# Targets:
# make
# Same as make all
# make lib
# Build the common library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET=libdruntime-core.a
LIB_MASK=libdruntime-core*.a
CP=cp -f
RM=rm -f
MD=mkdir -p
ADD_CFLAGS=
ADD_DFLAGS=
CFLAGS=-O $(ADD_CFLAGS)
#CFLAGS=-g $(ADD_CFLAGS)
DFLAGS=-release -O -inline -w -nofloat $(ADD_DFLAGS)
#DFLAGS=-g -w -nofloat $(ADD_DFLAGS)
TFLAGS=-O -inline -w -nofloat $(ADD_DFLAGS)
#TFLAGS=-g -w -nofloat $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=gcc
LC=$(AR) -qsv
DC=dmd
INC_DEST=../../import
LIB_DEST=../../lib
DOC_DEST=../../doc
.SUFFIXES: .s .S .c .cpp .d .html .o
.s.o:
$(CC) -c $(CFLAGS) $< -o$@
.S.o:
$(CC) -c $(CFLAGS) $< -o$@
.c.o:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.o:
g++ -c $(CFLAGS) $< -o$@
.d.o:
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@
# $(DC) -c $(DFLAGS) $< -of$@
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
targets : lib doc
all : lib doc
core : lib
lib : core.lib
doc : core.doc
######################################################
OBJ_CORE= \
core/bitmanip.o \
core/exception.o \
core/memory_.o \
core/runtime.o \
core/thread.o
OBJ_STDC= \
stdc/errno.o
ALL_OBJS= \
$(OBJ_CORE) \
$(OBJ_STDC)
######################################################
DOC_CORE= \
core/bitmanip.html \
core/exception.html \
core/memory.html \
core/runtime.html \
core/thread.html
ALL_DOCS=
######################################################
core.lib : $(LIB_TARGET)
$(LIB_TARGET) : $(ALL_OBJS)
$(RM) $@
$(LC) $@ $(ALL_OBJS)
core.doc : $(ALL_DOCS)
echo Documentation generated.
######################################################
### bitmanip
core/bitmanip.o : core/bitmanip.d
$(DC) -c $(DFLAGS) core/bitmanip.d -of$@
### memory
core/memory_.o : core/memory.d
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@
### thread
core/thread.o : core/thread.d
$(DC) -c $(DFLAGS) -d -Hf$*.di core/thread.d -of$@
######################################################
clean :
find . -name "*.di" | xargs $(RM)
$(RM) $(ALL_OBJS)
$(RM) $(ALL_DOCS)
find . -name "$(LIB_MASK)" | xargs $(RM)
install :
$(MD) $(INC_DEST)
find . -name "*.di" -exec cp -f {} $(INC_DEST)/{} \;
$(MD) $(DOC_DEST)
find . -name "*.html" -exec cp -f {} $(DOC_DEST)/{} \;
$(MD) $(LIB_DEST)
find . -name "$(LIB_MASK)" -exec cp -f {} $(LIB_DEST)/{} \;

21
druntime/src/common/stdc/errno.c
View File

@@ -1,21 +0,0 @@
/**
* This file contains wrapper functions for macro-defined C rouines.
*
* Copyright: Copyright (c) 2005-2008, The D Runtime Project
* License: BSD Style, see LICENSE
* Authors: Sean Kelly
*/
#include <errno.h>
int getErrno()
{
return errno;
}
int setErrno( int val )
{
errno = val;
return val;
}

130
druntime/src/common/win32.mak
View File

@@ -1,130 +0,0 @@
# Makefile to build the D runtime library core components for Win32
# Designed to work with DigitalMars make
# Targets:
# make
# Same as make all
# make lib
# Build the common library
# make doc
# Generate documentation
# make clean
# Delete unneeded files created by build process
LIB_TARGET=druntime-core.lib
LIB_MASK=druntime-core*.lib
CP=xcopy /y
RM=del /f
MD=mkdir
ADD_CFLAGS=
ADD_DFLAGS=
CFLAGS=-mn -6 -r $(ADD_CFLAGS)
#CFLAGS=-g -mn -6 -r $(ADD_CFLAGS)
DFLAGS=-release -O -inline -w -nofloat $(ADD_DFLAGS)
#DFLAGS=-g -w -nofloat $(ADD_DFLAGS)
TFLAGS=-O -inline -w -nofloat $(ADD_DFLAGS)
#TFLAGS=-g -w -nofloat $(ADD_DFLAGS)
DOCFLAGS=-version=DDoc
CC=dmc
LC=lib
DC=dmd
INC_DEST=..\..\import
LIB_DEST=..\..\lib
DOC_DEST=..\..\doc
.DEFAULT: .asm .c .cpp .d .html .obj
.asm.obj:
$(CC) -c $<
.c.obj:
$(CC) -c $(CFLAGS) $< -o$@
.cpp.obj:
$(CC) -c $(CFLAGS) $< -o$@
.d.obj:
$(DC) -c $(DFLAGS) -Hf$*.di $< -of$@
# $(DC) -c $(DFLAGS) $< -of$@
.d.html:
$(DC) -c -o- $(DOCFLAGS) -Df$*.html $<
targets : lib doc
all : lib doc
core : lib
lib : core.lib
doc : core.doc
######################################################
OBJ_CORE= \
core\bitmanip.obj \
core\exception.obj \
core\memory.obj \
core\runtime.obj \
core\thread.obj
OBJ_STDC= \
stdc\errno.obj
ALL_OBJS= \
$(OBJ_CORE) \
$(OBJ_STDC)
######################################################
DOC_CORE= \
core\bitmanip.html \
core\exception.html \
core\memory.html \
core\runtime.html \
core\thread.html
ALL_DOCS=
######################################################
core.lib : $(LIB_TARGET)
$(LIB_TARGET) : $(ALL_OBJS)
$(RM) $@
$(LC) -c -n $@ $(ALL_OBJS)
core.doc : $(ALL_DOCS)
@echo Documentation generated.
######################################################
### bitmanip
core\bitmanip.obj : core\bitmanip.d
$(DC) -c $(DFLAGS) core\bitmanip.d -of$@
### thread
core\thread.obj : core\thread.d
$(DC) -c $(DFLAGS) -d -Hf$*.di core\thread.d -of$@
######################################################
clean :
$(RM) /s .\*.di
$(RM) $(ALL_OBJS)
$(RM) $(ALL_DOCS)
$(RM) $(LIB_MASK)
install :
$(MD) $(INC_DEST)\.
$(CP) /s *.di $(INC_DEST)\.
$(MD) $(DOC_DEST)
$(CP) /s *.html $(DOC_DEST)\.
$(MD) $(LIB_DEST)
$(CP) $(LIB_MASK) $(LIB_DEST)\.

408
druntime/src/compiler/dmd/aApply.d
View File

@@ -1,408 +0,0 @@
/**
* Part of the D programming language runtime library.
*/
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.aApply;
/* 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.
*/
private import 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;
}

974
druntime/src/compiler/dmd/aApplyR.d
View File

@@ -1,974 +0,0 @@
/**
* Part of the D programming language runtime library.
*/
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
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 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);
}

886
druntime/src/compiler/dmd/aaA.d
View File

@@ -1,886 +0,0 @@
//_ aaA.d
/**
* Part of the D programming language runtime library.
* Implementation of associative arrays.
*/
/*
* Copyright (C) 2000-2008 by Digital Mars, http://www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.aaA;
private
{
import stdc.stdarg;
import stdc.string;
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
static 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;
auto keysize = aligntsize(keyti.tsize());
if (!aa.a)
aa.a = new BB();
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).length, nodes);
if (nodes > aa.a.b.length * 4)
{
_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);
}
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;
}

625
druntime/src/compiler/dmd/adi.d
View File

@@ -1,625 +0,0 @@
//_ adi.d
/**
* Part of the D programming language runtime library.
* Dynamic array property support routines
*/
/*
* Copyright (C) 2000-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.adi;
//debug=adi; // uncomment to turn on debugging printf's
private
{
debug(adi) import stdc.stdio;
import stdc.string;
import stdc.stdlib;
import 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");
}

110
druntime/src/compiler/dmd/alloca.d
View File

@@ -1,110 +0,0 @@
/*_ _alloca.d
* Copyright (C) 1990-2003 by Digital Mars, www.digitalmars.com
* All Rights Reserved
* Written by Walter Bright
*/
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 ;
add EAX,3 ;
and EAX,0xFFFFFFFC ; // round up to dword
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 ;
}
}

180
druntime/src/compiler/dmd/arrayassign.d
View File

@@ -1,180 +0,0 @@
/**
* Part of the D programming language runtime library.
* http://www.digitalmars.com
* Written by Walter Bright
* Placed in the Public Domain
*/
module rt.arrayassign;
private
{
import util.string;
import stdc.string;
import stdc.stdlib;
debug(PRINTF) import 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;
}

1890
druntime/src/compiler/dmd/arraybyte.d
View File

File diff suppressed because it is too large Load Diff

109
druntime/src/compiler/dmd/arraycast.d
View File

@@ -1,109 +0,0 @@
/*
* Copyright (C) 2004-2007 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
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);
}
}
}

61
druntime/src/compiler/dmd/arraycat.d
View File

@@ -1,61 +0,0 @@
/**
* Part of the D programming language runtime library.
*/
/*
* Copyright (C) 2004-2007 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.arraycat;
private
{
import stdc.string;
debug import 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;
}

1714
druntime/src/compiler/dmd/arraydouble.d
View File

File diff suppressed because it is too large Load Diff

2303
druntime/src/compiler/dmd/arrayfloat.d
View File

File diff suppressed because it is too large Load Diff

2427
druntime/src/compiler/dmd/arrayint.d
View File

File diff suppressed because it is too large Load Diff

234
druntime/src/compiler/dmd/arrayreal.d
View File

@@ -1,234 +0,0 @@
/***************************
* D programming language http://www.digitalmars.com/d/
* Runtime support for double array operations.
* Placed in public domain.
*/
module rt.arrayreal;
import util.cpuid;
version (Unittest)
{
/* This is so unit tests will test every CPU variant
*/
int cpuid;
const int CPUID_MAX = 1;
bool mmx() { return cpuid == 1 && util.cpuid.mmx(); }
bool sse() { return cpuid == 2 && util.cpuid.sse(); }
bool sse2() { return cpuid == 3 && util.cpuid.sse2(); }
bool amd3dnow() { return cpuid == 4 && util.cpuid.amd3dnow(); }
}
else
{
alias util.cpuid.mmx mmx;
alias util.cpuid.sse sse;
alias util.cpuid.sse2 sse2;
alias 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);
}
}
}
}
}

2300
druntime/src/compiler/dmd/arrayshort.d
View File

File diff suppressed because it is too large Load Diff

184
druntime/src/compiler/dmd/cast_.d
View File

@@ -1,184 +0,0 @@
/*
* Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
* Written by Walter Bright
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, in both source and binary form, subject to the following
* restrictions:
*
* o The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* o Altered source versions must be plainly marked as such, and must not
* be misrepresented as being the original software.
* o This notice may not be removed or altered from any source
* distribution.
*/
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.cast_;
extern (C):
/******************************************
* Given a pointer:
* If it is an Object, return that Object.
* If it is an interface, return the Object implementing the interface.
* If it is null, return null.
* Else, undefined crash
*/
Object _d_toObject(void* p)
{ Object o;
if (p)
{
o = cast(Object)p;
ClassInfo oc = o.classinfo;
Interface *pi = **cast(Interface ***)p;
/* Interface.offset lines up with ClassInfo.name.ptr,
* so we rely on pointers never being less than 64K,
* and Objects never being greater.
*/
if (pi.offset < 0x10000)
{
//printf("\tpi.offset = %d\n", pi.offset);
o = cast(Object)(p - pi.offset);
}
}
return o;
}
/*************************************
* Attempts to cast Object o to class c.
* Returns o if successful, null if not.
*/
Object _d_interface_cast(void* p, ClassInfo c)
{ Object o;
//printf("_d_interface_cast(p = %p, c = '%.*s')\n", p, c.name);
if (p)
{
Interface *pi = **cast(Interface ***)p;
//printf("\tpi.offset = %d\n", pi.offset);
o = cast(Object)(p - pi.offset);
return _d_dynamic_cast(o, c);
}
return o;
}
Object _d_dynamic_cast(Object o, ClassInfo c)
{ ClassInfo oc;
size_t offset = 0;
//printf("_d_dynamic_cast(o = %p, c = '%.*s')\n", o, c.name);
if (o)
{
oc = o.classinfo;
if (_d_isbaseof2(oc, c, offset))
{
//printf("\toffset = %d\n", offset);
o = cast(Object)(cast(void*)o + offset);
}
else
o = null;
}
//printf("\tresult = %p\n", o);
return o;
}
int _d_isbaseof2(ClassInfo oc, ClassInfo c, inout size_t offset)
{ int i;
if (oc is c)
return 1;
do
{
if (oc.base is c)
return 1;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
if (ic is c)
{ offset = oc.interfaces[i].offset;
return 1;
}
}
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
if (_d_isbaseof2(ic, c, offset))
{ offset = oc.interfaces[i].offset;
return 1;
}
}
oc = oc.base;
} while (oc);
return 0;
}
int _d_isbaseof(ClassInfo oc, ClassInfo c)
{ int i;
if (oc is c)
return 1;
do
{
if (oc.base is c)
return 1;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo ic;
ic = oc.interfaces[i].classinfo;
if (ic is c || _d_isbaseof(ic, c))
return 1;
}
oc = oc.base;
} while (oc);
return 0;
}
/*********************************
* Find the vtbl[] associated with Interface ic.
*/
void *_d_interface_vtbl(ClassInfo ic, Object o)
{ int i;
ClassInfo oc;
//printf("__d_interface_vtbl(o = %p, ic = %p)\n", o, ic);
assert(o);
oc = o.classinfo;
for (i = 0; i < oc.interfaces.length; i++)
{
ClassInfo oic;
oic = oc.interfaces[i].classinfo;
if (oic is ic)
{
return cast(void *)oc.interfaces[i].vtbl;
}
}
assert(0);
}

218
druntime/src/compiler/dmd/cmath2.d
View File

@@ -1,218 +0,0 @@
// Copyright (C) 2001-2003 by Digital Mars
// All Rights Reserved
// www.digitalmars.com
// Runtime support for complex arithmetic code generation
// (for linux)
/*
* Modified by Sean Kelly for use with the D Runtime Project
*/
module rt.cmath2;
private import stdc.math;
extern (C):
/****************************
* Multiply two complex floating point numbers, x and y.
* Input:
* x.re ST3
* x.im ST2
* y.re ST1
* y.im ST0
* Output:
* ST1 real part
* ST0 imaginary part
*/
void _Cmul()
{
// p.re = x.re * y.re - x.im * y.im;
// p.im = x.im * y.re + x.re * y.im;
asm
{ naked ;
fld ST(1) ; // x.re
fmul ST,ST(4) ; // ST0 = x.re * y.re
fld ST(1) ; // y.im
fmul ST,ST(4) ; // ST0 = x.im * y.im
fsubp ST(1),ST ; // ST0 = x.re * y.re - x.im * y.im
fld ST(3) ; // x.im
fmul ST,ST(3) ; // ST0 = x.im * y.re
fld ST(5) ; // x.re
fmul ST,ST(3) ; // ST0 = x.re * y.im
faddp ST(1),ST ; // ST0 = x.im * y.re + x.re * y.im
fxch ST(4),ST ;
fstp ST(0) ;
fxch ST(4),ST ;
fstp ST(0) ;
fstp ST(0) ;
fstp ST(0) ;
ret ;
}
/+
if (isnan(x) && isnan(y))
{
// Recover infinities that computed as NaN+ iNaN ...
int recalc = 0;
if ( isinf( a) || isinf( b) )
{ // z is infinite
// "Box" the infinity and change NaNs in the other factor to 0
a = copysignl( isinf( a) ? 1.0 : 0.0, a);
b = copysignl( isinf( b) ? 1.0 : 0.0, b);
if (isnan( c)) c = copysignl( 0.0, c);
if (isnan( d)) d = copysignl( 0.0, d);
recalc = 1;
}
if (isinf(c) || isinf(d))
{ // w is infinite
// "Box" the infinity and change NaNs in the other factor to 0
c = copysignl( isinf( c) ? 1.0 : 0.0, c);
d = copysignl( isinf( d) ? 1.0 : 0.0, d);
if (isnan( a)) a = copysignl( 0.0, a);
if (isnan( b)) b = copysignl( 0.0, b);
recalc = 1;
}
if (!recalc && (isinf(ac) || isinf(bd) ||
isinf(ad) || isinf(bc)))
{
// Recover infinities from overflow by changing NaNs to 0 ...
if (isnan( a)) a = copysignl( 0.0, a);
if (isnan( b)) b = copysignl( 0.0, b);
if (isnan( c)) c = copysignl( 0.0, c);
if (isnan( d)) d = copysignl( 0.0, d);
recalc = 1;
}
if (recalc)
{
x = INFINITY * (a * c - b * d);
y = INFINITY * (a * d + b * c);
}
}
+/
}
/****************************
* Divide two complex floating point numbers, x / y.
* Input:
* x.re ST3
* x.im ST2
* y.re ST1
* y.im ST0
* Output:
* ST1 real part
* ST0 imaginary part
*/
void _Cdiv()
{
real x_re, x_im;
real y_re, y_im;
real q_re, q_im;
real r;
real den;
asm
{
fstp y_im ;
fstp y_re ;
fstp x_im ;
fstp x_re ;
}
if (fabs(y_re) < fabs(y_im))
{
r = y_re / y_im;
den = y_im + r * y_re;
q_re = (x_re * r + x_im) / den;
q_im = (x_im * r - x_re) / den;
}
else
{
r = y_im / y_re;
den = y_re + r * y_im;
q_re = (x_re + r * x_im) / den;
q_im = (x_im - r * x_re) / den;
}
//printf("q.re = %g, q.im = %g\n", (double)q_re, (double)q_im);
/+
if (isnan(q_re) && isnan(q_im))
{
real denom = y_re * y_re + y_im * y_im;
// non-zero / zero
if (denom == 0.0 && (!isnan(x_re) || !isnan(x_im)))
{
q_re = copysignl(INFINITY, y_re) * x_re;
q_im = copysignl(INFINITY, y_re) * x_im;
}
// infinite / finite
else if ((isinf(x_re) || isinf(x_im)) && isfinite(y_re) && isfinite(y_im))
{
x_re = copysignl(isinf(x_re) ? 1.0 : 0.0, x_re);
x_im = copysignl(isinf(x_im) ? 1.0 : 0.0, x_im);
q_re = INFINITY * (x_re * y_re + x_im * y_im);
q_im = INFINITY * (x_im * y_re - x_re * y_im);
}
// finite / infinite
else if (isinf(logbw) && isfinite(x_re) && isfinite(x_im))
{
y_re = copysignl(isinf(y_re) ? 1.0 : 0.0, y_re);
y_im = copysignl(isinf(y_im) ? 1.0 : 0.0, y_im);
q_re = 0.0 * (x_re * y_re + x_im * y_im);
q_im = 0.0 * (x_im * y_re - x_re * y_im);
}
}
return q_re + q_im * 1.0i;
+/
asm
{
fld q_re;
fld q_im;
}
}
/****************************
* Compare two complex floating point numbers, x and y.
* Input:
* x.re ST3
* x.im ST2
* y.re ST1
* y.im ST0
* Output:
* 8087 stack is cleared
* flags set
*/
void _Ccmp()
{
asm
{ naked ;
fucomp ST(2) ; // compare x.im and y.im
fstsw AX ;
sahf ;
jne L1 ;
jp L1 ; // jmp if NAN
fucomp ST(2) ; // compare x.re and y.re
fstsw AX ;
sahf ;
fstp ST(0) ; // pop
fstp ST(0) ; // pop
ret ;
L1:
fstp ST(0) ; // pop
fstp ST(0) ; // pop
fstp ST(0) ; // pop
ret ;
}
}

36
druntime/src/compiler/dmd/compiler.d
View File

@@ -1,36 +0,0 @@
/* Written by Walter Bright
* www.digitalmars.com
* Placed into Public Domain
*/
module rt.compiler;
// Identify the compiler used and its various features.
const
{
// Vendor specific string naming the compiler
char[] name = "Digital Mars D";
// Master list of D compiler vendors
enum Vendor
{
DigitalMars = 1
}
// Which vendor we are
Vendor vendor = Vendor.DigitalMars;
// The vendor specific version number, as in
// version_major.version_minor
uint version_major = 0;
uint version_minor = 0;
// The version of the D Programming Language Specification
// Supported by the compiler
uint D_major = 0;
uint D_minor = 0;
}

Some files were not shown because too many files have changed in this diff Show More