diff --git a/druntime/doc/.empty b/druntime/doc/.empty
new file mode 100644
index 00000000..e69de29b
diff --git a/druntime/import/core/bitmanip.di b/druntime/import/core/bitmanip.di
new file mode 100644
index 00000000..ab2c3ec5
--- /dev/null
+++ b/druntime/import/core/bitmanip.di
@@ -0,0 +1,262 @@
+/**
+ * This module contains a collection of bit-level operations.
+ *
+ * Copyright: Copyright (c) 2005-2008, The D Runtime Project
+ * License: BSD Style, see LICENSE
+ * Authors: Walter Bright, Don Clugston, Sean Kelly
+ */
+module 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
+ * 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", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btc(array, 35) = %d\n", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bts(array, 35) = %d\n", bts(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btr(array, 35) = %d\n", btr(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bt(array, 1) = %d\n", bt(array, 1));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ return 0;
+ }
+ * ---
+ * Output:
+
+ 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
+
+ */
+ 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;
+
+ }
+}
diff --git a/druntime/import/core/exception.di b/druntime/import/core/exception.di
new file mode 100644
index 00000000..d298e7a6
--- /dev/null
+++ b/druntime/import/core/exception.di
@@ -0,0 +1,114 @@
+// 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);
+}
diff --git a/druntime/import/core/memory.di b/druntime/import/core/memory.di
new file mode 100644
index 00000000..e051b731
--- /dev/null
+++ b/druntime/import/core/memory.di
@@ -0,0 +1,282 @@
+// 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();
+}
+}
+}
diff --git a/druntime/import/core/memory_.di b/druntime/import/core/memory_.di
new file mode 100644
index 00000000..f2c17764
--- /dev/null
+++ b/druntime/import/core/memory_.di
@@ -0,0 +1,282 @@
+// 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();
+}
+}
+}
diff --git a/druntime/import/core/runtime.di b/druntime/import/core/runtime.di
new file mode 100644
index 00000000..3fa0d209
--- /dev/null
+++ b/druntime/import/core/runtime.di
@@ -0,0 +1,85 @@
+// 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();
+}
diff --git a/druntime/import/core/thread.di b/druntime/import/core/thread.di
new file mode 100644
index 00000000..1f2656f6
--- /dev/null
+++ b/druntime/import/core/thread.di
@@ -0,0 +1,792 @@
+// 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();
+}
+}
+}
+}
+}
+}
+}
diff --git a/druntime/import/ldc/bitmanip.di b/druntime/import/ldc/bitmanip.di
new file mode 100644
index 00000000..c055903f
--- /dev/null
+++ b/druntime/import/ldc/bitmanip.di
@@ -0,0 +1,49 @@
+// 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);
diff --git a/druntime/import/ldc/vararg.di b/druntime/import/ldc/vararg.di
new file mode 100644
index 00000000..157859ac
--- /dev/null
+++ b/druntime/import/ldc/vararg.di
@@ -0,0 +1,32 @@
+// 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;
+}
diff --git a/druntime/import/object.di b/druntime/import/object.di
new file mode 100644
index 00000000..d182b6c0
--- /dev/null
+++ b/druntime/import/object.di
@@ -0,0 +1,248 @@
+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);
+}
diff --git a/druntime/import/std/c/stdarg.di b/druntime/import/std/c/stdarg.di
new file mode 100644
index 00000000..29f4f1eb
--- /dev/null
+++ b/druntime/import/std/c/stdarg.di
@@ -0,0 +1,32 @@
+/**
+ * These functions are built-in intrinsics to the compiler.
+ *
+ * Copyright: Public Domain
+ * License: Public Domain
+ * Authors: David Friedman
+ */
+module std.c.stdarg;
+
+version( GNU )
+{
+ private import gcc.builtins;
+ alias __builtin_va_list va_list;
+ alias __builtin_va_end va_end;
+ alias __builtin_va_copy va_copy;
+}
+
+template va_start(T)
+{
+ void va_start( out va_list ap, inout T parmn )
+ {
+
+ }
+}
+
+template va_arg(T)
+{
+ T va_arg( inout va_list ap )
+ {
+ return T.init;
+ }
+}
diff --git a/druntime/import/std/intrinsic.di b/druntime/import/std/intrinsic.di
new file mode 100644
index 00000000..25a8332a
--- /dev/null
+++ b/druntime/import/std/intrinsic.di
@@ -0,0 +1,176 @@
+/**
+ * These functions are built-in intrinsics to the compiler.
+ *
+ * Intrinsic functions are functions built in to the compiler, usually to take
+ * advantage of specific CPU features that are inefficient to handle via
+ * external functions. The compiler's optimizer and code generator are fully
+ * integrated in with intrinsic functions, bringing to bear their full power on
+ * them. This can result in some surprising speedups.
+ *
+ * Copyright: Public Domain
+ * License: Public Domain
+ * Authors: Walter Bright
+ */
+module std.intrinsic;
+
+
+/**
+ * Scans the bits in v starting with bit 0, looking
+ * for the first set bit.
+ * Returns:
+ * The bit number of the first bit set.
+ * The return value is undefined if v is zero.
+ */
+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
+ * 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", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btc(array, 35) = %d\n", btc(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bts(array, 35) = %d\n", bts(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("btr(array, 35) = %d\n", btr(array, 35));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ printf("bt(array, 1) = %d\n", bt(array, 1));
+ printf("array = [0]:x%x, [1]:x%x\n", array[0], array[1]);
+
+ return 0;
+}
+ * ---
+ * Output:
+
+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
+
+ */
+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 );
diff --git a/druntime/import/std/stdarg.di b/druntime/import/std/stdarg.di
new file mode 100644
index 00000000..8fccb13a
--- /dev/null
+++ b/druntime/import/std/stdarg.di
@@ -0,0 +1,32 @@
+/**
+ * These functions are built-in intrinsics to the compiler.
+ *
+ * Copyright: Public Domain
+ * License: Public Domain
+ * Authors: David Friedman
+ */
+module std.stdarg;
+
+version( GNU )
+{
+ private import gcc.builtins;
+ alias __builtin_va_list va_list;
+ alias __builtin_va_end va_end;
+ alias __builtin_va_copy va_copy;
+}
+
+template va_start(T)
+{
+ void va_start( out va_list ap, inout T parmn )
+ {
+
+ }
+}
+
+template va_arg(T)
+{
+ T va_arg( inout va_list ap )
+ {
+ return T.init;
+ }
+}
diff --git a/druntime/import/stdc/complex.d b/druntime/import/stdc/complex.d
new file mode 100644
index 00000000..07e18b8f
--- /dev/null
+++ b/druntime/import/stdc/complex.d
@@ -0,0 +1,99 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/config.d b/druntime/import/stdc/config.d
new file mode 100644
index 00000000..0270cdd5
--- /dev/null
+++ b/druntime/import/stdc/config.d
@@ -0,0 +1,30 @@
+/**
+ * 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;
+ }
+}
diff --git a/druntime/import/stdc/ctype.d b/druntime/import/stdc/ctype.d
new file mode 100644
index 00000000..572a989c
--- /dev/null
+++ b/druntime/import/stdc/ctype.d
@@ -0,0 +1,26 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/errno.d b/druntime/import/stdc/errno.d
new file mode 100644
index 00000000..dcd3604b
--- /dev/null
+++ b/druntime/import/stdc/errno.d
@@ -0,0 +1,375 @@
+/**
+ * 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
+}
diff --git a/druntime/import/stdc/fenv.d b/druntime/import/stdc/fenv.d
new file mode 100644
index 00000000..e9cdeed8
--- /dev/null
+++ b/druntime/import/stdc/fenv.d
@@ -0,0 +1,137 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/inttypes.d b/druntime/import/stdc/inttypes.d
new file mode 100644
index 00000000..b1ae8558
--- /dev/null
+++ b/druntime/import/stdc/inttypes.d
@@ -0,0 +1,252 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/limits.d b/druntime/import/stdc/limits.d
new file mode 100644
index 00000000..436bbdab
--- /dev/null
+++ b/druntime/import/stdc/limits.d
@@ -0,0 +1,33 @@
+/**
+ * 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;
diff --git a/druntime/import/stdc/locale.d b/druntime/import/stdc/locale.d
new file mode 100644
index 00000000..1e96d7f2
--- /dev/null
+++ b/druntime/import/stdc/locale.d
@@ -0,0 +1,55 @@
+/**
+ * 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();
diff --git a/druntime/import/stdc/math.d b/druntime/import/stdc/math.d
new file mode 100644
index 00000000..8e3e284a
--- /dev/null
+++ b/druntime/import/stdc/math.d
@@ -0,0 +1,928 @@
+/**
+ * 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);
+}
\ No newline at end of file
diff --git a/druntime/import/stdc/posix/arpa/inet.d b/druntime/import/stdc/posix/arpa/inet.d
new file mode 100644
index 00000000..0542cf34
--- /dev/null
+++ b/druntime/import/stdc/posix/arpa/inet.d
@@ -0,0 +1,127 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/posix/config.d b/druntime/import/stdc/posix/config.d
new file mode 100644
index 00000000..5b5105bb
--- /dev/null
+++ b/druntime/import/stdc/posix/config.d
@@ -0,0 +1,27 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/posix/dirent.d b/druntime/import/stdc/posix/dirent.d
new file mode 100644
index 00000000..8cb447c3
--- /dev/null
+++ b/druntime/import/stdc/posix/dirent.d
@@ -0,0 +1,198 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/dlfcn.d b/druntime/import/stdc/posix/dlfcn.d
new file mode 100644
index 00000000..4f8c2fbd
--- /dev/null
+++ b/druntime/import/stdc/posix/dlfcn.d
@@ -0,0 +1,65 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/fcntl.d b/druntime/import/stdc/posix/fcntl.d
new file mode 100644
index 00000000..caf6542e
--- /dev/null
+++ b/druntime/import/stdc/posix/fcntl.d
@@ -0,0 +1,248 @@
+/**
+ * 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);
+*/
diff --git a/druntime/import/stdc/posix/inttypes.d b/druntime/import/stdc/posix/inttypes.d
new file mode 100644
index 00000000..495e9f8d
--- /dev/null
+++ b/druntime/import/stdc/posix/inttypes.d
@@ -0,0 +1,30 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/posix/net/if_.d b/druntime/import/stdc/posix/net/if_.d
new file mode 100644
index 00000000..d64f3574
--- /dev/null
+++ b/druntime/import/stdc/posix/net/if_.d
@@ -0,0 +1,77 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/netinet/in_.d b/druntime/import/stdc/posix/netinet/in_.d
new file mode 100644
index 00000000..26e1fd80
--- /dev/null
+++ b/druntime/import/stdc/posix/netinet/in_.d
@@ -0,0 +1,327 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/posix/netinet/tcp.d b/druntime/import/stdc/posix/netinet/tcp.d
new file mode 100644
index 00000000..0f6d1513
--- /dev/null
+++ b/druntime/import/stdc/posix/netinet/tcp.d
@@ -0,0 +1,33 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/posix/poll.d b/druntime/import/stdc/posix/poll.d
new file mode 100644
index 00000000..d3229877
--- /dev/null
+++ b/druntime/import/stdc/posix/poll.d
@@ -0,0 +1,133 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/pthread.d b/druntime/import/stdc/posix/pthread.d
new file mode 100644
index 00000000..30281434
--- /dev/null
+++ b/druntime/import/stdc/posix/pthread.d
@@ -0,0 +1,580 @@
+/**
+ * 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);
+*/
diff --git a/druntime/import/stdc/posix/pwd.d b/druntime/import/stdc/posix/pwd.d
new file mode 100644
index 00000000..2e76495c
--- /dev/null
+++ b/druntime/import/stdc/posix/pwd.d
@@ -0,0 +1,132 @@
+/**
+ * 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();
+}
diff --git a/druntime/import/stdc/posix/sched.d b/druntime/import/stdc/posix/sched.d
new file mode 100644
index 00000000..13cbb953
--- /dev/null
+++ b/druntime/import/stdc/posix/sched.d
@@ -0,0 +1,132 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/semaphore.d b/druntime/import/stdc/posix/semaphore.d
new file mode 100644
index 00000000..008e3943
--- /dev/null
+++ b/druntime/import/stdc/posix/semaphore.d
@@ -0,0 +1,97 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/setjmp.d b/druntime/import/stdc/posix/setjmp.d
new file mode 100644
index 00000000..6e489033
--- /dev/null
+++ b/druntime/import/stdc/posix/setjmp.d
@@ -0,0 +1,103 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/signal.d b/druntime/import/stdc/posix/signal.d
new file mode 100644
index 00000000..68500469
--- /dev/null
+++ b/druntime/import/stdc/posix/signal.d
@@ -0,0 +1,837 @@
+/**
+ * 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
+ 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*);
+}
diff --git a/druntime/import/stdc/posix/stdio.d b/druntime/import/stdc/posix/stdio.d
new file mode 100644
index 00000000..4324bc83
--- /dev/null
+++ b/druntime/import/stdc/posix/stdio.d
@@ -0,0 +1,214 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/stdlib.d b/druntime/import/stdc/posix/stdlib.d
new file mode 100644
index 00000000..b2350c42
--- /dev/null
+++ b/druntime/import/stdc/posix/stdlib.d
@@ -0,0 +1,305 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/sys/ipc.d b/druntime/import/stdc/posix/sys/ipc.d
new file mode 100644
index 00000000..42302ad5
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/ipc.d
@@ -0,0 +1,99 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/sys/mman.d b/druntime/import/stdc/posix/sys/mman.d
new file mode 100644
index 00000000..92bb35bb
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/mman.d
@@ -0,0 +1,308 @@
+/**
+ * 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);
+*/
diff --git a/druntime/import/stdc/posix/sys/select.d b/druntime/import/stdc/posix/sys/select.d
new file mode 100644
index 00000000..ad1b4c6c
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/select.d
@@ -0,0 +1,150 @@
+/**
+ * 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)];
+ }
+}
diff --git a/druntime/import/stdc/posix/sys/shm.d b/druntime/import/stdc/posix/sys/shm.d
new file mode 100644
index 00000000..f16d4cf5
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/shm.d
@@ -0,0 +1,111 @@
+/**
+ * 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<= 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
+ }
+}
diff --git a/druntime/import/stdc/posix/sys/stat.d b/druntime/import/stdc/posix/sys/stat.d
new file mode 100644
index 00000000..437d99ef
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/stat.d
@@ -0,0 +1,411 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/sys/time.d b/druntime/import/stdc/posix/sys/time.d
new file mode 100644
index 00000000..90559eba
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/time.d
@@ -0,0 +1,121 @@
+/**
+ * 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]);
+}
diff --git a/druntime/import/stdc/posix/sys/types.d b/druntime/import/stdc/posix/sys/types.d
new file mode 100644
index 00000000..fb5b7aa1
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/types.d
@@ -0,0 +1,429 @@
+/**
+ * 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
+*/
diff --git a/druntime/import/stdc/posix/sys/uio.d b/druntime/import/stdc/posix/sys/uio.d
new file mode 100644
index 00000000..189f52de
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/uio.d
@@ -0,0 +1,65 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/sys/wait.d b/druntime/import/stdc/posix/sys/wait.d
new file mode 100644
index 00000000..700c29f4
--- /dev/null
+++ b/druntime/import/stdc/posix/sys/wait.d
@@ -0,0 +1,136 @@
+/**
+ * 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);
+*/
diff --git a/druntime/import/stdc/posix/termios.d b/druntime/import/stdc/posix/termios.d
new file mode 100644
index 00000000..d9e373bd
--- /dev/null
+++ b/druntime/import/stdc/posix/termios.d
@@ -0,0 +1,523 @@
+/**
+ * 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);
+}
diff --git a/druntime/import/stdc/posix/time.d b/druntime/import/stdc/posix/time.d
new file mode 100644
index 00000000..652f24d6
--- /dev/null
+++ b/druntime/import/stdc/posix/time.d
@@ -0,0 +1,257 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/ucontext.d b/druntime/import/stdc/posix/ucontext.d
new file mode 100644
index 00000000..6b1bf166
--- /dev/null
+++ b/druntime/import/stdc/posix/ucontext.d
@@ -0,0 +1,155 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/posix/unistd.d b/druntime/import/stdc/posix/unistd.d
new file mode 100644
index 00000000..f9c93b63
--- /dev/null
+++ b/druntime/import/stdc/posix/unistd.d
@@ -0,0 +1,594 @@
+/**
+ * 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();
+}
diff --git a/druntime/import/stdc/posix/utime.d b/druntime/import/stdc/posix/utime.d
new file mode 100644
index 00000000..40e073e9
--- /dev/null
+++ b/druntime/import/stdc/posix/utime.d
@@ -0,0 +1,58 @@
+/**
+ * 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*);
+}
diff --git a/druntime/import/stdc/signal.d b/druntime/import/stdc/signal.d
new file mode 100644
index 00000000..1680e702
--- /dev/null
+++ b/druntime/import/stdc/signal.d
@@ -0,0 +1,48 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/stdarg.d b/druntime/import/stdc/stdarg.d
new file mode 100644
index 00000000..4b28aeca
--- /dev/null
+++ b/druntime/import/stdc/stdarg.d
@@ -0,0 +1,51 @@
+/**
+ * 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;
+ }
+}
diff --git a/druntime/import/stdc/stddef.d b/druntime/import/stdc/stddef.d
new file mode 100644
index 00000000..439eddc2
--- /dev/null
+++ b/druntime/import/stdc/stddef.d
@@ -0,0 +1,33 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/stdint.d b/druntime/import/stdc/stdint.d
new file mode 100644
index 00000000..36c75fdb
--- /dev/null
+++ b/druntime/import/stdc/stdint.d
@@ -0,0 +1,151 @@
+/**
+ * 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;
diff --git a/druntime/import/stdc/stdio.d b/druntime/import/stdc/stdio.d
new file mode 100644
index 00000000..905ac5ba
--- /dev/null
+++ b/druntime/import/stdc/stdio.d
@@ -0,0 +1,445 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/stdlib.d b/druntime/import/stdc/stdlib.d
new file mode 100644
index 00000000..ab3163a0
--- /dev/null
+++ b/druntime/import/stdc/stdlib.d
@@ -0,0 +1,101 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/string.d b/druntime/import/stdc/string.d
new file mode 100644
index 00000000..7443d342
--- /dev/null
+++ b/druntime/import/stdc/string.d
@@ -0,0 +1,76 @@
+/**
+ * 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);
diff --git a/druntime/import/stdc/tgmath.d b/druntime/import/stdc/tgmath.d
new file mode 100644
index 00000000..51214462
--- /dev/null
+++ b/druntime/import/stdc/tgmath.d
@@ -0,0 +1,652 @@
+/**
+ * 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;
+}
diff --git a/druntime/import/stdc/time.d b/druntime/import/stdc/time.d
new file mode 100644
index 00000000..7eb234a5
--- /dev/null
+++ b/druntime/import/stdc/time.d
@@ -0,0 +1,99 @@
+/**
+ * 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();
+}
diff --git a/druntime/import/stdc/wctype.d b/druntime/import/stdc/wctype.d
new file mode 100644
index 00000000..c24808e7
--- /dev/null
+++ b/druntime/import/stdc/wctype.d
@@ -0,0 +1,33 @@
+/**
+ * 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);
\ No newline at end of file
diff --git a/druntime/lib/.empty b/druntime/lib/.empty
new file mode 100644
index 00000000..e69de29b