Changeset 1719

Timestamp:

07/04/10 21:44:42 (14 years ago)

Author:

andrei

Message:

Now all writers are passed by value

Files:

• trunk/phobos/std/format.d (modified) (14 diffs)

trunk/phobos/std/format.d

@@ -1 +1 @@
-// Written in the D programming language.
-
-/**
- * This module implements the workhorse functionality for string and
- * I/O formatting.  It's comparable to C99's vsprintf().
- *
- * Macros:
- *  WIKI = Phobos/StdFormat
- *
-
-
-
+
+
- *
-
-
-
-
+
+
- */
-module std.format;
-
-
-
-
-
-
+
+
-import core.stdc.stdio, core.stdc.stdlib, core.stdc.string;
-
-
-
-
-
-
-
-
-
+
+
+
-version(unittest) {
-    import std.stdio, std.typecons;
-}
-
-version (Windows) version (DigitalMars)
-{
-    version = DigitalMarsC;
-}
-
-version (DigitalMarsC)
@@ -408 +396 @@
-    std.format.doFormat(&putc, _arguments, _argptr);
-}
-
-...
-
-int x = 27;
-// prints 'The answer is 27:6'
-myPrint("The answer is %s:", x, 6);
-------------------------
- */
-
-void doFormat(void delegate(dchar) putc, TypeInfo[] arguments, va_list argptr)
-   int j;
+
-    TypeInfo ti;
-    Mangle m;
-    uint flags;
-    int field_width;
-    int precision;
-
-    enum : uint
-    {
-    FLdash = 1,
-    FLplus = 2,
@@ -446 +433 @@
-                    valti.classinfo.name[9..14] == "Const")
-                valti = (cast(TypeInfo_Const)valti).next;
-            else
-                break;
-        }
-        return valti;
-    }
-
-    void formatArg(char fc)
-    {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            {
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                break;
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                else
-sl = n + 1
-fbuf = (cast(char*)alloca(sl * char.sizeof))[0 .. sl]
+vchar = cast(char)((uc ? 'A' - 10 : 'a' - 10) + vnumber)
+goto L2
-            }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    Lreal:
-    putreal(vreal);
-    return;
-
-    Lcomplex:
-    putreal(vcreal.re);
-    putc('+');
-    putreal(vcreal.im);
-    putc('i');
-    return;
-
-    Lerror:
-
-
-
-
-
+
+
+
+
-    {
-        ti = arguments[j++];
-        //printf("test1: '%.*s' %d\n", ti.classinfo.name,
-        //ti.classinfo.name.length); ti.print();
-        
-        flags = 0;
-        precision = 0;
-        field_width = 0;
-        
-        ti = skipCI(ti);
@@ -1531 +1520 @@
-    assert(std.string.format("%8s", "bar") == "     bar");
-    assert(std.string.format("%8s", "b\u00e9ll\u00f4") == "   b\u00e9ll\u00f4");
-}
-
-// Andrei
-//------------------------------------------------------------------------------
-
-/*
- * A compiled version of an individual writef format
- * specifier. FormatInfo only focuses on representation, without
-
+
+
-struct FormatInfo
-{
-
+
+
-     * precision means that they were specified with '*' in the format
-
-
+
+
+
-    /** Special value for precision */
-shor
+in
-    /** minimum width, default 0.  */
-shor
+in
-    /** precision. */
-short precision = UNSPECIFIED; 
+int precision = UNSPECIFIED;
-    /** The actual format specifier, 's' by default. */
-    char spec = 's';
-    /** Index of the argument for positional parameters, from 1 to
-     * ubyte.max. (0 means not used) */
-    ubyte index;
-    /* Flags: flDash for '-', flZero for '0', flSpace for ' ', flPlus
-     *  for '+', flHash for '#'. */
-    mixin(bitfields!(
-                bool, "flDash", 1,
-                bool, "flZero", 1,
-                bool, "flSpace", 1,
-                bool, "flPlus", 1,
-                bool, "flHash", 1,
-                ubyte, "", 3));
-    /* For arrays only: the trailing  */    
-    const(char)[] innerTrailing, trailing;
-
-/
-
-
-
-* after the end of the format specifier. */
-static FormatInfo parse(S)(ref S fmt)
-{
-    FormatInfo result;
- result
-result.trailing = to!(const(char)[]
-size_t i = 0;
-for (;;)
+    /*
+    
+    
+    
+    * after the end of the format specifier.
+ */
+this(S)(ref S fmt)
+{
+
+trailing = to!(typeof(trailing)
+for (size_t i = 0; i < fmt.length; )
+{
-            switch (fmt[i])
-            {
-
-
-
-
-
+
-                {
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-                    if (isdigit(fmt[++i]))
-                    {
-
-
-
+
+
+
+
-                        i = 0;
-
-
-
-
-
+
-                    }
-                    else
-                    {
-                        // read result
-result.precision
+width
-                    }
-
-
-
-
-
+
+
-                    auto tmp = fmt[i .. $];
-
+
+
+
-                    i = tmp.ptr - fmt.ptr;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-}
-
-//------------------------------------------------------------------------------
-// Writes characters in the format strings up to the first format
-// specifier and updates the format specifier to remove the written
-// portion The updated format fmt does not include the '%'
-ref 
+
-{
-    for (size_t i = 0; i < fmt.length; ++i)
-    {
-        if (fmt[i] != '%') continue;
-        if (fmt[++i] != '%')
-        {
-            // spec found, print and bailout
-            w.put(fmt[0 .. i - 1]);
-            fmt = fmt[i .. $];
-            return;
@@ -1731 +1724 @@
-        fmt = fmt[i + 1 .. $];
-        i = 0;
-    }
-    // no format spec found
-    w.put(fmt);
-    fmt = null;
-}
-
-unittest
-{
-
+
+
-    string fmt = "abc%sdef%sghi";
-    writeUpToFormatSpec(w, fmt);
-
+
+
-    writeUpToFormatSpec(w, fmt);
-    assert(w.data == "abcsdef" && fmt == "sghi");
-    // test with embedded %%s
-    fmt = "ab%%cd%%ef%sg%%h%sij";
-    w.clear;
-    writeUpToFormatSpec(w, fmt);
-    assert(w.data == "ab%cd%ef" && fmt == "sg%%h%sij");
-    writeUpToFormatSpec(w, fmt);
-    assert(w.data == "ab%cd%efsg%h" && fmt == "sij");
-}
-
-/*
- * Formats an integral number 'arg' according to 'f' and writes it to
- * 'w'.
- 
-ref 
+
+
-if (isIntegral!(D))
-{
-    Unqual!(D) arg = argx;
-    if (f.spec == 'r')
-    {
-        // raw write, skip all else and write the thing
-        auto begin = cast(const char*) &arg;
-        if (std.system.endian == Endian.LittleEndian && f.flPlus
-            || std.system.endian == Endian.BigEndian && f.flDash)
-        {
@@ -1844 +1839 @@
-        forcedPrefix = '0';
-    }
-    // write left pad; write sign; write 0x or 0X; write digits;
-    //   write right pad
-    // Writing left pad
-    int spacesToPrint = 
-        f.width // start with the minimum width
-        - digits.length  // take away digits to print
-        - (forcedPrefix != 0) // take away the sign if any
-        - (base == 16 && f.flHash() && arg ? 2 : 0); // 0x or 0X
-
+const 
-    if (delta > 0) spacesToPrint -= delta;
-    //writeln(spacesToPrint);
-    if (spacesToPrint > 0) // need to do some padding
-    {
-        if (leftPad == '0')
-        {
-            // pad with zeros
-            f.precision =
-                cast(typeof(f.precision)) (spacesToPrint + digits.length);
-                //to!(typeof(f.precision))(spacesToPrint + digits.length);
@@ -2090 +2085 @@
-        auto s = obj.toString;
-        w.put(s);                                        
-    } else {
-        // last resort: just print type name
-        w.put(D.stringof);
-    }
-}
-
-unittest
-{
-
+
+
-    int[] a = [ 1, 3, 2 ];
-    formattedWrite(w, "testing %(s, 
-    
+        formattedWrite(w, "testing %(s, %
+ 
-    w.clear;
-%) %(
+) (%
-    assert(w.data == "testing (1) (3) (2) embedded", w.data);
-
-    int[0] empt = [];
-    w.clear;
-    formattedWrite(w, "(%s)", empt);
-    assert(w.data == "()", w.data);
-}
-
-//------------------------------------------------------------------------------
-// Fix for issue 1591
@@ -2171 +2167 @@
-The positional and non-positional styles can be mixed in the same
-format string. (POSIX leaves this behavior undefined.) The internal
-counter for non-positional parameters tracks the next parameter after
-the largest positional parameter already used.
-
-Warning:
-This is the function internally used by writef* but it's still
-undergoing active development. Do not rely on it.
- */
-
-ref 
+
-{
-    enum len = args.length;
-    void function(ref Writer, const(void)*, FormatInfo) funs[len] = void;
-    const(void)* argsAddresses[len] = void;
-    foreach (i, arg; args)
-    {
-        funs[i] = &formatGeneric!(Writer, typeof(arg));
-        argsAddresses[i] = &arg;
-    }
-    // Are we already done with formats? Then just dump each parameter in turn
-    uint currentArg = 0;
-    for (;;)
-    {
-        writeUpToFormatSpec(w, fmt);
-        if (fmt.length == 0) 
-        {
-            // New behavior: break if there are too few specifiers AND
-            // at least one specifier did exist
-            break;
-        }
-.parse
+
-        if (currentArg == funs.length && !spec.index)
-        {
-            // leftover spec?
-
-
-
-
-
+
+
-            break;
-        }
-        if (spec.width == FormatInfo.DYNAMIC)
-        {
-            auto width = to!(typeof(spec.width))(getNthInt(currentArg, args));
-            if (width < 0)
-            {
-                spec.flDash = true;
-cast(short)(0 - width)
+-width
-            }
-            spec.width = width;
-            ++currentArg;
-        }
-        else if (spec.width < 0)
-        {
-            // means: get width as a positional parameter
-            auto index = cast(uint) -spec.width;
-            auto width = to!(typeof(spec.width))(getNthInt(index, args));
-            if (currentArg < index) currentArg = index;
-            if (width < 0)
-            {
-                spec.flDash = true;
-cast(short)(0 - width)
+-width
-            }
-            spec.width = width;
-        }
-        if (spec.precision == FormatInfo.DYNAMIC)
-        {
-            auto precision = to!(typeof(spec.precision))(
-                getNthInt(currentArg, args));
-            if (precision >= 0) spec.precision = precision;
-            // else negative precision is same as no precision
-            else spec.precision = FormatInfo.UNSPECIFIED;
@@ -2266 +2259 @@
-            funs[currentArg](w, argsAddresses[currentArg], spec);
-            ++currentArg;
-        }
-    }
-}
-
-/* ======================== Unit Tests ====================================== */
-
-unittest
-{
-Appender!(string) stream
+auto stream = appender((string*).init)
-    formattedWrite(stream, "%s", 1.1);
-    assert(stream.data == "1.1", stream.data);
-}
-
-unittest
-{
-Appender!(string) stream
+auto stream = appender((string*).init)
-    formattedWrite(stream, "%u", 42);
-    assert(stream.data == "42", stream.data);
-}
-
-unittest
-{
-    // testing raw writes
-
+
+
-    uint a = 0x02030405;
-    formattedWrite(w, "%+r", a);
-    assert(w.data.length == 4 && w.data[0] == 2 && w.data[1] == 3
-        && w.data[2] == 4 && w.data[3] == 5);
-    w.clear;
-    formattedWrite(w, "%-r", a);
-    assert(w.data.length == 4 && w.data[0] == 5 && w.data[1] == 4
-        && w.data[2] == 3 && w.data[3] == 2);
-}
-
-unittest
-{
-    // testing positional parameters
-Appender!(string) w
+auto w = appender!string()
-    formattedWrite(w,
-            "Numbers %2$s and %1$s are reversed and %1$s%2$s repeated",
-            42, 0);
-    assert(w.data == "Numbers 0 and 42 are reversed and 420 repeated",
-            w.data);
-    w.clear;
-    formattedWrite(w, "asd%s", 23);
-    assert(w.data == "asd23", w.data);
-    w.clear;
-    formattedWrite(w, "%s%s", 23, 45);
-    assert(w.data == "2345", w.data);
-}
-
-unittest
-{
-    debug(format) printf("std.format.format.unittest\n");
-
-Appender!(string) stream
+
+auto stream = appender!string()
-    //goto here;
-    
-    formattedWrite(stream,
-            "hello world! %s %s ", true, 57, 1_000_000_000, 'x', " foo");
-    assert(stream.data == "hello world! true 57 ",
-        stream.data);
-    
-    stream.clear;
-    formattedWrite(stream, "%g %A %s", 1.67, -1.28, float.nan);
-  //std.c.stdio.fwrite(stream.data.ptr, stream.data.length, 1, stderr);
@@ -2744 +2738 @@
-                                      writeln("Expected: >", exp, "<");
-                                      writeln("Actual:   >", stream.data,
-                                              "<");
-                                      assert(false);
-                                  }
-                              }+/
-}
-
-unittest
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Appender!(string) stream
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+ 
+ 
+ 
+ 
+ // 
+ // 
+//  
+//  
+//  
+//  
+//  
+//  
+//  
+//  
+//  
+//  
+//  
+ // 
+
+ auto stream = appender!string()
+ 
+     
+     
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+
+ 
+ 
+ 
-//    r = std.string.format("%s", aa);
-//   assert(r == "[3:[h,e,l,l,o],4:[b,e,t,t,y]]");
-}
-
-//------------------------------------------------------------------------------
-void formattedRead(R, S...)(ref R r, const(char)[] fmt, S args)
-{
-    static if (!S.length)
-    {
-r = 
+
-        enforce(fmt.length == 0);
-    }
-    else
-    {
-        FormatInfo spec;
-        // The loop below accounts for '*' == fields meant to be read
-        // and skipped
-        for (;;)
-        {
-r = 
-.parse
+
+
-            if (spec.width != spec.DYNAMIC) break;
-            // must skip this field
-            skipData(r, spec);
-        }
-        alias typeof(*args[0]) A;
-        //@@@BUG 2725
-        //static if (is(A X == Tuple!(T), T))
-        static if (is(A.Types[0]))
-        {
-            //@@@BUG
@@ -2835 +2829 @@
-            //             args[1 .. $]);
-            // else
-            //     return formattedRead(r, fmt, args[1 .. $]);
-            // assume it's a tuple
-            foreach (i, T; A.Types)
-            {
-                //writeln("Parsing ", r, " with format ", fmt);
-                args[0].field[i] = unformat!(T)(r, spec);
-                for (;;)
-                {
-r = 
-.parse
+
+
-                    if (spec.width != spec.DYNAMIC) break;
-                    // must skip this guy
-                    skipData(r, spec);
-                }
-            }
-            return formattedRead(r, fmt, args[1 .. $]);
-        }
-        else
-        {
-            *args[0] = unformat!(A)(r, spec);
@@ -2870 +2864 @@
-        break;
-    default:
-        assert(false, text("Not understood: ", spec.spec));
-    }
-}
-
-//------------------------------------------------------------------------------
-T unformat(T, Range)(ref Range input, FormatInfo spec)
-    if (isArray!T && !isSomeString!T)
-{
-Appender!(T) app
+auto app = appender!T()
-    for (;;)
-    {
-        auto e = parse!(ElementType!(T))(input);
-        app.put(e);
-        if (!std.string.startsWith(input, spec.innerTrailing)) break; // done
-        input = input[spec.innerTrailing.length .. $];
-        if (input.empty) break; // the trailing is terminator, not
-                                // separator
-    }
-    return app.data;
-}
-
-//------------------------------------------------------------------------------
-
-
-
+
+
+
+
-    if (spec.trailing.empty)
-    {
-        for (; !input.empty; input.popFront())
-        {
-            app.put(input.front);
-        }
-    }
-    else
-    {
-!input.startsWith(spec.trailing.front)
+input.front != spec.trailing.front
-             input.popFront())
-        {
-            app.put(input.front);
-        }
-    }
-//input = input[spec.innerTrailing.length .. $]
-app.data
+auto result = app.data
+result
-}
-
-unittest
-{
-    string s1, s2;
-    char[] line = "hello, world".dup;
-    formattedRead(line, "%s", &s1);
-    assert(s1 == "hello, world", s1);
-
-    line = "hello, world;yah".dup;
@@ -2927 +2922 @@
-}
-
-private template acceptedSpecs(T)
-{
-    static if (isIntegral!T) enum acceptedSpecs = "sdu";// + "coxX" (todo)
-    else static if (isFloatingPoint!T) enum acceptedSpecs = "seEfgG";
-    else enum acceptedSpecs = "";
-}
-
-//------------------------------------------------------------------------------
-
+
+
-{
-    enforce(std.algorithm.find("cdosuxX", spec.spec).length,
-            text("Wrong integral type specifier: `", spec.spec, "'"));
-    if (std.algorithm.find("dsu", spec.spec).length)
-    {
-        return parse!T(input);
-    }
-    assert(0, "Parsing spec '"~spec.spec~"' not implemented.");
-}
-
-//------------------------------------------------------------------------------
-
+
+
-{
-    if (spec.spec == 'r')
-    {
-        // raw read
-
+//
-        enforce(isSomeString!Range || ElementType!(Range).sizeof == 1);
-        union X
-        {
-            ubyte[T.sizeof] raw;
-            T typed;
-        }
-        X x;
-        foreach (i; 0 .. T.sizeof)
-        {
-            static if (isSomeString!Range)
-            {
-                x.raw[i] = input[0];
-                input = input[1 .. $];
-            }
-            else
-            {
-
+
+
-                input.popFront();
-            }
-        }
-        return x.typed;
-    }
-    enforce(std.algorithm.find(acceptedSpecs!T, spec.spec).length,
-            text("Format specifier `", spec.spec,
-                    "' not accepted for floating point types"));
-    return parse!T(input);
-}
-
-//------------------------------------------------------------------------------
-T unformat(T, Range)(ref Range input, FormatInfo spec) if (is(T == typedef))
-{
-    static if (is(T Original == typedef))
-    {
-        return cast(T) unformat!Original(input, spec);
-    }
-    else
-    {
-        static assert(false);
-    }
-}
-
-unittest
-{
-    typedef int Int;
-    string s = "123";
-    Int x;
-    formattedRead(s, "%s", &x);
-    assert(x == 123);
-}
-
-unittest
-{
-    union A
-    {
-        char[float.sizeof] untyped;
-        float typed;
-    };
-    A a;
-    a.typed = 5.5;
-    char[] input = a.untyped[];
-    float witness;
-    formattedRead(input, "%r", &witness);
-    assert(witness == a.typed);
-}
-
-//------------------------------------------------------------------------------
-R parseToFormatSpec(R)(
+void parseToFormatSpec(R)(ref 
-{
-    while (fmt.length)
-    {
-        if (fmt[0] == '%')
-        {
-            if (fmt.length > 1 && fmt[1] == '%')
-            {
-                assert(!r.empty);
-                // Require a '%'
-                if (r.front != '%') break;
@@ -3035 +3011 @@
-            else
-            {
-                fmt.popFront;
-                break;
-            }
-        }
-        else
-        {
-            if (fmt.front == ' ')
-            {
-
+
+
-            }
-            else
-            {
-
-
-
-
+
+
+
-                //static assert(0);
-                if (r.front != fmt.front) break;
-                r.popFront;
-            }
-            fmt.popFront;
-        }
-    }
-    return r;
-}
-
-unittest
-{
-    char[] line = "1 2".dup;
-    string format = "%s %s";
-    int a, b;
-    formattedRead(line, format, &a, &b);
-    assert(a == 1 && b == 2);
-
+    line = "1 2 3".dup;
+    format = "%d ";
+    formattedRead(line, format, &a);
+    assert(a == 1);
+
-    Tuple!(int, float) t;
-    line = "1 2.125".dup;
-    formattedRead(line, format, &t);
-    assert(t.field[0] == 1 && t.field[1] == 2.125);
-
-    line = "1 7643 2.125".dup;
-    formattedRead(line, "%s %*u %s", &t);
-    assert(t.field[0] == 1 && t.field[1] == 2.125);
-}