Ticket #1042: patch.1

Index: Layout.d
===================================================================
--- Layout.d    (revision 3447)
+++ Layout.d    (working copy)
@@ -51,6 +51,71 @@
         alias void* ArgList;
         }
 
+version(GNU) {
+    /+
+     + Template to get arbitrary structures out of va_arg
+     + assumes that all argument of the same size are treated in the same way
+     + this is needed due to the bad implementation of va_arg in gdc see
+     + 
+     +/
+    private const int maxStore=64;
+    private struct StoreEl{byte[maxStore] st;};
+    
+    private va_list dummy;
+    static if (is(typeof(dummy.ptr))){
+    /+ ugly workaround for the missing way to pass inout va_list on X86-64 +/
+    void *dynGetArgT(int s1,int s2)(in TypeInfo ti, va_list argptr,out StoreEl el){
+        const int m = (s1+s2)/2;
+        static if (s1 < s2){
+            if (ti.tsize > m) {
+                return dynGetArgT!(m+1,s2)(ti,argptr,el);
+            } else {
+                return dynGetArgT!(s1,m)(ti,argptr,el);
+            }
+        }
+        else{
+            if (ti.tsize == m)
+            {
+                struct ms{byte[m] mse;};
+                ms *st=cast(ms*)&el;
+                *st=va_arg!(ms)(argptr);
+                return cast(void *)st;
+            } else {
+                throw new Exception("hit max size of dyn_va_argT increase maxStore");
+            }
+        }
+    }
+    void *dynGetArg(in TypeInfo ti, va_list argptr,out StoreEl el){
+        return dynGetArgT!(1,maxStore)(ti,argptr,el);
+    }
+    }else{
+    void *dynGetArgT(int s1,int s2)(in TypeInfo ti,inout va_list argptr,out StoreEl el){
+        const int m = (s1+s2)/2;
+        static if (s1 < s2){
+            if (ti.tsize > m) {
+                return dynGetArgT!(m+1,s2)(ti,argptr,el);
+            } else {
+                return dynGetArgT!(s1,m)(ti,argptr,el);
+            }
+        }
+        else{
+            if (ti.tsize == m)
+            {
+                struct ms{byte[m] mse;};
+                ms *st=cast(ms*)&el;
+                *st=va_arg!(ms)(argptr);
+                return cast(void *)st;
+            } else {
+                throw new Exception("hit max size of dyn_va_argT increase maxStore");
+            }
+        }
+    }
+    void *dynGetArg(in TypeInfo ti, inout va_list argptr,out StoreEl el){
+        return dynGetArgT!(1,maxStore)(ti,argptr,el);
+    }
+    }    
+}
+
 /*******************************************************************************
 
         Contains methods for replacing format items in a string with string
@@ -184,77 +249,45 @@
         version (GNU)
                 {
                 Arg[64] arglist = void;
-                int[64] intargs = void;
-                byte[64] byteargs = void;
-                long[64] longargs = void;
-                short[64] shortargs = void;
-                void[][64] voidargs = void;
                 real[64] realargs = void;
                 float[64] floatargs = void;
                 double[64] doubleargs = void;
-
+                StoreEl[64] bigargs = void;
+                
                 foreach (i, arg; arguments)
-                        {
-                        static if (is(typeof(args.ptr)))
-                            arglist[i] = args.ptr;
-                        else
-                            arglist[i] = args;
-                        /* Since floating point types don't live on
-                         * the stack, they must be accessed by the
-                         * correct type. */
-                        bool converted = false;
-                        switch (arg.classinfo.name[9])
-                               {
-                               case TypeCode.FLOAT:
-                                    floatargs[i] = va_arg!(float)(args);
-                                    arglist[i] = &floatargs[i];
-                                    converted = true;
-                                    break;
+                    {
+                            /* Since floating point types don't live on
+                             * the stack, they must be accessed by the
+                             * correct type. */
+                            bool converted = false;
+                            switch (arg.classinfo.name[9])
+                                   {
+                                   case TypeCode.FLOAT:
+                                        floatargs[i] = va_arg!(float)(args);
+                                        arglist[i] = &floatargs[i];
+                                        converted = true;
+                                        break;
 
-                               case TypeCode.DOUBLE:
-                                    doubleargs[i] = va_arg!(double)(args);
-                                    arglist[i] = &doubleargs[i];
-                                    converted = true;
-                                    break;
+                                   case TypeCode.DOUBLE:
+                                        doubleargs[i] = va_arg!(double)(args);
+                                        arglist[i] = &doubleargs[i];
+                                        converted = true;
+                                        break;
 
-                               case TypeCode.REAL:
-                                    realargs[i] = va_arg!(real)(args);
-                                    arglist[i] = &realargs[i];
-                                    converted = true;
-                                    break;
+                                   case TypeCode.REAL:
+                                        realargs[i] = va_arg!(real)(args);
+                                        arglist[i] = &realargs[i];
+                                        converted = true;
+                                        break;
 
-                               default:
-                                    break;
+                                   default:
+                                        break;
                                 }
-                        if (! converted)
-                           {
-                           switch (arg.tsize)
-                                  {
-                                  case 1:
-                                       byteargs[i] = va_arg!(byte)(args);
-                                       arglist[i] = &byteargs[i];
-                                       break;
-                                  case 2:
-                                       shortargs[i] = va_arg!(short)(args);
-                                       arglist[i] = &shortargs[i];
-                                       break;
-                                  case 4:
-                                       intargs[i] = va_arg!(int)(args);
-                                       arglist[i] = &intargs[i];
-                                       break;
-                                  case 8:
-                                       longargs[i] = va_arg!(long)(args);
-                                       arglist[i] = &longargs[i];
-                                       break;
-                                  case 16:
-                                       voidargs[i] = va_arg!(void[])(args);
-                                       arglist[i] = &voidargs[i];
-                                       break;
-                                  default:
-                                       assert (false, "Unknown size: " ~ Integer.toString (arg.tsize));
-                                  }
-                           }
-                        }
+                            if (! converted)
+                               {
+                                   arglist[i] = dynGetArg(arg,args,bigargs[i]);
+                               }
+                      }
                 }
              else
                 {
@@ -815,7 +848,8 @@
         assert( Formatter( "d{{0}d", "<string>" ) == "d{0}d");
         assert( Formatter( "d{{{0}d", "<string>" ) == "d{<string>d");
         assert( Formatter( "d{0}}d", "<string>" ) == "d<string>}d");
-
+        assert( Formatter( "{} {} {} {} {:x}",1.3f,cast(bool)1,1.4,cast(bool)1, 0xafe0000 ) == "1.30 true 1.40 true afe0000" );
+        assert( Formatter( "{} {} {} {} {:x}",0.0f,cast(bool)1,0.0,cast(bool)1, 0xafe0000 ) == "0.00 true 0.00 true afe0000" );
         assert( Formatter( "{0:x}", 0xafe0000 ) == "afe0000" );
         // todo: is it correct to print 7 instead of 6 chars???
         assert( Formatter( "{0:x7}", 0xafe0000 ) == "afe0000" );
@@ -891,6 +925,7 @@
         assert( Formatter( "{:x}", a ) == "[ 33, 34, 35, 36, 37 ]" );
         assert( Formatter( "{,-4}", a ) == "[ 51  , 52  , 53  , 54  , 55   ]" );
         assert( Formatter( "{,4}", a ) == "[   51,   52,   53,   54,   55 ]" );
+        assert( Formatter( "{} {}", a,cast(byte)21 ) == "[ 51, 52, 53, 54, 55 ] 21" );
         int[][] b = [ [ 51, 52 ], [ 53, 54, 55 ] ];
         assert( Formatter( "{}", b ) == "[ [ 51, 52 ], [ 53, 54, 55 ] ]" );