Merge branch 'master' of github.com:D-Programming-Language/phobos

Author: complexmath

changelog.dd

@@ -3,6 +3,7 @@ $(VERSION 053, ddd mm, 2011, =================================================,
     $(WHATSNEW
         $(LI Added bindings for libcurl: etc.c.curl)
         $(LI Added std.net.isemail)
+		$(LI Added std.parallelism)
     )
     $(LIBBUGSFIXED
         $(LI $(BUGZILLA 4644): assertExceptionThrown to assert that a particular exception was thrown)
@@ -13,7 +14,9 @@ $(VERSION 053, ddd mm, 2011, =================================================,
         $(LI $(BUGZILLA 5616): std.datetime: not cross-platform)
         $(LI $(BUGZILLA 5654): BigInt returns ZERO with strings of single digit number with leading zeros)
         $(LI $(BUGZILLA 5731): std.datetime.SysTime prints UTC offsets backwards)
+        $(LI $(BUGZILLA 5761): std.datetime: Date.this(int day) conversion fails for Dec 30 of leap years)
         $(LI $(BUGZILLA 5780): [patch] std.traits.hasIndirections incorrectly handles static arrays)
-    )
+        $(LI $(BUGZILLA 5781): std.datetime: On Windows, times off by one hour in some years due to DST rule changes)
+     )
 
 )

index.d

@@ -160,9 +160,6 @@ D language compiler. Also, check out the
 	<dt><a href="std_gc.html"><b>std.gc</b></a>
 	<dd>Control the garbage collector.
 
-	<dt><a href="std_intrinsic.html"><b>std.intrinsic</b></a>
-	<dd>Compiler built in intrinsic functions
-
 	<dt><a href="std_math.html"><b>std.math</b></a>
 	<dd>Include all the usual math functions like sin, cos, atan, etc.
 

posix.mak

@@ -152,15 +152,15 @@ endif
 MAIN = $(ROOT)/emptymain.d
 
 # Stuff in std/
-STD_MODULES = $(addprefix std/, algorithm array base64 bigint bitmanip	\
-        compiler complex concurrency container contracts conv cpuid		\
-        cstream ctype date datetime datebase dateparse demangle			\
-        encoding exception file format functional getopt gregorian		\
-        intrinsic json loader math mathspecial md5 metastrings mmfile	\
-        numeric outbuffer path perf process random range regex regexp	\
-        signals socket socketstream stdint stdio stdiobase stream		\
-        string syserror system traits typecons typetuple uni uri utf	\
-        variant xml zip zlib)
+STD_MODULES = $(addprefix std/, algorithm array base64 bigint			\
+        bitmanip compiler complex concurrency container contracts		\
+        conv cpuid cstream ctype date datetime datebase dateparse		\
+        demangle encoding exception file format functional getopt		\
+        gregorian json loader math mathspecial md5 metastrings mmfile	\
+        numeric outbuffer parallelism path perf process random range	\
+        regex regexp signals socket socketstream stdint stdio			\
+        stdiobase stream string syserror system traits typecons			\
+        typetuple uni uri utf variant xml zip zlib)
 
 STD_NET_MODULES = $(addprefix std/net/, isemail)
 

std/algorithm.d

@@ -658,7 +658,9 @@ template reduce(fun...) if (fun.length >= 1)
                 alias args[0] r;
                 static if (fun.length == 1)
                 {
-                    return reduce(r.front, (r.popFront(), r));
+                    auto seed = r.front;
+                    r.popFront();
+                    return reduce(seed, r);
                 }
                 else
                 {

std/array.d

@@ -12,9 +12,9 @@ Source: $(PHOBOSSRC std/_array.d)
 */
 module std.array;
 
-import core.memory;
+import core.memory, core.bitop;
 import std.algorithm, std.conv, std.ctype, std.encoding, std.exception,
-    std.intrinsic, std.range, std.string, std.traits, std.typecons, std.utf;
+    std.range, std.string, std.traits, std.typecons, std.utf;
 import std.c.string : memcpy;
 version(unittest) import core.exception, std.stdio, std.typetuple;
 

std/bitmanip.d

@@ -23,7 +23,7 @@ module std.bitmanip;
 
 //debug = bitarray;                // uncomment to turn on debugging printf's
 
-private import std.intrinsic;
+import core.bitop;
 
 string myToStringx(ulong n)
 {   enum s = "0123456789";

std/c/windows/winsock.d

@@ -316,7 +316,7 @@ version(BigEndian)
 }
 else version(LittleEndian)
 {
-        private import std.intrinsic;
+        private import core.bitop;
 
 
         uint16_t htons(uint16_t x)

std/complex.d

@@ -19,14 +19,7 @@ import std.traits;
 
 
 
-/** A complex number parametrised by a type T.
-
-    Bugs:
-    Some operators, such as opAssign and opOpAssign, should return by ref,
-    but currently don't.  This will be implemented as soon as
-    $(LINK2 http://d.puremagic.com/issues/show_bug.cgi?id=2460, DMD bug 2460)
-    is fixed.
-*/
+/** A complex number parametrised by a type T. */
 struct Complex(T)  if (isFloatingPoint!T)
 {
     /** The real part of the number. */
@@ -38,7 +31,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 @safe pure nothrow  // The following functions depend only on std.math.
 {
-    
+
     /** Calculate the absolute value (or modulus) of the number. */
     @property T abs() const
     {
@@ -68,7 +61,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // this = complex
-    Complex opAssign(R : T)(Complex!R z)
+    ref Complex opAssign(R : T)(Complex!R z)
     {
         re = z.re;
         im = z.im;
@@ -77,7 +70,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // this = numeric
-    Complex opAssign(R : T)(R r)
+    ref Complex opAssign(R : T)(R r)
     {
         re = r;
         im = 0;
@@ -196,7 +189,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex += complex,  complex -= complex
-    Complex opOpAssign(string op, C)(C z)
+    ref Complex opOpAssign(string op, C)(C z)
         if ((op == "+" || op == "-") && is(C R == Complex!R))
     {
         mixin ("re "~op~"= z.re;");
@@ -206,7 +199,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex *= complex
-    Complex opOpAssign(string op, C)(C z)
+    ref Complex opOpAssign(string op, C)(C z)
         if (op == "*" && is(C R == Complex!R))
     {
         auto temp = re*z.re - im*z.im;
@@ -217,7 +210,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex /= complex
-    Complex opOpAssign(string op, C)(C z)
+    ref Complex opOpAssign(string op, C)(C z)
         if (op == "/" && is(C R == Complex!R))
     {
         if (fabs(z.re) < fabs(z.im))
@@ -243,7 +236,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex ^^= complex
-    Complex opOpAssign(string op, C)(C z)
+    ref Complex opOpAssign(string op, C)(C z)
         if (op == "^^" && is(C R == Complex!R))
     {
         FPTemporary!T r = abs;
@@ -258,7 +251,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex += numeric,  complex -= numeric
-    Complex opOpAssign(string op, U : T)(U a)
+    ref Complex opOpAssign(string op, U : T)(U a)
         if (op == "+" || op == "-")
     {
         mixin ("re "~op~"= a;");
@@ -267,7 +260,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex *= numeric,  complex /= numeric
-    Complex opOpAssign(string op, U : T)(U a)
+    ref Complex opOpAssign(string op, U : T)(U a)
         if (op == "*" || op == "/")
     {
         mixin ("re "~op~"= a;");
@@ -277,7 +270,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex ^^= real
-    Complex opOpAssign(string op, R)(R r)
+    ref Complex opOpAssign(string op, R)(R r)
         if (op == "^^" && isFloatingPoint!R)
     {
         FPTemporary!T ab = abs^^r;
@@ -289,7 +282,7 @@ struct Complex(T)  if (isFloatingPoint!T)
 
 
     // complex ^^= int
-    Complex opOpAssign(string op, U)(U i)
+    ref Complex opOpAssign(string op, U)(U i)
         if (op == "^^" && isIntegral!U)
     {
         switch (i)

std/container.d

@@ -1503,7 +1503,7 @@ struct Array(T) if (!is(T : const(bool)))
                 {
                     foreach (ref e; _payload.ptr[newLength .. _payload.length])
                     {
-                        clear(e);
+                        .clear(e);
                     }
                 }
                 _payload = _payload.ptr[0 .. newLength];
@@ -1545,9 +1545,9 @@ struct Array(T) if (!is(T : const(bool)))
                         0,
                         (elements - oldLength) * T.sizeof);
                 GC.addRange(newPayload.ptr, sz);
-                GC.removeRange(_data._payload.ptr);
-                free(_data._payload.ptr);
-                _data._payload = newPayload;
+                GC.removeRange(_payload.ptr);
+                free(_payload.ptr);
+                _payload = newPayload;
             }
             else
             {
@@ -2320,6 +2320,63 @@ unittest
     assert(a.length == 7);
     assert(equal(a[1..4], [1, 2, 3]));
 }
+// Test issue 5920
+version(unittest)
+{
+    //@@@BUG4274@@@: This cannot be declared as an inner struct.
+    private struct structBug5920
+    {
+        int order;
+        uint* pDestructionMask;
+        ~this()
+        {
+            if (pDestructionMask) 
+                *pDestructionMask += 1 << order; 
+        }
+    }
+}
+unittest
+{
+    alias structBug5920 S;
+    uint dMask;
+
+    auto arr = Array!S(cast(S[])[]);
+    foreach (i; 0..8)
+        arr.insertBack(S(i, &dMask));
+    // don't check dMask now as S may be copied multiple times (it's ok?)
+    {
+        assert(arr.length == 8);
+        dMask = 0;
+        arr.length = 6;
+        assert(arr.length == 6);    // make sure shrinking calls the d'tor
+        assert(dMask == 0b1100_0000);
+        arr.removeBack();
+        assert(arr.length == 5);    // make sure removeBack() calls the d'tor
+        assert(dMask == 0b1110_0000);
+        arr.removeBack(3);
+        assert(arr.length == 2);    // ditto
+        assert(dMask == 0b1111_1100);
+        arr.clear();
+        assert(arr.length == 0);    // make sure clear() calls the d'tor
+        assert(dMask == 0b1111_1111);
+    }
+    assert(dMask == 0b1111_1111);   // make sure the d'tor is called once only.
+}
+// Test issue 5792 (mainly just to check if this piece of code is compilable)
+unittest
+{
+    auto a = Array!(int[])([[1,2],[3,4]]);
+    a.reserve(4);
+    assert(a.capacity >= 4);
+    assert(a.length == 2);
+    assert(a[0] == [1,2]);
+    assert(a[1] == [3,4]);
+    a.reserve(16);
+    assert(a.capacity >= 16);
+    assert(a.length == 2);
+    assert(a[0] == [1,2]);
+    assert(a[1] == [3,4]);
+}
 
 // BinaryHeap
 /**