Merge pull request #39 from open-watt/druntime_scrub

More druntime scrubbing

Author: samsinsane

src/urt/internal/lifetime.d

@@ -0,0 +1,121 @@
+module urt.internal.lifetime;
+
+import urt.lifetime : forward;
+
+/+
+emplaceRef is a package function for druntime internal use. It works like
+emplace, but takes its argument by ref (as opposed to "by pointer").
+This makes it easier to use, easier to be safe, and faster in a non-inline
+build.
+Furthermore, emplaceRef optionally takes a type parameter, which specifies
+the type we want to build. This helps to build qualified objects on mutable
+buffer, without breaking the type system with unsafe casts.
++/
+void emplaceRef(T, UT, Args...)(ref UT chunk, auto ref Args args)
+{
+    static if (args.length == 0)
+    {
+        static assert(is(typeof({static T i;})),
+            "Cannot emplace a " ~ T.stringof ~ " because " ~ T.stringof ~
+            ".this() is annotated with @disable.");
+        static if (is(T == class)) static assert(!__traits(isAbstractClass, T),
+            T.stringof ~ " is abstract and it can't be emplaced");
+        emplaceInitializer(chunk);
+    }
+    else static if (
+        !is(T == struct) && Args.length == 1 /* primitives, enums, arrays */
+        ||
+        Args.length == 1 && is(typeof({T t = forward!(args[0]);})) /* conversions */
+        ||
+        is(typeof(T(forward!args))) /* general constructors */)
+    {
+        static struct S
+        {
+            T payload;
+            this()(auto ref Args args)
+            {
+                static if (__traits(compiles, payload = forward!args))
+                    payload = forward!args;
+                else
+                    payload = T(forward!args);
+            }
+        }
+        if (__ctfe)
+        {
+            static if (__traits(compiles, chunk = T(forward!args)))
+                chunk = T(forward!args);
+            else static if (args.length == 1 && __traits(compiles, chunk = forward!(args[0])))
+                chunk = forward!(args[0]);
+            else assert(0, "CTFE emplace doesn't support "
+                ~ T.stringof ~ " from " ~ Args.stringof);
+        }
+        else
+        {
+            S* p = () @trusted { return cast(S*) &chunk; }();
+            static if (UT.sizeof > 0)
+                emplaceInitializer(*p);
+            p.__ctor(forward!args);
+        }
+    }
+    else static if (is(typeof(chunk.__ctor(forward!args))))
+    {
+        // This catches the rare case of local types that keep a frame pointer
+        emplaceInitializer(chunk);
+        chunk.__ctor(forward!args);
+    }
+    else
+    {
+        //We can't emplace. Try to diagnose a disabled postblit.
+        static assert(!(Args.length == 1 && is(Args[0] : T)),
+            "Cannot emplace a " ~ T.stringof ~ " because " ~ T.stringof ~
+            ".this(this) is annotated with @disable.");
+
+        //We can't emplace.
+        static assert(false,
+            T.stringof ~ " cannot be emplaced from " ~ Args[].stringof ~ ".");
+    }
+}
+
+// ditto
+static import urt.traits;
+void emplaceRef(UT, Args...)(ref UT chunk, auto ref Args args)
+    if (is(UT == urt.traits.Unqual!UT))
+{
+    emplaceRef!(UT, UT)(chunk, forward!args);
+}
+
+/+
+Emplaces T.init.
+In contrast to `emplaceRef(chunk)`, there are no checks for disabled default
+constructors etc.
++/
+void emplaceInitializer(T)(scope ref T chunk) nothrow pure @trusted
+    if (!is(T == const) && !is(T == immutable) && !is(T == inout))
+{
+    import core.internal.traits : hasElaborateAssign;
+
+    static if (__traits(isZeroInit, T))
+    {
+        import urt.mem : memset;
+        memset(cast(void*) &chunk, 0, T.sizeof);
+    }
+    else static if (__traits(isScalar, T) ||
+                    T.sizeof <= 16 && !hasElaborateAssign!T && __traits(compiles, (){ T chunk; chunk = T.init; }))
+    {
+        chunk = T.init;
+    }
+    else static if (__traits(isStaticArray, T))
+    {
+        // For static arrays there is no initializer symbol created. Instead, we emplace elements one-by-one.
+        foreach (i; 0 .. T.length)
+        {
+            emplaceInitializer(chunk[i]);
+        }
+    }
+    else
+    {
+        import urt.mem : memcpy;
+        const initializer = __traits(initSymbol, T);
+        memcpy(cast(void*)&chunk, initializer.ptr, initializer.length);
+    }
+}

src/urt/lifetime.d

@@ -1,5 +1,6 @@
 module urt.lifetime;
 
+import urt.internal.lifetime : emplaceRef; // TODO: DESTROY THIS!
 
 T* emplace(T)(T* chunk) @safe pure
 {
@@ -78,12 +79,6 @@ T* emplace(T, Args...)(void[] chunk, auto ref Args args)
     return cast(T*) chunk.ptr;
 }
 
-
-// HACK: we should port this to our lib...
-static import core.internal.lifetime;
-alias emplaceRef = core.internal.lifetime.emplaceRef;
-
-
 /+
 void copyEmplace(S, T)(ref S source, ref T target) @system
     if (is(immutable S == immutable T))
@@ -269,7 +264,7 @@ private void moveEmplaceImpl(T)(scope ref T target, return scope ref T source) @
 
         static if (hasElaborateAssign!T || !isAssignable!T)
         {
-            import core.stdc.string : memcpy;
+            import urt.mem : memcpy;
             () @trusted { memcpy(&target, &source, T.sizeof); }();
         }
         else
@@ -327,20 +322,11 @@ void moveEmplace(T)(ref T source, ref T target) @system @nogc
 
 
 
-//debug = PRINTF;
-
-debug(PRINTF)
-{
-    import core.stdc.stdio;
-}
-
 /// Implementation of `_d_delstruct` and `_d_delstructTrace`
 template _d_delstructImpl(T)
 {
     private void _d_delstructImpure(ref T p)
     {
-        debug(PRINTF) printf("_d_delstruct(%p)\n", p);
-
         destroy(*p);
         p = null;
     }
@@ -478,27 +464,11 @@ T _d_newclassT(T)() @trusted
             attr |= BlkAttr.NO_SCAN;
 
         p = GC.malloc(init.length, attr, typeid(T));
-        debug(PRINTF) printf(" p = %p\n", p);
-    }
-
-    debug(PRINTF)
-    {
-        printf("p = %p\n", p);
-        printf("init.ptr = %p, len = %llu\n", init.ptr, cast(ulong)init.length);
-        printf("vptr = %p\n", *cast(void**) init);
-        printf("vtbl[0] = %p\n", (*cast(void***) init)[0]);
-        printf("vtbl[1] = %p\n", (*cast(void***) init)[1]);
-        printf("init[0] = %x\n", (cast(uint*) init)[0]);
-        printf("init[1] = %x\n", (cast(uint*) init)[1]);
-        printf("init[2] = %x\n", (cast(uint*) init)[2]);
-        printf("init[3] = %x\n", (cast(uint*) init)[3]);
-        printf("init[4] = %x\n", (cast(uint*) init)[4]);
     }
 
     // initialize it
     p[0 .. init.length] = init[];
 
-    debug(PRINTF) printf("initialization done\n");
     return cast(T) p;
 }
 

src/urt/math.d

@@ -1,7 +1,6 @@
 module urt.math;
 
 import urt.intrinsic;
-import core.stdc.stdio; // For writeDebugf
 
 // for arch where using FPU for int<->float conversions is preferred
 //version = PreferFPUIntConv;

src/urt/mem/package.d

@@ -11,19 +11,19 @@ extern(C)
 nothrow @nogc:
     void* alloca(size_t size);
 
-    void* memcpy(void* dest, const void* src, size_t n);
-    void* memmove(void* dest, const void* src, size_t n);
-    void* memset(void* s, int c, size_t n);
-    void* memzero(void* s, size_t n) => memset(s, 0, n);
+    void* memcpy(void* dest, const void* src, size_t n) pure;
+    void* memmove(void* dest, const void* src, size_t n) pure;
+    void* memset(void* s, int c, size_t n) pure;
+    void* memzero(void* s, size_t n) pure => memset(s, 0, n);
 
-    size_t strlen(const char* s);
-    int strcmp(const char* s1, const char* s2);
-    char* strcpy(char* dest, const char* src);
+    size_t strlen(const char* s) pure;
+    int strcmp(const char* s1, const char* s2) pure;
+    char* strcpy(char* dest, const char* src) pure;
     char* strcat(char* dest, const char* src);
 
-    size_t wcslen(const wchar_t* s);
-//    wchar_t* wcscpy(wchar_t* dest, const wchar_t* src);
+    size_t wcslen(const wchar_t* s) pure;
+//    wchar_t* wcscpy(wchar_t* dest, const wchar_t* src) pure;
 //    wchar_t* wcscat(wchar_t* dest, const wchar_t* src);
-//    wchar_t* wcsncpy(wchar_t* dest, const wchar_t* src, size_t n);
+//    wchar_t* wcsncpy(wchar_t* dest, const wchar_t* src, size_t n) pure;
 //    wchar_t* wcsncat(wchar_t* dest, const wchar_t* src, size_t n);
 }