Add Go frontend, libgo library, and Go testsuite.

gcc/:
	* gcc.c (default_compilers): Add entry for ".go".
	* common.opt: Add -static-libgo as a driver option.
	* doc/install.texi (Configuration): Mention libgo as an option for
	--enable-shared.  Mention go as an option for --enable-languages.
	* doc/invoke.texi (Overall Options): Mention .go as a file name
	suffix.  Mention go as a -x option.
	* doc/frontends.texi (G++ and GCC): Mention Go as a supported
	language.
	* doc/sourcebuild.texi (Top Level): Mention libgo.
	* doc/standards.texi (Standards): Add section on Go language.
	Move references for other languages into their own section.
	* doc/contrib.texi (Contributors): Mention that I contributed the
	Go frontend.
gcc/testsuite/:
	* lib/go.exp: New file.
	* lib/go-dg.exp: New file.
	* lib/go-torture.exp: New file.
	* lib/target-supports.exp (check_compile): Match // Go.

From-SVN: r167407

7 files changed, 3779 insertions, 0 deletions

diff --git a/libgo/go/fmt/doc.go b/libgo/go/fmt/doc.go
new file mode 100644
index 0000000..06dc730
--- /dev/null
+++ b/libgo/go/fmt/doc.go
@@ -0,0 +1,163 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+	Package fmt implements formatted I/O with functions analogous
+	to C's printf and scanf.  The format 'verbs' are derived from C's but
+	are simpler.
+
+	Printing:
+
+	The verbs:
+
+	General:
+		%v	the value in a default format.
+			when printing structs, the plus flag (%+v) adds field names
+		%#v	a Go-syntax representation of the value
+		%T	a Go-syntax representation of the type of the value
+
+	Boolean:
+		%t	the word true or false
+	Integer:
+		%b	base 2
+		%c	the character represented by the corresponding Unicode code point
+		%d	base 10
+		%o	base 8
+		%x	base 16, with lower-case letters for a-f
+		%X	base 16, with upper-case letters for A-F
+	Floating-point and complex constituents:
+		%e	scientific notation, e.g. -1234.456e+78
+		%E	scientific notation, e.g. -1234.456E+78
+		%f	decimal point but no exponent, e.g. 123.456
+		%g	whichever of %e or %f produces more compact output
+		%G	whichever of %E or %f produces more compact output
+	String and slice of bytes:
+		%s	the uninterpreted bytes of the string or slice
+		%q	a double-quoted string safely escaped with Go syntax
+		%x	base 16 notation with two characters per byte
+	Pointer:
+		%p	base 16 notation, with leading 0x
+
+	There is no 'u' flag.  Integers are printed unsigned if they have unsigned type.
+	Similarly, there is no need to specify the size of the operand (int8, int64).
+
+	For numeric values, the width and precision flags control
+	formatting; width sets the width of the field, precision the
+	number of places after the decimal, if appropriate.  The
+	format %6.2f prints 123.45. The width of a field is the number
+	of Unicode code points in the string. This differs from C's printf where
+	the field width is the number of bytes.  Either or both of the
+	flags may be replaced with the character '*', causing their values
+	to be obtained from the next operand, which must be of type int.
+
+	Other flags:
+		+	always print a sign for numeric values
+		-	pad with spaces on the right rather than the left (left-justify the field)
+		#	alternate format: add leading 0 for octal (%#o), 0x for hex (%#x);
+			0X for hex (%#X); suppress 0x for %p (%#p);
+			print a raw (backquoted) string if possible for %q (%#q)
+		' '	(space) leave a space for elided sign in numbers (% d);
+			put spaces between bytes printing strings or slices in hex (% x)
+		0	pad with leading zeros rather than spaces
+
+	For each Printf-like function, there is also a Print function
+	that takes no format and is equivalent to saying %v for every
+	operand.  Another variant Println inserts blanks between
+	operands and appends a newline.
+
+	Regardless of the verb, if an operand is an interface value,
+	the internal concrete value is used, not the interface itself.
+	Thus:
+		var i interface{} = 23
+		fmt.Printf("%v\n", i)
+	will print 23.
+
+	If an operand implements interface Formatter, that interface
+	can be used for fine control of formatting.
+
+	If an operand implements method String() string that method
+	will be used to convert the object to a string, which will then
+	be formatted as required by the verb (if any). To avoid
+	recursion in cases such as
+		type X int
+		func (x X) String() string { return Sprintf("%d", x) }
+	cast the value before recurring:
+		func (x X) String() string { return Sprintf("%d", int(x)) }
+
+	Format errors:
+
+	If an invalid argument is given for a verb, such as providing
+	a string to %d, the generated string will contain a
+	description of the problem, as in these examples:
+
+		Wrong type or unknown verb: %!verb(type=value)
+			Printf("%d", hi):          %!d(string=hi)
+		Too many arguments: %!(EXTRA type=value)
+			Printf("hi", "guys"):      hi%!(EXTRA string=guys)
+		Too few arguments: %!verb(MISSING)
+			Printf("hi%d"):            hi %!d(MISSING)
+		Non-int for width or precision: %!(BADWIDTH) or %!(BADPREC)
+			Printf("%*s", 4.5, "hi"):  %!(BADWIDTH)hi
+			Printf("%.*s", 4.5, "hi"): %!(BADPREC)hi
+
+	All errors begin with the string "%!" followed sometimes
+	by a single character (the verb) and end with a parenthesized
+	description.
+
+	Scanning:
+
+	An analogous set of functions scans formatted text to yield
+	values.  Scan, Scanf and Scanln read from os.Stdin; Fscan,
+	Fscanf and Fscanln read from a specified os.Reader; Sscan,
+	Sscanf and Sscanln read from an argument string.  Sscanln,
+	Fscanln and Sscanln stop scanning at a newline and require that
+	the items be followed by one; Sscanf, Fscanf and Sscanf require
+	newlines in the input to match newlines in the format; the other
+	routines treat newlines as spaces.
+
+	Scanf, Fscanf, and Sscanf parse the arguments according to a
+	format string, analogous to that of Printf.  For example, %x
+	will scan an integer as a hexadecimal number, and %v will scan
+	the default representation format for the value.
+
+	The formats behave analogously to those of Printf with the
+	following exceptions:
+
+	%p is not implemented
+	%T is not implemented
+	%e %E %f %F %g %g are all equivalent and scan any floating
+		point or complex value
+	%s and %v on strings scan a space-delimited token
+
+	Width is interpreted in the input text (%5s means at most
+	five runes of input will be read to scan a string) but there
+	is no syntax for scanning with a precision (no %5.2f, just
+	%5f).
+
+	When scanning with a format, all non-empty runs of space
+	characters (except newline) are equivalent to a single
+	space in both the format and the input.  With that proviso,
+	text in the format string must match the input text; scanning
+	stops if it does not, with the return value of the function
+	indicating the number of arguments scanned.
+
+	In all the scanning functions, if an operand implements method
+	Scan (that is, it implements the Scanner interface) that
+	method will be used to scan the text for that operand.  Also,
+	if the number of arguments scanned is less than the number of
+	arguments provided, an error is returned.
+
+	All arguments to be scanned must be either pointers to basic
+	types or implementations of the Scanner interface.
+
+	Note: Fscan etc. can read one character (rune) past the
+	input they return, which means that a loop calling a scan
+	routine may skip some of the input.  This is usually a
+	problem only when there is no space between input values.
+	However, if the reader provided to Fscan implements UnreadRune,
+	that method will be used to save the character and successive
+	calls will not lose data.  To attach an UnreadRune method
+	to a reader without that capability, use bufio.NewReader.
+*/
+package fmt
diff --git a/libgo/go/fmt/fmt_test.go b/libgo/go/fmt/fmt_test.go
new file mode 100644
index 0000000..2c09e07
--- /dev/null
+++ b/libgo/go/fmt/fmt_test.go
@@ -0,0 +1,652 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt_test
+
+import (
+	. "fmt"
+	"io"
+	"math"
+	"runtime" // for the malloc count test only
+	"strings"
+	"testing"
+)
+
+type (
+	renamedBool       bool
+	renamedInt        int
+	renamedInt8       int8
+	renamedInt16      int16
+	renamedInt32      int32
+	renamedInt64      int64
+	renamedUint       uint
+	renamedUint8      uint8
+	renamedUint16     uint16
+	renamedUint32     uint32
+	renamedUint64     uint64
+	renamedUintptr    uintptr
+	renamedString     string
+	renamedBytes      []byte
+	renamedFloat      float
+	renamedFloat32    float32
+	renamedFloat64    float64
+	renamedComplex    complex
+	renamedComplex64  complex64
+	renamedComplex128 complex128
+)
+
+func TestFmtInterface(t *testing.T) {
+	var i1 interface{}
+	i1 = "abc"
+	s := Sprintf("%s", i1)
+	if s != "abc" {
+		t.Errorf(`Sprintf("%%s", empty("abc")) = %q want %q`, s, "abc")
+	}
+}
+
+type fmtTest struct {
+	fmt string
+	val interface{}
+	out string
+}
+
+const b32 uint32 = 1<<32 - 1
+const b64 uint64 = 1<<64 - 1
+
+var array = []int{1, 2, 3, 4, 5}
+var iarray = []interface{}{1, "hello", 2.5, nil}
+
+type A struct {
+	i int
+	j uint
+	s string
+	x []int
+}
+
+type I int
+
+func (i I) String() string { return Sprintf("<%d>", int(i)) }
+
+type B struct {
+	i I
+	j int
+}
+
+type C struct {
+	i int
+	B
+}
+
+type F int
+
+func (f F) Format(s State, c int) {
+	Fprintf(s, "<%c=F(%d)>", c, int(f))
+}
+
+type G int
+
+func (g G) GoString() string {
+	return Sprintf("GoString(%d)", int(g))
+}
+
+type S struct {
+	f F // a struct field that Formats
+	g G // a struct field that GoStrings
+}
+
+// A type with a String method with pointer receiver for testing %p
+type P int
+
+var pValue P
+
+func (p *P) String() string {
+	return "String(p)"
+}
+
+var b byte
+
+var fmttests = []fmtTest{
+	{"%d", 12345, "12345"},
+	{"%v", 12345, "12345"},
+	{"%t", true, "true"},
+
+	// basic string
+	{"%s", "abc", "abc"},
+	{"%x", "abc", "616263"},
+	{"%x", "xyz", "78797a"},
+	{"%X", "xyz", "78797A"},
+	{"%q", "abc", `"abc"`},
+
+	// basic bytes
+	{"%s", []byte("abc"), "abc"},
+	{"%x", []byte("abc"), "616263"},
+	{"% x", []byte("abc"), "61 62 63"},
+	{"%x", []byte("xyz"), "78797a"},
+	{"%X", []byte("xyz"), "78797A"},
+	{"%q", []byte("abc"), `"abc"`},
+
+	// escaped strings
+	{"%#q", `abc`, "`abc`"},
+	{"%#q", `"`, "`\"`"},
+	{"1 %#q", `\n`, "1 `\\n`"},
+	{"2 %#q", "\n", `2 "\n"`},
+	{"%q", `"`, `"\""`},
+	{"%q", "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"`},
+	{"%q", "abc\xffdef", `"abc\xffdef"`},
+	{"%q", "\u263a", `"\u263a"`},
+	{"%q", "\U0010ffff", `"\U0010ffff"`},
+
+	// width
+	{"%5s", "abc", "  abc"},
+	{"%2s", "\u263a", " \u263a"},
+	{"%-5s", "abc", "abc  "},
+	{"%05s", "abc", "00abc"},
+
+	// integers
+	{"%d", 12345, "12345"},
+	{"%d", -12345, "-12345"},
+	{"%10d", 12345, "     12345"},
+	{"%10d", -12345, "    -12345"},
+	{"%+10d", 12345, "    +12345"},
+	{"%010d", 12345, "0000012345"},
+	{"%010d", -12345, "-000012345"},
+	{"%-10d", 12345, "12345     "},
+	{"%010.3d", 1, "       001"},
+	{"%010.3d", -1, "      -001"},
+	{"%+d", 12345, "+12345"},
+	{"%+d", -12345, "-12345"},
+	{"%+d", 0, "+0"},
+	{"% d", 0, " 0"},
+	{"% d", 12345, " 12345"},
+
+	// floats
+	{"%+.3e", 0.0, "+0.000e+00"},
+	{"%+.3e", 1.0, "+1.000e+00"},
+	{"%+.3f", -1.0, "-1.000"},
+	{"% .3E", -1.0, "-1.000E+00"},
+	{"% .3e", 1.0, " 1.000e+00"},
+	{"%+.3g", 0.0, "+0"},
+	{"%+.3g", 1.0, "+1"},
+	{"%+.3g", -1.0, "-1"},
+	{"% .3g", -1.0, "-1"},
+	{"% .3g", 1.0, " 1"},
+
+	// complex values
+	{"%+.3e", 0i, "(+0.000e+00+0.000e+00i)"},
+	{"%+.3f", 0i, "(+0.000+0.000i)"},
+	{"%+.3g", 0i, "(+0+0i)"},
+	{"%+.3e", 1 + 2i, "(+1.000e+00+2.000e+00i)"},
+	{"%+.3f", 1 + 2i, "(+1.000+2.000i)"},
+	{"%+.3g", 1 + 2i, "(+1+2i)"},
+	{"%.3e", 0i, "(0.000e+00+0.000e+00i)"},
+	{"%.3f", 0i, "(0.000+0.000i)"},
+	{"%.3g", 0i, "(0+0i)"},
+	{"%.3e", 1 + 2i, "(1.000e+00+2.000e+00i)"},
+	{"%.3f", 1 + 2i, "(1.000+2.000i)"},
+	{"%.3g", 1 + 2i, "(1+2i)"},
+	{"%.3e", -1 - 2i, "(-1.000e+00-2.000e+00i)"},
+	{"%.3f", -1 - 2i, "(-1.000-2.000i)"},
+	{"%.3g", -1 - 2i, "(-1-2i)"},
+	{"% .3E", -1 - 2i, "(-1.000E+00-2.000E+00i)"},
+	{"%+.3g", complex64(1 + 2i), "(+1+2i)"},
+	{"%+.3g", complex128(1 + 2i), "(+1+2i)"},
+
+	// erroneous formats
+	{"", 2, "%!(EXTRA int=2)"},
+	{"%d", "hello", "%!d(string=hello)"},
+
+	// old test/fmt_test.go
+	{"%d", 1234, "1234"},
+	{"%d", -1234, "-1234"},
+	{"%d", uint(1234), "1234"},
+	{"%d", uint32(b32), "4294967295"},
+	{"%d", uint64(b64), "18446744073709551615"},
+	{"%o", 01234, "1234"},
+	{"%#o", 01234, "01234"},
+	{"%o", uint32(b32), "37777777777"},
+	{"%o", uint64(b64), "1777777777777777777777"},
+	{"%x", 0x1234abcd, "1234abcd"},
+	{"%#x", 0x1234abcd, "0x1234abcd"},
+	{"%x", b32 - 0x1234567, "fedcba98"},
+	{"%X", 0x1234abcd, "1234ABCD"},
+	{"%X", b32 - 0x1234567, "FEDCBA98"},
+	{"%#X", 0, "0X0"},
+	{"%x", b64, "ffffffffffffffff"},
+	{"%b", 7, "111"},
+	{"%b", b64, "1111111111111111111111111111111111111111111111111111111111111111"},
+	{"%b", -6, "-110"},
+	{"%e", float64(1), "1.000000e+00"},
+	{"%e", float64(1234.5678e3), "1.234568e+06"},
+	{"%e", float64(1234.5678e-8), "1.234568e-05"},
+	{"%e", float64(-7), "-7.000000e+00"},
+	{"%e", float64(-1e-9), "-1.000000e-09"},
+	{"%f", float64(1234.5678e3), "1234567.800000"},
+	{"%f", float64(1234.5678e-8), "0.000012"},
+	{"%f", float64(-7), "-7.000000"},
+	{"%f", float64(-1e-9), "-0.000000"},
+	{"%g", float64(1234.5678e3), "1.2345678e+06"},
+	{"%g", float32(1234.5678e3), "1.2345678e+06"},
+	{"%g", float64(1234.5678e-8), "1.2345678e-05"},
+	{"%g", float64(-7), "-7"},
+	{"%g", float64(-1e-9), "-1e-09"},
+	{"%g", float32(-1e-9), "-1e-09"},
+	{"%E", float64(1), "1.000000E+00"},
+	{"%E", float64(1234.5678e3), "1.234568E+06"},
+	{"%E", float64(1234.5678e-8), "1.234568E-05"},
+	{"%E", float64(-7), "-7.000000E+00"},
+	{"%E", float64(-1e-9), "-1.000000E-09"},
+	{"%G", float64(1234.5678e3), "1.2345678E+06"},
+	{"%G", float32(1234.5678e3), "1.2345678E+06"},
+	{"%G", float64(1234.5678e-8), "1.2345678E-05"},
+	{"%G", float64(-7), "-7"},
+	{"%G", float64(-1e-9), "-1E-09"},
+	{"%G", float32(-1e-9), "-1E-09"},
+	{"%c", 'x', "x"},
+	{"%c", 0xe4, "ä"},
+	{"%c", 0x672c, "本"},
+	{"%c", '日', "日"},
+	{"%20.8d", 1234, "            00001234"},
+	{"%20.8d", -1234, "           -00001234"},
+	{"%20d", 1234, "                1234"},
+	{"%-20.8d", 1234, "00001234            "},
+	{"%-20.8d", -1234, "-00001234           "},
+	{"%-#20.8x", 0x1234abc, "0x01234abc          "},
+	{"%-#20.8X", 0x1234abc, "0X01234ABC          "},
+	{"%-#20.8o", 01234, "00001234            "},
+	{"%.20b", 7, "00000000000000000111"},
+	{"%20.5s", "qwertyuiop", "               qwert"},
+	{"%.5s", "qwertyuiop", "qwert"},
+	{"%-20.5s", "qwertyuiop", "qwert               "},
+	{"%20c", 'x', "                   x"},
+	{"%-20c", 'x', "x                   "},
+	{"%20.6e", 1.2345e3, "        1.234500e+03"},
+	{"%20.6e", 1.2345e-3, "        1.234500e-03"},
+	{"%20e", 1.2345e3, "        1.234500e+03"},
+	{"%20e", 1.2345e-3, "        1.234500e-03"},
+	{"%20.8e", 1.2345e3, "      1.23450000e+03"},
+	{"%20f", float64(1.23456789e3), "         1234.567890"},
+	{"%20f", float64(1.23456789e-3), "            0.001235"},
+	{"%20f", float64(12345678901.23456789), "  12345678901.234568"},
+	{"%-20f", float64(1.23456789e3), "1234.567890         "},
+	{"%20.8f", float64(1.23456789e3), "       1234.56789000"},
+	{"%20.8f", float64(1.23456789e-3), "          0.00123457"},
+	{"%g", float64(1.23456789e3), "1234.56789"},
+	{"%g", float64(1.23456789e-3), "0.00123456789"},
+	{"%g", float64(1.23456789e20), "1.23456789e+20"},
+	{"%20e", math.Inf(1), "                +Inf"},
+	{"%-20f", math.Inf(-1), "-Inf                "},
+	{"%20g", math.NaN(), "                 NaN"},
+
+	// arrays
+	{"%v", array, "[1 2 3 4 5]"},
+	{"%v", iarray, "[1 hello 2.5 <nil>]"},
+	{"%v", &array, "&[1 2 3 4 5]"},
+	{"%v", &iarray, "&[1 hello 2.5 <nil>]"},
+
+	// complexes with %v
+	{"%v", 1 + 2i, "(1+2i)"},
+	{"%v", complex64(1 + 2i), "(1+2i)"},
+	{"%v", complex128(1 + 2i), "(1+2i)"},
+
+	// structs
+	{"%v", A{1, 2, "a", []int{1, 2}}, `{1 2 a [1 2]}`},
+	{"%+v", A{1, 2, "a", []int{1, 2}}, `{i:1 j:2 s:a x:[1 2]}`},
+
+	// +v on structs with Stringable items
+	{"%+v", B{1, 2}, `{i:<1> j:2}`},
+	{"%+v", C{1, B{2, 3}}, `{i:1 B:{i:<2> j:3}}`},
+
+	// q on Stringable items
+	{"%s", I(23), `<23>`},
+	{"%q", I(23), `"<23>"`},
+	{"%x", I(23), `3c32333e`},
+	{"%d", I(23), `%!d(string=<23>)`},
+
+	// go syntax
+	{"%#v", A{1, 2, "a", []int{1, 2}}, `fmt_test.A{i:1, j:0x2, s:"a", x:[]int{1, 2}}`},
+	{"%#v", &b, "(*uint8)(PTR)"},
+	{"%#v", TestFmtInterface, "(func(*testing.T))(PTR)"},
+	{"%#v", make(chan int), "(chan int)(PTR)"},
+	{"%#v", uint64(1<<64 - 1), "0xffffffffffffffff"},
+	{"%#v", 1000000000, "1000000000"},
+	{"%#v", map[string]int{"a": 1, "b": 2}, `map[string] int{"a":1, "b":2}`},
+	{"%#v", map[string]B{"a": {1, 2}, "b": {3, 4}}, `map[string] fmt_test.B{"a":fmt_test.B{i:1, j:2}, "b":fmt_test.B{i:3, j:4}}`},
+	{"%#v", []string{"a", "b"}, `[]string{"a", "b"}`},
+
+	// slices with other formats
+	{"%#x", []int{1, 2, 15}, `[0x1 0x2 0xf]`},
+	{"%x", []int{1, 2, 15}, `[1 2 f]`},
+	{"%d", []int{1, 2, 15}, `[1 2 15]`},
+	{"%d", []byte{1, 2, 15}, `[1 2 15]`},
+	{"%q", []string{"a", "b"}, `["a" "b"]`},
+
+	// renamings
+	{"%v", renamedBool(true), "true"},
+	{"%d", renamedBool(true), "%!d(fmt_test.renamedBool=true)"},
+	{"%o", renamedInt(8), "10"},
+	{"%d", renamedInt8(-9), "-9"},
+	{"%v", renamedInt16(10), "10"},
+	{"%v", renamedInt32(-11), "-11"},
+	{"%X", renamedInt64(255), "FF"},
+	{"%v", renamedUint(13), "13"},
+	{"%o", renamedUint8(14), "16"},
+	{"%X", renamedUint16(15), "F"},
+	{"%d", renamedUint32(16), "16"},
+	{"%X", renamedUint64(17), "11"},
+	{"%o", renamedUintptr(18), "22"},
+	{"%x", renamedString("thing"), "7468696e67"},
+	{"%d", renamedBytes([]byte{1, 2, 15}), `[1 2 15]`},
+	{"%q", renamedBytes([]byte("hello")), `"hello"`},
+	{"%v", renamedFloat(11), "11"},
+	{"%v", renamedFloat32(22), "22"},
+	{"%v", renamedFloat64(33), "33"},
+	{"%v", renamedComplex(7 + .2i), "(7+0.2i)"},
+	{"%v", renamedComplex64(3 + 4i), "(3+4i)"},
+	{"%v", renamedComplex128(4 - 3i), "(4-3i)"},
+
+	// Formatter
+	{"%x", F(1), "<x=F(1)>"},
+	{"%x", G(2), "2"},
+	{"%+v", S{F(4), G(5)}, "{f:<v=F(4)> g:5}"},
+
+	// GoStringer
+	{"%#v", G(6), "GoString(6)"},
+	{"%#v", S{F(7), G(8)}, "fmt_test.S{f:<v=F(7)>, g:GoString(8)}"},
+
+	// %T
+	{"%T", (4 - 3i), "complex"},
+	{"%T", renamedComplex128(4 - 3i), "fmt_test.renamedComplex128"},
+	{"%T", intVal, "int"},
+	{"%6T", &intVal, "  *int"},
+
+	// %p
+	{"p0=%p", new(int), "p0=PTR"},
+	{"p1=%s", &pValue, "p1=String(p)"}, // String method...
+	{"p2=%p", &pValue, "p2=PTR"},       // ... not called with %p
+
+	// %p on non-pointers
+	{"%p", make(chan int), "PTR"},
+	{"%p", make(map[int]int), "PTR"},
+	{"%p", make([]int, 1), "PTR"},
+	{"%p", 27, "%!p(int=27)"}, // not a pointer at all
+
+	// erroneous things
+	{"%d", "hello", "%!d(string=hello)"},
+	{"no args", "hello", "no args%!(EXTRA string=hello)"},
+	{"%s", nil, "%!s(<nil>)"},
+	{"%T", nil, "<nil>"},
+	{"%-1", 100, "%!1(int=100)"},
+}
+
+func TestSprintf(t *testing.T) {
+	for _, tt := range fmttests {
+		s := Sprintf(tt.fmt, tt.val)
+		if i := strings.Index(s, "0x"); i >= 0 && strings.Contains(tt.out, "PTR") {
+			j := i + 2
+			for ; j < len(s); j++ {
+				c := s[j]
+				if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
+					break
+				}
+			}
+			s = s[0:i] + "PTR" + s[j:]
+		}
+		if s != tt.out {
+			if _, ok := tt.val.(string); ok {
+				// Don't requote the already-quoted strings.
+				// It's too confusing to read the errors.
+				t.Errorf("Sprintf(%q, %q) = <%s> want <%s>", tt.fmt, tt.val, s, tt.out)
+			} else {
+				t.Errorf("Sprintf(%q, %v) = %q want %q", tt.fmt, tt.val, s, tt.out)
+			}
+		}
+	}
+}
+
+func BenchmarkSprintfEmpty(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Sprintf("")
+	}
+}
+
+func BenchmarkSprintfString(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Sprintf("%s", "hello")
+	}
+}
+
+func BenchmarkSprintfInt(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Sprintf("%d", 5)
+	}
+}
+
+func BenchmarkSprintfIntInt(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Sprintf("%d %d", 5, 6)
+	}
+}
+
+func TestCountMallocs(t *testing.T) {
+	mallocs := 0 - runtime.MemStats.Mallocs
+	for i := 0; i < 100; i++ {
+		Sprintf("")
+	}
+	mallocs += runtime.MemStats.Mallocs
+	Printf("mallocs per Sprintf(\"\"): %d\n", mallocs/100)
+	mallocs = 0 - runtime.MemStats.Mallocs
+	for i := 0; i < 100; i++ {
+		Sprintf("xxx")
+	}
+	mallocs += runtime.MemStats.Mallocs
+	Printf("mallocs per Sprintf(\"xxx\"): %d\n", mallocs/100)
+	mallocs = 0 - runtime.MemStats.Mallocs
+	for i := 0; i < 100; i++ {
+		Sprintf("%x", i)
+	}
+	mallocs += runtime.MemStats.Mallocs
+	Printf("mallocs per Sprintf(\"%%x\"): %d\n", mallocs/100)
+	mallocs = 0 - runtime.MemStats.Mallocs
+	for i := 0; i < 100; i++ {
+		Sprintf("%x %x", i, i)
+	}
+	mallocs += runtime.MemStats.Mallocs
+	Printf("mallocs per Sprintf(\"%%x %%x\"): %d\n", mallocs/100)
+}
+
+type flagPrinter struct{}
+
+func (*flagPrinter) Format(f State, c int) {
+	s := "%"
+	for i := 0; i < 128; i++ {
+		if f.Flag(i) {
+			s += string(i)
+		}
+	}
+	if w, ok := f.Width(); ok {
+		s += Sprintf("%d", w)
+	}
+	if p, ok := f.Precision(); ok {
+		s += Sprintf(".%d", p)
+	}
+	s += string(c)
+	io.WriteString(f, "["+s+"]")
+}
+
+type flagTest struct {
+	in  string
+	out string
+}
+
+var flagtests = []flagTest{
+	{"%a", "[%a]"},
+	{"%-a", "[%-a]"},
+	{"%+a", "[%+a]"},
+	{"%#a", "[%#a]"},
+	{"% a", "[% a]"},
+	{"%0a", "[%0a]"},
+	{"%1.2a", "[%1.2a]"},
+	{"%-1.2a", "[%-1.2a]"},
+	{"%+1.2a", "[%+1.2a]"},
+	{"%-+1.2a", "[%+-1.2a]"},
+	{"%-+1.2abc", "[%+-1.2a]bc"},
+	{"%-1.2abc", "[%-1.2a]bc"},
+}
+
+func TestFlagParser(t *testing.T) {
+	var flagprinter flagPrinter
+	for _, tt := range flagtests {
+		s := Sprintf(tt.in, &flagprinter)
+		if s != tt.out {
+			t.Errorf("Sprintf(%q, &flagprinter) => %q, want %q", tt.in, s, tt.out)
+		}
+	}
+}
+
+func TestStructPrinter(t *testing.T) {
+	var s struct {
+		a string
+		b string
+		c int
+	}
+	s.a = "abc"
+	s.b = "def"
+	s.c = 123
+	type Test struct {
+		fmt string
+		out string
+	}
+	var tests = []Test{
+		{"%v", "{abc def 123}"},
+		{"%+v", "{a:abc b:def c:123}"},
+	}
+	for _, tt := range tests {
+		out := Sprintf(tt.fmt, s)
+		if out != tt.out {
+			t.Errorf("Sprintf(%q, &s) = %q, want %q", tt.fmt, out, tt.out)
+		}
+	}
+}
+
+// Check map printing using substrings so we don't depend on the print order.
+func presentInMap(s string, a []string, t *testing.T) {
+	for i := 0; i < len(a); i++ {
+		loc := strings.Index(s, a[i])
+		if loc < 0 {
+			t.Errorf("map print: expected to find %q in %q", a[i], s)
+		}
+		// make sure the match ends here
+		loc += len(a[i])
+		if loc >= len(s) || (s[loc] != ' ' && s[loc] != ']') {
+			t.Errorf("map print: %q not properly terminated in %q", a[i], s)
+		}
+	}
+}
+
+func TestMapPrinter(t *testing.T) {
+	m0 := make(map[int]string)
+	s := Sprint(m0)
+	if s != "map[]" {
+		t.Errorf("empty map printed as %q not %q", s, "map[]")
+	}
+	m1 := map[int]string{1: "one", 2: "two", 3: "three"}
+	a := []string{"1:one", "2:two", "3:three"}
+	presentInMap(Sprintf("%v", m1), a, t)
+	presentInMap(Sprint(m1), a, t)
+}
+
+func TestEmptyMap(t *testing.T) {
+	const emptyMapStr = "map[]"
+	var m map[string]int
+	s := Sprint(m)
+	if s != emptyMapStr {
+		t.Errorf("nil map printed as %q not %q", s, emptyMapStr)
+	}
+	m = make(map[string]int)
+	s = Sprint(m)
+	if s != emptyMapStr {
+		t.Errorf("empty map printed as %q not %q", s, emptyMapStr)
+	}
+}
+
+// Check that Sprint (and hence Print, Fprint) puts spaces in the right places,
+// that is, between arg pairs in which neither is a string.
+func TestBlank(t *testing.T) {
+	got := Sprint("<", 1, ">:", 1, 2, 3, "!")
+	expect := "<1>:1 2 3!"
+	if got != expect {
+		t.Errorf("got %q expected %q", got, expect)
+	}
+}
+
+// Check that Sprintln (and hence Println, Fprintln) puts spaces in the right places,
+// that is, between all arg pairs.
+func TestBlankln(t *testing.T) {
+	got := Sprintln("<", 1, ">:", 1, 2, 3, "!")
+	expect := "< 1 >: 1 2 3 !\n"
+	if got != expect {
+		t.Errorf("got %q expected %q", got, expect)
+	}
+}
+
+
+// Check Formatter with Sprint, Sprintln, Sprintf
+func TestFormatterPrintln(t *testing.T) {
+	f := F(1)
+	expect := "<v=F(1)>\n"
+	s := Sprint(f, "\n")
+	if s != expect {
+		t.Errorf("Sprint wrong with Formatter: expected %q got %q", expect, s)
+	}
+	s = Sprintln(f)
+	if s != expect {
+		t.Errorf("Sprintln wrong with Formatter: expected %q got %q", expect, s)
+	}
+	s = Sprintf("%v\n", f)
+	if s != expect {
+		t.Errorf("Sprintf wrong with Formatter: expected %q got %q", expect, s)
+	}
+}
+
+func args(a ...interface{}) []interface{} { return a }
+
+type starTest struct {
+	fmt string
+	in  []interface{}
+	out string
+}
+
+var startests = []starTest{
+	{"%*d", args(4, 42), "  42"},
+	{"%.*d", args(4, 42), "0042"},
+	{"%*.*d", args(8, 4, 42), "    0042"},
+	{"%0*d", args(4, 42), "0042"},
+	{"%-*d", args(4, 42), "42  "},
+
+	// erroneous
+	{"%*d", args(nil, 42), "%!(BADWIDTH)42"},
+	{"%.*d", args(nil, 42), "%!(BADPREC)42"},
+	{"%*d", args(5, "foo"), "%!d(string=  foo)"},
+	{"%*% %d", args(20, 5), "% 5"},
+	{"%*", args(4), "%!(BADWIDTH)%!*(int=4)"},
+	{"%*d", args(int32(4), 42), "%!(BADWIDTH)42"},
+}
+
+// TODO: there's no conversion from []T to ...T, but we can fake it.  These
+// functions do the faking.  We index the table by the length of the param list.
+var sprintf = []func(string, []interface{}) string{
+	0: func(f string, i []interface{}) string { return Sprintf(f) },
+	1: func(f string, i []interface{}) string { return Sprintf(f, i[0]) },
+	2: func(f string, i []interface{}) string { return Sprintf(f, i[0], i[1]) },
+	3: func(f string, i []interface{}) string { return Sprintf(f, i[0], i[1], i[2]) },
+}
+
+func TestWidthAndPrecision(t *testing.T) {
+	for _, tt := range startests {
+		s := sprintf[len(tt.in)](tt.fmt, tt.in)
+		if s != tt.out {
+			t.Errorf("got %q expected %q", s, tt.out)
+		}
+	}
+}
diff --git a/libgo/go/fmt/format.go b/libgo/go/fmt/format.go
new file mode 100644
index 0000000..3ec1cf1
--- /dev/null
+++ b/libgo/go/fmt/format.go
@@ -0,0 +1,420 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"bytes"
+	"strconv"
+	"utf8"
+)
+
+const (
+	nByte = 64
+
+	ldigits = "0123456789abcdef"
+	udigits = "0123456789ABCDEF"
+)
+
+const (
+	signed   = true
+	unsigned = false
+)
+
+var padZeroBytes = make([]byte, nByte)
+var padSpaceBytes = make([]byte, nByte)
+
+var newline = []byte{'\n'}
+
+func init() {
+	for i := 0; i < nByte; i++ {
+		padZeroBytes[i] = '0'
+		padSpaceBytes[i] = ' '
+	}
+}
+
+// A fmt is the raw formatter used by Printf etc.
+// It prints into a bytes.Buffer that must be set up externally.
+type fmt struct {
+	intbuf [nByte]byte
+	buf    *bytes.Buffer
+	// width, precision
+	wid  int
+	prec int
+	// flags
+	widPresent  bool
+	precPresent bool
+	minus       bool
+	plus        bool
+	sharp       bool
+	space       bool
+	zero        bool
+}
+
+func (f *fmt) clearflags() {
+	f.wid = 0
+	f.widPresent = false
+	f.prec = 0
+	f.precPresent = false
+	f.minus = false
+	f.plus = false
+	f.sharp = false
+	f.space = false
+	f.zero = false
+}
+
+func (f *fmt) init(buf *bytes.Buffer) {
+	f.buf = buf
+	f.clearflags()
+}
+
+// Compute left and right padding widths (only one will be non-zero).
+func (f *fmt) computePadding(width int) (padding []byte, leftWidth, rightWidth int) {
+	left := !f.minus
+	w := f.wid
+	if w < 0 {
+		left = false
+		w = -w
+	}
+	w -= width
+	if w > 0 {
+		if left && f.zero {
+			return padZeroBytes, w, 0
+		}
+		if left {
+			return padSpaceBytes, w, 0
+		} else {
+			// can't be zero padding on the right
+			return padSpaceBytes, 0, w
+		}
+	}
+	return
+}
+
+// Generate n bytes of padding.
+func (f *fmt) writePadding(n int, padding []byte) {
+	for n > 0 {
+		m := n
+		if m > nByte {
+			m = nByte
+		}
+		f.buf.Write(padding[0:m])
+		n -= m
+	}
+}
+
+// Append b to f.buf, padded on left (w > 0) or right (w < 0 or f.minus)
+// clear flags aftewards.
+func (f *fmt) pad(b []byte) {
+	var padding []byte
+	var left, right int
+	if f.widPresent && f.wid != 0 {
+		padding, left, right = f.computePadding(len(b))
+	}
+	if left > 0 {
+		f.writePadding(left, padding)
+	}
+	f.buf.Write(b)
+	if right > 0 {
+		f.writePadding(right, padding)
+	}
+}
+
+// append s to buf, padded on left (w > 0) or right (w < 0 or f.minus).
+// clear flags aftewards.
+func (f *fmt) padString(s string) {
+	var padding []byte
+	var left, right int
+	if f.widPresent && f.wid != 0 {
+		padding, left, right = f.computePadding(utf8.RuneCountInString(s))
+	}
+	if left > 0 {
+		f.writePadding(left, padding)
+	}
+	f.buf.WriteString(s)
+	if right > 0 {
+		f.writePadding(right, padding)
+	}
+}
+
+func putint(buf []byte, base, val uint64, digits string) int {
+	i := len(buf) - 1
+	for val >= base {
+		buf[i] = digits[val%base]
+		i--
+		val /= base
+	}
+	buf[i] = digits[val]
+	return i - 1
+}
+
+// fmt_boolean formats a boolean.
+func (f *fmt) fmt_boolean(v bool) {
+	if v {
+		f.padString("true")
+	} else {
+		f.padString("false")
+	}
+}
+
+// integer; interprets prec but not wid.  Once formatted, result is sent to pad()
+// and then flags are cleared.
+func (f *fmt) integer(a int64, base uint64, signedness bool, digits string) {
+	var buf []byte = f.intbuf[0:]
+	negative := signedness == signed && a < 0
+	if negative {
+		a = -a
+	}
+
+	// two ways to ask for extra leading zero digits: %.3d or %03d.
+	// apparently the first cancels the second.
+	prec := 0
+	if f.precPresent {
+		prec = f.prec
+		f.zero = false
+	} else if f.zero && f.widPresent && !f.minus && f.wid > 0 {
+		prec = f.wid
+		if negative || f.plus || f.space {
+			prec-- // leave room for sign
+		}
+	}
+
+	// format a into buf, ending at buf[i].  (printing is easier right-to-left.)
+	// a is made into unsigned ua.  we could make things
+	// marginally faster by splitting the 32-bit case out into a separate
+	// block but it's not worth the duplication, so ua has 64 bits.
+	i := len(f.intbuf)
+	ua := uint64(a)
+	for ua >= base {
+		i--
+		buf[i] = digits[ua%base]
+		ua /= base
+	}
+	i--
+	buf[i] = digits[ua]
+	for i > 0 && prec > nByte-i {
+		i--
+		buf[i] = '0'
+	}
+
+	// Various prefixes: 0x, -, etc.
+	if f.sharp {
+		switch base {
+		case 8:
+			if buf[i] != '0' {
+				i--
+				buf[i] = '0'
+			}
+		case 16:
+			i--
+			buf[i] = 'x' + digits[10] - 'a'
+			i--
+			buf[i] = '0'
+		}
+	}
+
+	if negative {
+		i--
+		buf[i] = '-'
+	} else if f.plus {
+		i--
+		buf[i] = '+'
+	} else if f.space {
+		i--
+		buf[i] = ' '
+	}
+	f.pad(buf[i:])
+}
+
+// fmt_s formats a string.
+func (f *fmt) fmt_s(s string) {
+	if f.precPresent {
+		if f.prec < len(s) {
+			s = s[0:f.prec]
+		}
+	}
+	f.padString(s)
+}
+
+// fmt_sx formats a string as a hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sx(s string) {
+	t := ""
+	for i := 0; i < len(s); i++ {
+		if i > 0 && f.space {
+			t += " "
+		}
+		v := s[i]
+		t += string(ldigits[v>>4])
+		t += string(ldigits[v&0xF])
+	}
+	f.padString(t)
+}
+
+// fmt_sX formats a string as an uppercase hexadecimal encoding of its bytes.
+func (f *fmt) fmt_sX(s string) {
+	t := ""
+	for i := 0; i < len(s); i++ {
+		v := s[i]
+		t += string(udigits[v>>4])
+		t += string(udigits[v&0xF])
+	}
+	f.padString(t)
+}
+
+// fmt_q formats a string as a double-quoted, escaped Go string constant.
+func (f *fmt) fmt_q(s string) {
+	var quoted string
+	if f.sharp && strconv.CanBackquote(s) {
+		quoted = "`" + s + "`"
+	} else {
+		quoted = strconv.Quote(s)
+	}
+	f.padString(quoted)
+}
+
+// floating-point
+
+func doPrec(f *fmt, def int) int {
+	if f.precPresent {
+		return f.prec
+	}
+	return def
+}
+
+// Add a plus sign or space to the floating-point string representation if missing and required.
+func (f *fmt) plusSpace(s string) {
+	if s[0] != '-' {
+		if f.plus {
+			s = "+" + s
+		} else if f.space {
+			s = " " + s
+		}
+	}
+	f.padString(s)
+}
+
+// fmt_e64 formats a float64 in the form -1.23e+12.
+func (f *fmt) fmt_e64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'e', doPrec(f, 6))) }
+
+// fmt_E64 formats a float64 in the form -1.23E+12.
+func (f *fmt) fmt_E64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'E', doPrec(f, 6))) }
+
+// fmt_f64 formats a float64 in the form -1.23.
+func (f *fmt) fmt_f64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'f', doPrec(f, 6))) }
+
+// fmt_g64 formats a float64 in the 'f' or 'e' form according to size.
+func (f *fmt) fmt_g64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'g', doPrec(f, -1))) }
+
+// fmt_g64 formats a float64 in the 'f' or 'E' form according to size.
+func (f *fmt) fmt_G64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'G', doPrec(f, -1))) }
+
+// fmt_fb64 formats a float64 in the form -123p3 (exponent is power of 2).
+func (f *fmt) fmt_fb64(v float64) { f.plusSpace(strconv.Ftoa64(v, 'b', 0)) }
+
+// float32
+// cannot defer to float64 versions
+// because it will get rounding wrong in corner cases.
+
+// fmt_e32 formats a float32 in the form -1.23e+12.
+func (f *fmt) fmt_e32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'e', doPrec(f, 6))) }
+
+// fmt_E32 formats a float32 in the form -1.23E+12.
+func (f *fmt) fmt_E32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'E', doPrec(f, 6))) }
+
+// fmt_f32 formats a float32 in the form -1.23.
+func (f *fmt) fmt_f32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'f', doPrec(f, 6))) }
+
+// fmt_g32 formats a float32 in the 'f' or 'e' form according to size.
+func (f *fmt) fmt_g32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'g', doPrec(f, -1))) }
+
+// fmt_G32 formats a float32 in the 'f' or 'E' form according to size.
+func (f *fmt) fmt_G32(v float32) { f.plusSpace(strconv.Ftoa32(v, 'G', doPrec(f, -1))) }
+
+// fmt_fb32 formats a float32 in the form -123p3 (exponent is power of 2).
+func (f *fmt) fmt_fb32(v float32) { f.padString(strconv.Ftoa32(v, 'b', 0)) }
+
+// fmt_c64 formats a complex64 according to the verb.
+func (f *fmt) fmt_c64(v complex64, verb int) {
+	f.buf.WriteByte('(')
+	r := real(v)
+	for i := 0; ; i++ {
+		switch verb {
+		case 'e':
+			f.fmt_e32(r)
+		case 'E':
+			f.fmt_E32(r)
+		case 'f':
+			f.fmt_f32(r)
+		case 'g':
+			f.fmt_g32(r)
+		case 'G':
+			f.fmt_G32(r)
+		}
+		if i != 0 {
+			break
+		}
+		f.plus = true
+		r = imag(v)
+	}
+	f.buf.Write(irparenBytes)
+}
+
+// fmt_c128 formats a complex128 according to the verb.
+func (f *fmt) fmt_c128(v complex128, verb int) {
+	f.buf.WriteByte('(')
+	r := real(v)
+	for i := 0; ; i++ {
+		switch verb {
+		case 'e':
+			f.fmt_e64(r)
+		case 'E':
+			f.fmt_E64(r)
+		case 'f':
+			f.fmt_f64(r)
+		case 'g':
+			f.fmt_g64(r)
+		case 'G':
+			f.fmt_G64(r)
+		}
+		if i != 0 {
+			break
+		}
+		f.plus = true
+		r = imag(v)
+	}
+	f.buf.Write(irparenBytes)
+}
+
+// float
+func (x *fmt) f(a float) {
+	if strconv.FloatSize == 32 {
+		x.fmt_f32(float32(a))
+	} else {
+		x.fmt_f64(float64(a))
+	}
+}
+
+func (x *fmt) e(a float) {
+	if strconv.FloatSize == 32 {
+		x.fmt_e32(float32(a))
+	} else {
+		x.fmt_e64(float64(a))
+	}
+}
+
+func (x *fmt) g(a float) {
+	if strconv.FloatSize == 32 {
+		x.fmt_g32(float32(a))
+	} else {
+		x.fmt_g64(float64(a))
+	}
+}
+
+func (x *fmt) fb(a float) {
+	if strconv.FloatSize == 32 {
+		x.fmt_fb32(float32(a))
+	} else {
+		x.fmt_fb64(float64(a))
+	}
+}
diff --git a/libgo/go/fmt/print.go b/libgo/go/fmt/print.go
new file mode 100644
index 0000000..24b1eb3
--- /dev/null
+++ b/libgo/go/fmt/print.go
@@ -0,0 +1,913 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"reflect"
+	"utf8"
+)
+
+// Some constants in the form of bytes, to avoid string overhead.
+// Needlessly fastidious, I suppose.
+var (
+	commaSpaceBytes = []byte(", ")
+	nilAngleBytes   = []byte("<nil>")
+	nilParenBytes   = []byte("(nil)")
+	nilBytes        = []byte("nil")
+	mapBytes        = []byte("map[")
+	missingBytes    = []byte("(MISSING)")
+	extraBytes      = []byte("%!(EXTRA ")
+	irparenBytes    = []byte("i)")
+	bytesBytes      = []byte("[]byte{")
+	widthBytes      = []byte("%!(BADWIDTH)")
+	precBytes       = []byte("%!(BADPREC)")
+)
+
+// State represents the printer state passed to custom formatters.
+// It provides access to the io.Writer interface plus information about
+// the flags and options for the operand's format specifier.
+type State interface {
+	// Write is the function to call to emit formatted output to be printed.
+	Write(b []byte) (ret int, err os.Error)
+	// Width returns the value of the width option and whether it has been set.
+	Width() (wid int, ok bool)
+	// Precision returns the value of the precision option and whether it has been set.
+	Precision() (prec int, ok bool)
+
+	// Flag returns whether the flag c, a character, has been set.
+	Flag(int) bool
+}
+
+// Formatter is the interface implemented by values with a custom formatter.
+// The implementation of Format may call Sprintf or Fprintf(f) etc.
+// to generate its output.
+type Formatter interface {
+	Format(f State, c int)
+}
+
+// Stringer is implemented by any value that has a String method(),
+// which defines the ``native'' format for that value.
+// The String method is used to print values passed as an operand
+// to a %s or %v format or to an unformatted printer such as Print.
+type Stringer interface {
+	String() string
+}
+
+// GoStringer is implemented by any value that has a GoString() method,
+// which defines the Go syntax for that value.
+// The GoString method is used to print values passed as an operand
+// to a %#v format.
+type GoStringer interface {
+	GoString() string
+}
+
+type pp struct {
+	n       int
+	buf     bytes.Buffer
+	runeBuf [utf8.UTFMax]byte
+	fmt     fmt
+}
+
+// A leaky bucket of reusable pp structures.
+var ppFree = make(chan *pp, 100)
+
+// Allocate a new pp struct.  Probably can grab the previous one from ppFree.
+func newPrinter() *pp {
+	p, ok := <-ppFree
+	if !ok {
+		p = new(pp)
+	}
+	p.fmt.init(&p.buf)
+	return p
+}
+
+// Save used pp structs in ppFree; avoids an allocation per invocation.
+func (p *pp) free() {
+	// Don't hold on to pp structs with large buffers.
+	if cap(p.buf.Bytes()) > 1024 {
+		return
+	}
+	p.buf.Reset()
+	_ = ppFree <- p
+}
+
+func (p *pp) Width() (wid int, ok bool) { return p.fmt.wid, p.fmt.widPresent }
+
+func (p *pp) Precision() (prec int, ok bool) { return p.fmt.prec, p.fmt.precPresent }
+
+func (p *pp) Flag(b int) bool {
+	switch b {
+	case '-':
+		return p.fmt.minus
+	case '+':
+		return p.fmt.plus
+	case '#':
+		return p.fmt.sharp
+	case ' ':
+		return p.fmt.space
+	case '0':
+		return p.fmt.zero
+	}
+	return false
+}
+
+func (p *pp) add(c int) {
+	if c < utf8.RuneSelf {
+		p.buf.WriteByte(byte(c))
+	} else {
+		w := utf8.EncodeRune(c, p.runeBuf[0:])
+		p.buf.Write(p.runeBuf[0:w])
+	}
+}
+
+// Implement Write so we can call Fprintf on a pp (through State), for
+// recursive use in custom verbs.
+func (p *pp) Write(b []byte) (ret int, err os.Error) {
+	return p.buf.Write(b)
+}
+
+// These routines end in 'f' and take a format string.
+
+// Fprintf formats according to a format specifier and writes to w.
+// It returns the number of bytes written and any write error encountered.
+func Fprintf(w io.Writer, format string, a ...interface{}) (n int, error os.Error) {
+	p := newPrinter()
+	p.doPrintf(format, a)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
+}
+
+// Printf formats according to a format specifier and writes to standard output.
+// It returns the number of bytes written and any write error encountered.
+func Printf(format string, a ...interface{}) (n int, errno os.Error) {
+	n, errno = Fprintf(os.Stdout, format, a...)
+	return n, errno
+}
+
+// Sprintf formats according to a format specifier and returns the resulting string.
+func Sprintf(format string, a ...interface{}) string {
+	p := newPrinter()
+	p.doPrintf(format, a)
+	s := p.buf.String()
+	p.free()
+	return s
+}
+
+// Errorf formats according to a format specifier and returns the string 
+// converted to an os.ErrorString, which satisfies the os.Error interface.
+func Errorf(format string, a ...interface{}) os.Error {
+	return os.ErrorString(Sprintf(format, a...))
+}
+
+// These routines do not take a format string
+
+// Fprint formats using the default formats for its operands and writes to w.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+func Fprint(w io.Writer, a ...interface{}) (n int, error os.Error) {
+	p := newPrinter()
+	p.doPrint(a, false, false)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
+}
+
+// Print formats using the default formats for its operands and writes to standard output.
+// Spaces are added between operands when neither is a string.
+// It returns the number of bytes written and any write error encountered.
+func Print(a ...interface{}) (n int, errno os.Error) {
+	n, errno = Fprint(os.Stdout, a...)
+	return n, errno
+}
+
+// Sprint formats using the default formats for its operands and returns the resulting string.
+// Spaces are added between operands when neither is a string.
+func Sprint(a ...interface{}) string {
+	p := newPrinter()
+	p.doPrint(a, false, false)
+	s := p.buf.String()
+	p.free()
+	return s
+}
+
+// These routines end in 'ln', do not take a format string,
+// always add spaces between operands, and add a newline
+// after the last operand.
+
+// Fprintln formats using the default formats for its operands and writes to w.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func Fprintln(w io.Writer, a ...interface{}) (n int, error os.Error) {
+	p := newPrinter()
+	p.doPrint(a, true, true)
+	n64, error := p.buf.WriteTo(w)
+	p.free()
+	return int(n64), error
+}
+
+// Println formats using the default formats for its operands and writes to standard output.
+// Spaces are always added between operands and a newline is appended.
+// It returns the number of bytes written and any write error encountered.
+func Println(a ...interface{}) (n int, errno os.Error) {
+	n, errno = Fprintln(os.Stdout, a...)
+	return n, errno
+}
+
+// Sprintln formats using the default formats for its operands and returns the resulting string.
+// Spaces are always added between operands and a newline is appended.
+func Sprintln(a ...interface{}) string {
+	p := newPrinter()
+	p.doPrint(a, true, true)
+	s := p.buf.String()
+	p.free()
+	return s
+}
+
+
+// Get the i'th arg of the struct value.
+// If the arg itself is an interface, return a value for
+// the thing inside the interface, not the interface itself.
+func getField(v *reflect.StructValue, i int) reflect.Value {
+	val := v.Field(i)
+	if i, ok := val.(*reflect.InterfaceValue); ok {
+		if inter := i.Interface(); inter != nil {
+			return reflect.NewValue(inter)
+		}
+	}
+	return val
+}
+
+// Convert ASCII to integer.  n is 0 (and got is false) if no number present.
+func parsenum(s string, start, end int) (num int, isnum bool, newi int) {
+	if start >= end {
+		return 0, false, end
+	}
+	for newi = start; newi < end && '0' <= s[newi] && s[newi] <= '9'; newi++ {
+		num = num*10 + int(s[newi]-'0')
+		isnum = true
+	}
+	return
+}
+
+// Reflection values like reflect.FuncValue implement this method. We use it for %p.
+type uintptrGetter interface {
+	Get() uintptr
+}
+
+func (p *pp) unknownType(v interface{}) {
+	if v == nil {
+		p.buf.Write(nilAngleBytes)
+		return
+	}
+	p.buf.WriteByte('?')
+	p.buf.WriteString(reflect.Typeof(v).String())
+	p.buf.WriteByte('?')
+}
+
+func (p *pp) badVerb(verb int, val interface{}) {
+	p.add('%')
+	p.add('!')
+	p.add(verb)
+	p.add('(')
+	if val == nil {
+		p.buf.Write(nilAngleBytes)
+	} else {
+		p.buf.WriteString(reflect.Typeof(val).String())
+		p.add('=')
+		p.printField(val, 'v', false, false, 0)
+	}
+	p.add(')')
+}
+
+func (p *pp) fmtBool(v bool, verb int, value interface{}) {
+	switch verb {
+	case 't', 'v':
+		p.fmt.fmt_boolean(v)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+// fmtC formats a rune for the 'c' format.
+func (p *pp) fmtC(c int64) {
+	rune := int(c) // Check for overflow.
+	if int64(rune) != c {
+		rune = utf8.RuneError
+	}
+	w := utf8.EncodeRune(rune, p.runeBuf[0:utf8.UTFMax])
+	p.fmt.pad(p.runeBuf[0:w])
+}
+
+func (p *pp) fmtInt64(v int64, verb int, value interface{}) {
+	switch verb {
+	case 'b':
+		p.fmt.integer(v, 2, signed, ldigits)
+	case 'c':
+		p.fmtC(v)
+	case 'd', 'v':
+		p.fmt.integer(v, 10, signed, ldigits)
+	case 'o':
+		p.fmt.integer(v, 8, signed, ldigits)
+	case 'x':
+		p.fmt.integer(v, 16, signed, ldigits)
+	case 'X':
+		p.fmt.integer(v, 16, signed, udigits)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+// fmt_sharpHex64 formats a uint64 in hexadecimal and prefixes it with 0x by
+// temporarily turning on the sharp flag.
+func (p *pp) fmt0x64(v uint64) {
+	sharp := p.fmt.sharp
+	p.fmt.sharp = true // turn on 0x
+	p.fmt.integer(int64(v), 16, unsigned, ldigits)
+	p.fmt.sharp = sharp
+}
+
+func (p *pp) fmtUint64(v uint64, verb int, goSyntax bool, value interface{}) {
+	switch verb {
+	case 'b':
+		p.fmt.integer(int64(v), 2, unsigned, ldigits)
+	case 'c':
+		p.fmtC(int64(v))
+	case 'd':
+		p.fmt.integer(int64(v), 10, unsigned, ldigits)
+	case 'v':
+		if goSyntax {
+			p.fmt0x64(v)
+		} else {
+			p.fmt.integer(int64(v), 10, unsigned, ldigits)
+		}
+	case 'o':
+		p.fmt.integer(int64(v), 8, unsigned, ldigits)
+	case 'x':
+		p.fmt.integer(int64(v), 16, unsigned, ldigits)
+	case 'X':
+		p.fmt.integer(int64(v), 16, unsigned, udigits)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtFloat32(v float32, verb int, value interface{}) {
+	switch verb {
+	case 'b':
+		p.fmt.fmt_fb32(v)
+	case 'e':
+		p.fmt.fmt_e32(v)
+	case 'E':
+		p.fmt.fmt_E32(v)
+	case 'f':
+		p.fmt.fmt_f32(v)
+	case 'g', 'v':
+		p.fmt.fmt_g32(v)
+	case 'G':
+		p.fmt.fmt_G32(v)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtFloat64(v float64, verb int, value interface{}) {
+	switch verb {
+	case 'b':
+		p.fmt.fmt_fb64(v)
+	case 'e':
+		p.fmt.fmt_e64(v)
+	case 'E':
+		p.fmt.fmt_E64(v)
+	case 'f':
+		p.fmt.fmt_f64(v)
+	case 'g', 'v':
+		p.fmt.fmt_g64(v)
+	case 'G':
+		p.fmt.fmt_G64(v)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtComplex64(v complex64, verb int, value interface{}) {
+	switch verb {
+	case 'e', 'E', 'f', 'F', 'g', 'G':
+		p.fmt.fmt_c64(v, verb)
+	case 'v':
+		p.fmt.fmt_c64(v, 'g')
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtComplex128(v complex128, verb int, value interface{}) {
+	switch verb {
+	case 'e', 'E', 'f', 'F', 'g', 'G':
+		p.fmt.fmt_c128(v, verb)
+	case 'v':
+		p.fmt.fmt_c128(v, 'g')
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtString(v string, verb int, goSyntax bool, value interface{}) {
+	switch verb {
+	case 'v':
+		if goSyntax {
+			p.fmt.fmt_q(v)
+		} else {
+			p.fmt.fmt_s(v)
+		}
+	case 's':
+		p.fmt.fmt_s(v)
+	case 'x':
+		p.fmt.fmt_sx(v)
+	case 'X':
+		p.fmt.fmt_sX(v)
+	case 'q':
+		p.fmt.fmt_q(v)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtBytes(v []byte, verb int, goSyntax bool, depth int, value interface{}) {
+	if verb == 'v' || verb == 'd' {
+		if goSyntax {
+			p.buf.Write(bytesBytes)
+		} else {
+			p.buf.WriteByte('[')
+		}
+		for i, c := range v {
+			if i > 0 {
+				if goSyntax {
+					p.buf.Write(commaSpaceBytes)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			p.printField(c, 'v', p.fmt.plus, goSyntax, depth+1)
+		}
+		if goSyntax {
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte(']')
+		}
+		return
+	}
+	s := string(v)
+	switch verb {
+	case 's':
+		p.fmt.fmt_s(s)
+	case 'x':
+		p.fmt.fmt_sx(s)
+	case 'X':
+		p.fmt.fmt_sX(s)
+	case 'q':
+		p.fmt.fmt_q(s)
+	default:
+		p.badVerb(verb, value)
+	}
+}
+
+func (p *pp) fmtPointer(field interface{}, value reflect.Value, verb int, goSyntax bool) {
+	v, ok := value.(uintptrGetter)
+	if !ok { // reflect.PtrValue is a uintptrGetter, so failure means it's not a pointer at all.
+		p.badVerb(verb, field)
+		return
+	}
+	u := v.Get()
+	if goSyntax {
+		p.add('(')
+		p.buf.WriteString(reflect.Typeof(field).String())
+		p.add(')')
+		p.add('(')
+		if u == 0 {
+			p.buf.Write(nilBytes)
+		} else {
+			p.fmt0x64(uint64(v.Get()))
+		}
+		p.add(')')
+	} else {
+		p.fmt0x64(uint64(u))
+	}
+}
+
+var (
+	intBits     = reflect.Typeof(0).Bits()
+	floatBits   = reflect.Typeof(0.0).Bits()
+	complexBits = reflect.Typeof(1i).Bits()
+	uintptrBits = reflect.Typeof(uintptr(0)).Bits()
+)
+
+func (p *pp) printField(field interface{}, verb int, plus, goSyntax bool, depth int) (wasString bool) {
+	if field == nil {
+		if verb == 'T' || verb == 'v' {
+			p.buf.Write(nilAngleBytes)
+		} else {
+			p.badVerb(verb, field)
+		}
+		return false
+	}
+
+	// Special processing considerations.
+	// %T (the value's type) and %p (its address) are special; we always do them first.
+	switch verb {
+	case 'T':
+		p.printField(reflect.Typeof(field).String(), 's', false, false, 0)
+		return false
+	case 'p':
+		p.fmtPointer(field, reflect.NewValue(field), verb, goSyntax)
+		return false
+	}
+	// Is it a Formatter?
+	if formatter, ok := field.(Formatter); ok {
+		formatter.Format(p, verb)
+		return false // this value is not a string
+
+	}
+	// Must not touch flags before Formatter looks at them.
+	if plus {
+		p.fmt.plus = false
+	}
+	// If we're doing Go syntax and the field knows how to supply it, take care of it now.
+	if goSyntax {
+		p.fmt.sharp = false
+		if stringer, ok := field.(GoStringer); ok {
+			// Print the result of GoString unadorned.
+			p.fmtString(stringer.GoString(), 's', false, field)
+			return false // this value is not a string
+		}
+	} else {
+		// Is it a Stringer?
+		if stringer, ok := field.(Stringer); ok {
+			p.printField(stringer.String(), verb, plus, false, depth)
+			return false // this value is not a string
+		}
+	}
+
+	// Some types can be done without reflection.
+	switch f := field.(type) {
+	case bool:
+		p.fmtBool(f, verb, field)
+		return false
+	case float:
+		if floatBits == 32 {
+			p.fmtFloat32(float32(f), verb, field)
+		} else {
+			p.fmtFloat64(float64(f), verb, field)
+		}
+		return false
+	case float32:
+		p.fmtFloat32(f, verb, field)
+		return false
+	case float64:
+		p.fmtFloat64(f, verb, field)
+		return false
+	case complex:
+		if complexBits == 64 {
+			p.fmtComplex64(complex64(f), verb, field)
+		} else {
+			p.fmtComplex128(complex128(f), verb, field)
+		}
+		return false
+	case complex64:
+		p.fmtComplex64(complex64(f), verb, field)
+		return false
+	case complex128:
+		p.fmtComplex128(f, verb, field)
+		return false
+	case int:
+		p.fmtInt64(int64(f), verb, field)
+		return false
+	case int8:
+		p.fmtInt64(int64(f), verb, field)
+		return false
+	case int16:
+		p.fmtInt64(int64(f), verb, field)
+		return false
+	case int32:
+		p.fmtInt64(int64(f), verb, field)
+		return false
+	case int64:
+		p.fmtInt64(f, verb, field)
+		return false
+	case uint:
+		p.fmtUint64(uint64(f), verb, goSyntax, field)
+		return false
+	case uint8:
+		p.fmtUint64(uint64(f), verb, goSyntax, field)
+		return false
+	case uint16:
+		p.fmtUint64(uint64(f), verb, goSyntax, field)
+		return false
+	case uint32:
+		p.fmtUint64(uint64(f), verb, goSyntax, field)
+		return false
+	case uint64:
+		p.fmtUint64(f, verb, goSyntax, field)
+		return false
+	case uintptr:
+		p.fmtUint64(uint64(f), verb, goSyntax, field)
+		return false
+	case string:
+		p.fmtString(f, verb, goSyntax, field)
+		return verb == 's' || verb == 'v'
+	case []byte:
+		p.fmtBytes(f, verb, goSyntax, depth, field)
+		return verb == 's'
+	}
+
+	// Need to use reflection
+	value := reflect.NewValue(field)
+
+BigSwitch:
+	switch f := value.(type) {
+	case *reflect.BoolValue:
+		p.fmtBool(f.Get(), verb, field)
+	case *reflect.IntValue:
+		p.fmtInt64(f.Get(), verb, field)
+	case *reflect.UintValue:
+		p.fmtUint64(uint64(f.Get()), verb, goSyntax, field)
+	case *reflect.FloatValue:
+		if f.Type().Size() == 4 {
+			p.fmtFloat32(float32(f.Get()), verb, field)
+		} else {
+			p.fmtFloat64(float64(f.Get()), verb, field)
+		}
+	case *reflect.ComplexValue:
+		if f.Type().Size() == 8 {
+			p.fmtComplex64(complex64(f.Get()), verb, field)
+		} else {
+			p.fmtComplex128(complex128(f.Get()), verb, field)
+		}
+	case *reflect.StringValue:
+		p.fmtString(f.Get(), verb, goSyntax, field)
+	case *reflect.MapValue:
+		if goSyntax {
+			p.buf.WriteString(f.Type().String())
+			p.buf.WriteByte('{')
+		} else {
+			p.buf.Write(mapBytes)
+		}
+		keys := f.Keys()
+		for i, key := range keys {
+			if i > 0 {
+				if goSyntax {
+					p.buf.Write(commaSpaceBytes)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			p.printField(key.Interface(), verb, plus, goSyntax, depth+1)
+			p.buf.WriteByte(':')
+			p.printField(f.Elem(key).Interface(), verb, plus, goSyntax, depth+1)
+		}
+		if goSyntax {
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte(']')
+		}
+	case *reflect.StructValue:
+		if goSyntax {
+			p.buf.WriteString(reflect.Typeof(field).String())
+		}
+		p.add('{')
+		v := f
+		t := v.Type().(*reflect.StructType)
+		for i := 0; i < v.NumField(); i++ {
+			if i > 0 {
+				if goSyntax {
+					p.buf.Write(commaSpaceBytes)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			if plus || goSyntax {
+				if f := t.Field(i); f.Name != "" {
+					p.buf.WriteString(f.Name)
+					p.buf.WriteByte(':')
+				}
+			}
+			p.printField(getField(v, i).Interface(), verb, plus, goSyntax, depth+1)
+		}
+		p.buf.WriteByte('}')
+	case *reflect.InterfaceValue:
+		value := f.Elem()
+		if value == nil {
+			if goSyntax {
+				p.buf.WriteString(reflect.Typeof(field).String())
+				p.buf.Write(nilParenBytes)
+			} else {
+				p.buf.Write(nilAngleBytes)
+			}
+		} else {
+			return p.printField(value.Interface(), verb, plus, goSyntax, depth+1)
+		}
+	case reflect.ArrayOrSliceValue:
+		// Byte slices are special.
+		if f.Type().(reflect.ArrayOrSliceType).Elem().Kind() == reflect.Uint8 {
+			// We know it's a slice of bytes, but we also know it does not have static type
+			// []byte, or it would have been caught above.  Therefore we cannot convert
+			// it directly in the (slightly) obvious way: f.Interface().([]byte); it doesn't have
+			// that type, and we can't write an expression of the right type and do a
+			// conversion because we don't have a static way to write the right type.
+			// So we build a slice by hand.  This is a rare case but it would be nice
+			// if reflection could help a little more.
+			bytes := make([]byte, f.Len())
+			for i := range bytes {
+				bytes[i] = byte(f.Elem(i).(*reflect.UintValue).Get())
+			}
+			p.fmtBytes(bytes, verb, goSyntax, depth, field)
+			return verb == 's'
+		}
+		if goSyntax {
+			p.buf.WriteString(reflect.Typeof(field).String())
+			p.buf.WriteByte('{')
+		} else {
+			p.buf.WriteByte('[')
+		}
+		for i := 0; i < f.Len(); i++ {
+			if i > 0 {
+				if goSyntax {
+					p.buf.Write(commaSpaceBytes)
+				} else {
+					p.buf.WriteByte(' ')
+				}
+			}
+			p.printField(f.Elem(i).Interface(), verb, plus, goSyntax, depth+1)
+		}
+		if goSyntax {
+			p.buf.WriteByte('}')
+		} else {
+			p.buf.WriteByte(']')
+		}
+	case *reflect.PtrValue:
+		v := f.Get()
+		// pointer to array or slice or struct?  ok at top level
+		// but not embedded (avoid loops)
+		if v != 0 && depth == 0 {
+			switch a := f.Elem().(type) {
+			case reflect.ArrayOrSliceValue:
+				p.buf.WriteByte('&')
+				p.printField(a.Interface(), verb, plus, goSyntax, depth+1)
+				break BigSwitch
+			case *reflect.StructValue:
+				p.buf.WriteByte('&')
+				p.printField(a.Interface(), verb, plus, goSyntax, depth+1)
+				break BigSwitch
+			}
+		}
+		if goSyntax {
+			p.buf.WriteByte('(')
+			p.buf.WriteString(reflect.Typeof(field).String())
+			p.buf.WriteByte(')')
+			p.buf.WriteByte('(')
+			if v == 0 {
+				p.buf.Write(nilBytes)
+			} else {
+				p.fmt0x64(uint64(v))
+			}
+			p.buf.WriteByte(')')
+			break
+		}
+		if v == 0 {
+			p.buf.Write(nilAngleBytes)
+			break
+		}
+		p.fmt0x64(uint64(v))
+	case uintptrGetter:
+		p.fmtPointer(field, value, verb, goSyntax)
+	default:
+		p.unknownType(f)
+	}
+	return false
+}
+
+// intFromArg gets the fieldnumth element of a. On return, isInt reports whether the argument has type int.
+func intFromArg(a []interface{}, end, i, fieldnum int) (num int, isInt bool, newi, newfieldnum int) {
+	newi, newfieldnum = end, fieldnum
+	if i < end && fieldnum < len(a) {
+		num, isInt = a[fieldnum].(int)
+		newi, newfieldnum = i+1, fieldnum+1
+	}
+	return
+}
+
+func (p *pp) doPrintf(format string, a []interface{}) {
+	end := len(format) - 1
+	fieldnum := 0 // we process one field per non-trivial format
+	for i := 0; i <= end; {
+		c, w := utf8.DecodeRuneInString(format[i:])
+		if c != '%' || i == end {
+			if w == 1 {
+				p.buf.WriteByte(byte(c))
+			} else {
+				p.buf.WriteString(format[i : i+w])
+			}
+			i += w
+			continue
+		}
+		i++
+		// flags and widths
+		p.fmt.clearflags()
+	F:
+		for ; i < end; i++ {
+			switch format[i] {
+			case '#':
+				p.fmt.sharp = true
+			case '0':
+				p.fmt.zero = true
+			case '+':
+				p.fmt.plus = true
+			case '-':
+				p.fmt.minus = true
+			case ' ':
+				p.fmt.space = true
+			default:
+				break F
+			}
+		}
+		// do we have width?
+		if format[i] == '*' {
+			p.fmt.wid, p.fmt.widPresent, i, fieldnum = intFromArg(a, end, i, fieldnum)
+			if !p.fmt.widPresent {
+				p.buf.Write(widthBytes)
+			}
+		} else {
+			p.fmt.wid, p.fmt.widPresent, i = parsenum(format, i, end)
+		}
+		// do we have precision?
+		if i < end && format[i] == '.' {
+			if format[i+1] == '*' {
+				p.fmt.prec, p.fmt.precPresent, i, fieldnum = intFromArg(a, end, i+1, fieldnum)
+				if !p.fmt.precPresent {
+					p.buf.Write(precBytes)
+				}
+			} else {
+				p.fmt.prec, p.fmt.precPresent, i = parsenum(format, i+1, end)
+			}
+		}
+		c, w = utf8.DecodeRuneInString(format[i:])
+		i += w
+		// percent is special - absorbs no operand
+		if c == '%' {
+			p.buf.WriteByte('%') // We ignore width and prec.
+			continue
+		}
+		if fieldnum >= len(a) { // out of operands
+			p.buf.WriteByte('%')
+			p.add(c)
+			p.buf.Write(missingBytes)
+			continue
+		}
+		field := a[fieldnum]
+		fieldnum++
+
+		goSyntax := c == 'v' && p.fmt.sharp
+		plus := c == 'v' && p.fmt.plus
+		p.printField(field, c, plus, goSyntax, 0)
+	}
+
+	if fieldnum < len(a) {
+		p.buf.Write(extraBytes)
+		for ; fieldnum < len(a); fieldnum++ {
+			field := a[fieldnum]
+			if field != nil {
+				p.buf.WriteString(reflect.Typeof(field).String())
+				p.buf.WriteByte('=')
+			}
+			p.printField(field, 'v', false, false, 0)
+			if fieldnum+1 < len(a) {
+				p.buf.Write(commaSpaceBytes)
+			}
+		}
+		p.buf.WriteByte(')')
+	}
+}
+
+func (p *pp) doPrint(a []interface{}, addspace, addnewline bool) {
+	prevString := false
+	for fieldnum := 0; fieldnum < len(a); fieldnum++ {
+		p.fmt.clearflags()
+		// always add spaces if we're doing println
+		field := a[fieldnum]
+		if fieldnum > 0 {
+			isString := field != nil && reflect.Typeof(field).Kind() == reflect.String
+			if addspace || !isString && !prevString {
+				p.buf.WriteByte(' ')
+			}
+		}
+		prevString = p.printField(field, 'v', false, false, 0)
+	}
+	if addnewline {
+		p.buf.WriteByte('\n')
+	}
+}
diff --git a/libgo/go/fmt/scan.go b/libgo/go/fmt/scan.go
new file mode 100644
index 0000000..41a12d9
--- /dev/null
+++ b/libgo/go/fmt/scan.go
@@ -0,0 +1,965 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"unicode"
+	"utf8"
+)
+
+// readRuner is the interface to something that can read runes.  If
+// the object provided to Scan does not satisfy this interface, the
+// object will be wrapped by a readRune object.
+type readRuner interface {
+	ReadRune() (rune int, size int, err os.Error)
+}
+
+// unreadRuner is the interface to something that can unread runes.
+// If the object provided to Scan does not satisfy this interface,
+// a local buffer will be used to back up the input, but its contents
+// will be lost when Scan returns.
+type unreadRuner interface {
+	UnreadRune() os.Error
+}
+
+// ScanState represents the scanner state passed to custom scanners.
+// Scanners may do rune-at-a-time scanning or ask the ScanState
+// to discover the next space-delimited token.
+type ScanState interface {
+	// GetRune reads the next rune (Unicode code point) from the input.
+	GetRune() (rune int, err os.Error)
+	// UngetRune causes the next call to GetRune to return the rune.
+	UngetRune()
+	// Width returns the value of the width option and whether it has been set.
+	// The unit is Unicode code points.
+	Width() (wid int, ok bool)
+	// Token returns the next space-delimited token from the input. If
+	// a width has been specified, the returned token will be no longer
+	// than the width.
+	Token() (token string, err os.Error)
+}
+
+// Scanner is implemented by any value that has a Scan method, which scans
+// the input for the representation of a value and stores the result in the
+// receiver, which must be a pointer to be useful.  The Scan method is called
+// for any argument to Scan or Scanln that implements it.
+type Scanner interface {
+	Scan(state ScanState, verb int) os.Error
+}
+
+// Scan scans text read from standard input, storing successive
+// space-separated values into successive arguments.  Newlines count
+// as space.  It returns the number of items successfully scanned.
+// If that is less than the number of arguments, err will report why.
+func Scan(a ...interface{}) (n int, err os.Error) {
+	return Fscan(os.Stdin, a...)
+}
+
+// Scanln is similar to Scan, but stops scanning at a newline and
+// after the final item there must be a newline or EOF.
+func Scanln(a ...interface{}) (n int, err os.Error) {
+	return Fscanln(os.Stdin, a...)
+}
+
+// Scanf scans text read from standard input, storing successive
+// space-separated values into successive arguments as determined by
+// the format.  It returns the number of items successfully scanned.
+func Scanf(format string, a ...interface{}) (n int, err os.Error) {
+	return Fscanf(os.Stdin, format, a...)
+}
+
+// Sscan scans the argument string, storing successive space-separated
+// values into successive arguments.  Newlines count as space.  It
+// returns the number of items successfully scanned.  If that is less
+// than the number of arguments, err will report why.
+func Sscan(str string, a ...interface{}) (n int, err os.Error) {
+	return Fscan(strings.NewReader(str), a...)
+}
+
+// Sscanln is similar to Sscan, but stops scanning at a newline and
+// after the final item there must be a newline or EOF.
+func Sscanln(str string, a ...interface{}) (n int, err os.Error) {
+	return Fscanln(strings.NewReader(str), a...)
+}
+
+// Sscanf scans the argument string, storing successive space-separated
+// values into successive arguments as determined by the format.  It
+// returns the number of items successfully parsed.
+func Sscanf(str string, format string, a ...interface{}) (n int, err os.Error) {
+	return Fscanf(strings.NewReader(str), format, a...)
+}
+
+// Fscan scans text read from r, storing successive space-separated
+// values into successive arguments.  Newlines count as space.  It
+// returns the number of items successfully scanned.  If that is less
+// than the number of arguments, err will report why.
+func Fscan(r io.Reader, a ...interface{}) (n int, err os.Error) {
+	s := newScanState(r, true)
+	n, err = s.doScan(a)
+	s.free()
+	return
+}
+
+// Fscanln is similar to Fscan, but stops scanning at a newline and
+// after the final item there must be a newline or EOF.
+func Fscanln(r io.Reader, a ...interface{}) (n int, err os.Error) {
+	s := newScanState(r, false)
+	n, err = s.doScan(a)
+	s.free()
+	return
+}
+
+// Fscanf scans text read from r, storing successive space-separated
+// values into successive arguments as determined by the format.  It
+// returns the number of items successfully parsed.
+func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err os.Error) {
+	s := newScanState(r, false)
+	n, err = s.doScanf(format, a)
+	s.free()
+	return
+}
+
+// scanError represents an error generated by the scanning software.
+// It's used as a unique signature to identify such errors when recovering.
+type scanError struct {
+	err os.Error
+}
+
+const EOF = -1
+
+// ss is the internal implementation of ScanState.
+type ss struct {
+	rr         readRuner    // where to read input
+	buf        bytes.Buffer // token accumulator
+	nlIsSpace  bool         // whether newline counts as white space
+	peekRune   int          // one-rune lookahead
+	prevRune   int          // last rune returned by GetRune
+	atEOF      bool         // already read EOF
+	maxWid     int          // max width of field, in runes
+	widPresent bool         // width was specified
+	wid        int          // width consumed so far; used in accept()
+}
+
+func (s *ss) GetRune() (rune int, err os.Error) {
+	if s.peekRune >= 0 {
+		rune = s.peekRune
+		s.prevRune = rune
+		s.peekRune = -1
+		return
+	}
+	rune, _, err = s.rr.ReadRune()
+	if err == nil {
+		s.prevRune = rune
+	}
+	return
+}
+
+func (s *ss) Width() (wid int, ok bool) {
+	return s.maxWid, s.widPresent
+}
+
+// The public method returns an error; this private one panics.
+// If getRune reaches EOF, the return value is EOF (-1).
+func (s *ss) getRune() (rune int) {
+	if s.atEOF {
+		return EOF
+	}
+	if s.peekRune >= 0 {
+		rune = s.peekRune
+		s.prevRune = rune
+		s.peekRune = -1
+		return
+	}
+	rune, _, err := s.rr.ReadRune()
+	if err == nil {
+		s.prevRune = rune
+	} else if err != nil {
+		if err == os.EOF {
+			s.atEOF = true
+			return EOF
+		}
+		s.error(err)
+	}
+	return
+}
+
+// mustGetRune turns os.EOF into a panic(io.ErrUnexpectedEOF).
+// It is called in cases such as string scanning where an EOF is a
+// syntax error.
+func (s *ss) mustGetRune() (rune int) {
+	if s.atEOF {
+		s.error(io.ErrUnexpectedEOF)
+	}
+	if s.peekRune >= 0 {
+		rune = s.peekRune
+		s.peekRune = -1
+		return
+	}
+	rune, _, err := s.rr.ReadRune()
+	if err != nil {
+		if err == os.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+		s.error(err)
+	}
+	return
+}
+
+
+func (s *ss) UngetRune() {
+	if u, ok := s.rr.(unreadRuner); ok {
+		u.UnreadRune()
+	} else {
+		s.peekRune = s.prevRune
+	}
+}
+
+func (s *ss) error(err os.Error) {
+	panic(scanError{err})
+}
+
+func (s *ss) errorString(err string) {
+	panic(scanError{os.ErrorString(err)})
+}
+
+func (s *ss) Token() (tok string, err os.Error) {
+	defer func() {
+		if e := recover(); e != nil {
+			if se, ok := e.(scanError); ok {
+				err = se.err
+			} else {
+				panic(e)
+			}
+		}
+	}()
+	tok = s.token()
+	return
+}
+
+// readRune is a structure to enable reading UTF-8 encoded code points
+// from an io.Reader.  It is used if the Reader given to the scanner does
+// not already implement ReadRuner.
+type readRune struct {
+	reader  io.Reader
+	buf     [utf8.UTFMax]byte // used only inside ReadRune
+	pending int               // number of bytes in pendBuf; only >0 for bad UTF-8
+	pendBuf [utf8.UTFMax]byte // bytes left over
+}
+
+// readByte returns the next byte from the input, which may be
+// left over from a previous read if the UTF-8 was ill-formed.
+func (r *readRune) readByte() (b byte, err os.Error) {
+	if r.pending > 0 {
+		b = r.pendBuf[0]
+		copy(r.pendBuf[0:], r.pendBuf[1:])
+		r.pending--
+		return
+	}
+	_, err = r.reader.Read(r.pendBuf[0:1])
+	return r.pendBuf[0], err
+}
+
+// unread saves the bytes for the next read.
+func (r *readRune) unread(buf []byte) {
+	copy(r.pendBuf[r.pending:], buf)
+	r.pending += len(buf)
+}
+
+// ReadRune returns the next UTF-8 encoded code point from the
+// io.Reader inside r.
+func (r *readRune) ReadRune() (rune int, size int, err os.Error) {
+	r.buf[0], err = r.readByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	if r.buf[0] < utf8.RuneSelf { // fast check for common ASCII case
+		rune = int(r.buf[0])
+		return
+	}
+	var n int
+	for n = 1; !utf8.FullRune(r.buf[0:n]); n++ {
+		r.buf[n], err = r.readByte()
+		if err != nil {
+			if err == os.EOF {
+				err = nil
+				break
+			}
+			return
+		}
+	}
+	rune, size = utf8.DecodeRune(r.buf[0:n])
+	if size < n { // an error
+		r.unread(r.buf[size:n])
+	}
+	return
+}
+
+
+// A leaky bucket of reusable ss structures.
+var ssFree = make(chan *ss, 100)
+
+// Allocate a new ss struct.  Probably can grab the previous one from ssFree.
+func newScanState(r io.Reader, nlIsSpace bool) *ss {
+	s, ok := <-ssFree
+	if !ok {
+		s = new(ss)
+	}
+	if rr, ok := r.(readRuner); ok {
+		s.rr = rr
+	} else {
+		s.rr = &readRune{reader: r}
+	}
+	s.nlIsSpace = nlIsSpace
+	s.peekRune = -1
+	s.atEOF = false
+	s.maxWid = 0
+	s.widPresent = false
+	return s
+}
+
+// Save used ss structs in ssFree; avoid an allocation per invocation.
+func (s *ss) free() {
+	// Don't hold on to ss structs with large buffers.
+	if cap(s.buf.Bytes()) > 1024 {
+		return
+	}
+	s.buf.Reset()
+	s.rr = nil
+	_ = ssFree <- s
+}
+
+// skipSpace skips spaces and maybe newlines.
+func (s *ss) skipSpace(stopAtNewline bool) {
+	for {
+		rune := s.getRune()
+		if rune == EOF {
+			return
+		}
+		if rune == '\n' {
+			if stopAtNewline {
+				break
+			}
+			if s.nlIsSpace {
+				continue
+			}
+			s.errorString("unexpected newline")
+			return
+		}
+		if !unicode.IsSpace(rune) {
+			s.UngetRune()
+			break
+		}
+	}
+}
+
+// token returns the next space-delimited string from the input.  It
+// skips white space.  For Scanln, it stops at newlines.  For Scan,
+// newlines are treated as spaces.
+func (s *ss) token() string {
+	s.skipSpace(false)
+	// read until white space or newline
+	for nrunes := 0; !s.widPresent || nrunes < s.maxWid; nrunes++ {
+		rune := s.getRune()
+		if rune == EOF {
+			break
+		}
+		if unicode.IsSpace(rune) {
+			s.UngetRune()
+			break
+		}
+		s.buf.WriteRune(rune)
+	}
+	return s.buf.String()
+}
+
+// typeError indicates that the type of the operand did not match the format
+func (s *ss) typeError(field interface{}, expected string) {
+	s.errorString("expected field of type pointer to " + expected + "; found " + reflect.Typeof(field).String())
+}
+
+var complexError = os.ErrorString("syntax error scanning complex number")
+var boolError = os.ErrorString("syntax error scanning boolean")
+
+// accepts checks the next rune in the input.  If it's a byte (sic) in the string, it puts it in the
+// buffer and returns true. Otherwise it return false.
+func (s *ss) accept(ok string) bool {
+	if s.wid >= s.maxWid {
+		return false
+	}
+	rune := s.getRune()
+	if rune == EOF {
+		return false
+	}
+	for i := 0; i < len(ok); i++ {
+		if int(ok[i]) == rune {
+			s.buf.WriteRune(rune)
+			s.wid++
+			return true
+		}
+	}
+	if rune != EOF {
+		s.UngetRune()
+	}
+	return false
+}
+
+// okVerb verifies that the verb is present in the list, setting s.err appropriately if not.
+func (s *ss) okVerb(verb int, okVerbs, typ string) bool {
+	for _, v := range okVerbs {
+		if v == verb {
+			return true
+		}
+	}
+	s.errorString("bad verb %" + string(verb) + " for " + typ)
+	return false
+}
+
+// scanBool returns the value of the boolean represented by the next token.
+func (s *ss) scanBool(verb int) bool {
+	if !s.okVerb(verb, "tv", "boolean") {
+		return false
+	}
+	// Syntax-checking a boolean is annoying.  We're not fastidious about case.
+	switch s.mustGetRune() {
+	case '0':
+		return false
+	case '1':
+		return true
+	case 't', 'T':
+		if s.accept("rR") && (!s.accept("uU") || !s.accept("eE")) {
+			s.error(boolError)
+		}
+		return true
+	case 'f', 'F':
+		if s.accept("aL") && (!s.accept("lL") || !s.accept("sS") || !s.accept("eE")) {
+			s.error(boolError)
+		}
+		return false
+	}
+	return false
+}
+
+// Numerical elements
+const (
+	binaryDigits      = "01"
+	octalDigits       = "01234567"
+	decimalDigits     = "0123456789"
+	hexadecimalDigits = "0123456789aAbBcCdDeEfF"
+	sign              = "+-"
+	period            = "."
+	exponent          = "eE"
+)
+
+// getBase returns the numeric base represented by the verb and its digit string.
+func (s *ss) getBase(verb int) (base int, digits string) {
+	s.okVerb(verb, "bdoxXv", "integer") // sets s.err
+	base = 10
+	digits = decimalDigits
+	switch verb {
+	case 'b':
+		base = 2
+		digits = binaryDigits
+	case 'o':
+		base = 8
+		digits = octalDigits
+	case 'x', 'X':
+		base = 16
+		digits = hexadecimalDigits
+	}
+	return
+}
+
+// scanNumber returns the numerical string with specified digits starting here.
+func (s *ss) scanNumber(digits string) string {
+	if !s.accept(digits) {
+		s.errorString("expected integer")
+	}
+	for s.accept(digits) {
+	}
+	return s.buf.String()
+}
+
+// scanRune returns the next rune value in the input.
+func (s *ss) scanRune(bitSize int) int64 {
+	rune := int64(s.mustGetRune())
+	n := uint(bitSize)
+	x := (rune << (64 - n)) >> (64 - n)
+	if x != rune {
+		s.errorString("overflow on character value " + string(rune))
+	}
+	return rune
+}
+
+// scanInt returns the value of the integer represented by the next
+// token, checking for overflow.  Any error is stored in s.err.
+func (s *ss) scanInt(verb int, bitSize int) int64 {
+	if verb == 'c' {
+		return s.scanRune(bitSize)
+	}
+	base, digits := s.getBase(verb)
+	s.skipSpace(false)
+	s.accept(sign) // If there's a sign, it will be left in the token buffer.
+	tok := s.scanNumber(digits)
+	i, err := strconv.Btoi64(tok, base)
+	if err != nil {
+		s.error(err)
+	}
+	n := uint(bitSize)
+	x := (i << (64 - n)) >> (64 - n)
+	if x != i {
+		s.errorString("integer overflow on token " + tok)
+	}
+	return i
+}
+
+// scanUint returns the value of the unsigned integer represented
+// by the next token, checking for overflow.  Any error is stored in s.err.
+func (s *ss) scanUint(verb int, bitSize int) uint64 {
+	if verb == 'c' {
+		return uint64(s.scanRune(bitSize))
+	}
+	base, digits := s.getBase(verb)
+	s.skipSpace(false)
+	tok := s.scanNumber(digits)
+	i, err := strconv.Btoui64(tok, base)
+	if err != nil {
+		s.error(err)
+	}
+	n := uint(bitSize)
+	x := (i << (64 - n)) >> (64 - n)
+	if x != i {
+		s.errorString("unsigned integer overflow on token " + tok)
+	}
+	return i
+}
+
+// floatToken returns the floating-point number starting here, no longer than swid
+// if the width is specified. It's not rigorous about syntax because it doesn't check that
+// we have at least some digits, but Atof will do that.
+func (s *ss) floatToken() string {
+	s.buf.Reset()
+	// leading sign?
+	s.accept(sign)
+	// digits?
+	for s.accept(decimalDigits) {
+	}
+	// decimal point?
+	if s.accept(period) {
+		// fraction?
+		for s.accept(decimalDigits) {
+		}
+	}
+	// exponent?
+	if s.accept(exponent) {
+		// leading sign?
+		s.accept(sign)
+		// digits?
+		for s.accept(decimalDigits) {
+		}
+	}
+	return s.buf.String()
+}
+
+// complexTokens returns the real and imaginary parts of the complex number starting here.
+// The number might be parenthesized and has the format (N+Ni) where N is a floating-point
+// number and there are no spaces within.
+func (s *ss) complexTokens() (real, imag string) {
+	// TODO: accept N and Ni independently?
+	parens := s.accept("(")
+	real = s.floatToken()
+	s.buf.Reset()
+	// Must now have a sign.
+	if !s.accept("+-") {
+		s.error(complexError)
+	}
+	// Sign is now in buffer
+	imagSign := s.buf.String()
+	imag = s.floatToken()
+	if !s.accept("i") {
+		s.error(complexError)
+	}
+	if parens && !s.accept(")") {
+		s.error(complexError)
+	}
+	return real, imagSign + imag
+}
+
+// convertFloat converts the string to a float64value.
+func (s *ss) convertFloat(str string, n int) float64 {
+	f, err := strconv.AtofN(str, n)
+	if err != nil {
+		s.error(err)
+	}
+	return f
+}
+
+// convertComplex converts the next token to a complex128 value.
+// The atof argument is a type-specific reader for the underlying type.
+// If we're reading complex64, atof will parse float32s and convert them
+// to float64's to avoid reproducing this code for each complex type.
+func (s *ss) scanComplex(verb int, n int) complex128 {
+	if !s.okVerb(verb, floatVerbs, "complex") {
+		return 0
+	}
+	s.skipSpace(false)
+	sreal, simag := s.complexTokens()
+	real := s.convertFloat(sreal, n/2)
+	imag := s.convertFloat(simag, n/2)
+	return cmplx(real, imag)
+}
+
+// convertString returns the string represented by the next input characters.
+// The format of the input is determined by the verb.
+func (s *ss) convertString(verb int) (str string) {
+	if !s.okVerb(verb, "svqx", "string") {
+		return ""
+	}
+	s.skipSpace(false)
+	switch verb {
+	case 'q':
+		str = s.quotedString()
+	case 'x':
+		str = s.hexString()
+	default:
+		str = s.token() // %s and %v just return the next word
+	}
+	// Empty strings other than with %q are not OK.
+	if len(str) == 0 && verb != 'q' && s.maxWid > 0 {
+		s.errorString("Scan: no data for string")
+	}
+	return
+}
+
+// quotedString returns the double- or back-quoted string represented by the next input characters.
+func (s *ss) quotedString() string {
+	quote := s.mustGetRune()
+	switch quote {
+	case '`':
+		// Back-quoted: Anything goes until EOF or back quote.
+		for {
+			rune := s.mustGetRune()
+			if rune == quote {
+				break
+			}
+			s.buf.WriteRune(rune)
+		}
+		return s.buf.String()
+	case '"':
+		// Double-quoted: Include the quotes and let strconv.Unquote do the backslash escapes.
+		s.buf.WriteRune(quote)
+		for {
+			rune := s.mustGetRune()
+			s.buf.WriteRune(rune)
+			if rune == '\\' {
+				// In a legal backslash escape, no matter how long, only the character
+				// immediately after the escape can itself be a backslash or quote.
+				// Thus we only need to protect the first character after the backslash.
+				rune := s.mustGetRune()
+				s.buf.WriteRune(rune)
+			} else if rune == '"' {
+				break
+			}
+		}
+		result, err := strconv.Unquote(s.buf.String())
+		if err != nil {
+			s.error(err)
+		}
+		return result
+	default:
+		s.errorString("expected quoted string")
+	}
+	return ""
+}
+
+// hexDigit returns the value of the hexadecimal digit
+func (s *ss) hexDigit(digit int) int {
+	switch digit {
+	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+		return digit - '0'
+	case 'a', 'b', 'c', 'd', 'e', 'f':
+		return 10 + digit - 'a'
+	case 'A', 'B', 'C', 'D', 'E', 'F':
+		return 10 + digit - 'A'
+	}
+	s.errorString("Scan: illegal hex digit")
+	return 0
+}
+
+// hexByte returns the next hex-encoded (two-character) byte from the input.
+// There must be either two hexadecimal digits or a space character in the input.
+func (s *ss) hexByte() (b byte, ok bool) {
+	rune1 := s.getRune()
+	if rune1 == EOF {
+		return
+	}
+	if unicode.IsSpace(rune1) {
+		s.UngetRune()
+		return
+	}
+	rune2 := s.mustGetRune()
+	return byte(s.hexDigit(rune1)<<4 | s.hexDigit(rune2)), true
+}
+
+// hexString returns the space-delimited hexpair-encoded string.
+func (s *ss) hexString() string {
+	for {
+		b, ok := s.hexByte()
+		if !ok {
+			break
+		}
+		s.buf.WriteByte(b)
+	}
+	if s.buf.Len() == 0 {
+		s.errorString("Scan: no hex data for %x string")
+		return ""
+	}
+	return s.buf.String()
+}
+
+const floatVerbs = "eEfFgGv"
+
+// scanOne scans a single value, deriving the scanner from the type of the argument.
+func (s *ss) scanOne(verb int, field interface{}) {
+	s.buf.Reset()
+	var err os.Error
+	// If the parameter has its own Scan method, use that.
+	if v, ok := field.(Scanner); ok {
+		err = v.Scan(s, verb)
+		if err != nil {
+			s.error(err)
+		}
+		return
+	}
+	if !s.widPresent {
+		s.maxWid = 1 << 30 // Huge
+	}
+	s.wid = 0
+	switch v := field.(type) {
+	case *bool:
+		*v = s.scanBool(verb)
+	case *complex:
+		*v = complex(s.scanComplex(verb, int(complexBits)))
+	case *complex64:
+		*v = complex64(s.scanComplex(verb, 64))
+	case *complex128:
+		*v = s.scanComplex(verb, 128)
+	case *int:
+		*v = int(s.scanInt(verb, intBits))
+	case *int8:
+		*v = int8(s.scanInt(verb, 8))
+	case *int16:
+		*v = int16(s.scanInt(verb, 16))
+	case *int32:
+		*v = int32(s.scanInt(verb, 32))
+	case *int64:
+		*v = s.scanInt(verb, 64)
+	case *uint:
+		*v = uint(s.scanUint(verb, intBits))
+	case *uint8:
+		*v = uint8(s.scanUint(verb, 8))
+	case *uint16:
+		*v = uint16(s.scanUint(verb, 16))
+	case *uint32:
+		*v = uint32(s.scanUint(verb, 32))
+	case *uint64:
+		*v = s.scanUint(verb, 64)
+	case *uintptr:
+		*v = uintptr(s.scanUint(verb, uintptrBits))
+	// Floats are tricky because you want to scan in the precision of the result, not
+	// scan in high precision and convert, in order to preserve the correct error condition.
+	case *float:
+		if s.okVerb(verb, floatVerbs, "float") {
+			s.skipSpace(false)
+			*v = float(s.convertFloat(s.floatToken(), int(floatBits)))
+		}
+	case *float32:
+		if s.okVerb(verb, floatVerbs, "float32") {
+			s.skipSpace(false)
+			*v = float32(s.convertFloat(s.floatToken(), 32))
+		}
+	case *float64:
+		if s.okVerb(verb, floatVerbs, "float64") {
+			s.skipSpace(false)
+			*v = s.convertFloat(s.floatToken(), 64)
+		}
+	case *string:
+		*v = s.convertString(verb)
+	case *[]byte:
+		// We scan to string and convert so we get a copy of the data.
+		// If we scanned to bytes, the slice would point at the buffer.
+		*v = []byte(s.convertString(verb))
+	default:
+		val := reflect.NewValue(v)
+		ptr, ok := val.(*reflect.PtrValue)
+		if !ok {
+			s.errorString("Scan: type not a pointer: " + val.Type().String())
+			return
+		}
+		switch v := ptr.Elem().(type) {
+		case *reflect.BoolValue:
+			v.Set(s.scanBool(verb))
+		case *reflect.IntValue:
+			v.Set(s.scanInt(verb, v.Type().Bits()))
+		case *reflect.UintValue:
+			v.Set(s.scanUint(verb, v.Type().Bits()))
+		case *reflect.StringValue:
+			v.Set(s.convertString(verb))
+		case *reflect.SliceValue:
+			// For now, can only handle (renamed) []byte.
+			typ := v.Type().(*reflect.SliceType)
+			if typ.Elem().Kind() != reflect.Uint8 {
+				goto CantHandle
+			}
+			str := s.convertString(verb)
+			v.Set(reflect.MakeSlice(typ, len(str), len(str)))
+			for i := 0; i < len(str); i++ {
+				v.Elem(i).(*reflect.UintValue).Set(uint64(str[i]))
+			}
+		case *reflect.FloatValue:
+			s.skipSpace(false)
+			v.Set(s.convertFloat(s.floatToken(), v.Type().Bits()))
+		case *reflect.ComplexValue:
+			v.Set(s.scanComplex(verb, v.Type().Bits()))
+		default:
+		CantHandle:
+			s.errorString("Scan: can't handle type: " + val.Type().String())
+		}
+	}
+}
+
+// errorHandler turns local panics into error returns.  EOFs are benign.
+func errorHandler(errp *os.Error) {
+	if e := recover(); e != nil {
+		if se, ok := e.(scanError); ok { // catch local error
+			if se.err != os.EOF {
+				*errp = se.err
+			}
+		} else {
+			panic(e)
+		}
+	}
+}
+
+// doScan does the real work for scanning without a format string.
+// At the moment, it handles only pointers to basic types.
+func (s *ss) doScan(a []interface{}) (numProcessed int, err os.Error) {
+	defer errorHandler(&err)
+	for _, field := range a {
+		s.scanOne('v', field)
+		numProcessed++
+	}
+	// Check for newline if required.
+	if !s.nlIsSpace {
+		for {
+			rune := s.getRune()
+			if rune == '\n' || rune == EOF {
+				break
+			}
+			if !unicode.IsSpace(rune) {
+				s.errorString("Scan: expected newline")
+				break
+			}
+		}
+	}
+	return
+}
+
+// advance determines whether the next characters in the input match
+// those of the format.  It returns the number of bytes (sic) consumed
+// in the format. Newlines included, all runs of space characters in
+// either input or format behave as a single space. This routine also
+// handles the %% case.  If the return value is zero, either format
+// starts with a % (with no following %) or the input is empty.
+// If it is negative, the input did not match the string.
+func (s *ss) advance(format string) (i int) {
+	for i < len(format) {
+		fmtc, w := utf8.DecodeRuneInString(format[i:])
+		if fmtc == '%' {
+			// %% acts like a real percent
+			nextc, _ := utf8.DecodeRuneInString(format[i+w:]) // will not match % if string is empty
+			if nextc != '%' {
+				return
+			}
+			i += w // skip the first %
+		}
+		sawSpace := false
+		for unicode.IsSpace(fmtc) && i < len(format) {
+			sawSpace = true
+			i += w
+			fmtc, w = utf8.DecodeRuneInString(format[i:])
+		}
+		if sawSpace {
+			// There was space in the format, so there should be space (EOF)
+			// in the input.
+			inputc := s.getRune()
+			if inputc == EOF {
+				return
+			}
+			if !unicode.IsSpace(inputc) {
+				// Space in format but not in input: error
+				s.errorString("expected space in input to match format")
+			}
+			s.skipSpace(true)
+			continue
+		}
+		inputc := s.mustGetRune()
+		if fmtc != inputc {
+			s.UngetRune()
+			return -1
+		}
+		i += w
+	}
+	return
+}
+
+// doScanf does the real work when scanning with a format string.
+//  At the moment, it handles only pointers to basic types.
+func (s *ss) doScanf(format string, a []interface{}) (numProcessed int, err os.Error) {
+	defer errorHandler(&err)
+	end := len(format) - 1
+	// We process one item per non-trivial format
+	for i := 0; i <= end; {
+		w := s.advance(format[i:])
+		if w > 0 {
+			i += w
+			continue
+		}
+		// Either we failed to advance, we have a percent character, or we ran out of input.
+		if format[i] != '%' {
+			// Can't advance format.  Why not?
+			if w < 0 {
+				s.errorString("input does not match format")
+			}
+			// Otherwise at EOF; "too many operands" error handled below
+			break
+		}
+		i++ // % is one byte
+
+		// do we have 20 (width)?
+		s.maxWid, s.widPresent, i = parsenum(format, i, end)
+
+		c, w := utf8.DecodeRuneInString(format[i:])
+		i += w
+
+		if numProcessed >= len(a) { // out of operands
+			s.errorString("too few operands for format %" + format[i-w:])
+			break
+		}
+		field := a[numProcessed]
+
+		s.scanOne(c, field)
+		numProcessed++
+	}
+	if numProcessed < len(a) {
+		s.errorString("too many operands")
+	}
+	return
+}
diff --git a/libgo/go/fmt/scan_test.go b/libgo/go/fmt/scan_test.go
new file mode 100644
index 0000000..9193932
--- /dev/null
+++ b/libgo/go/fmt/scan_test.go
@@ -0,0 +1,605 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt_test
+
+import (
+	"bufio"
+	. "fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+	"utf8"
+)
+
+type ScanTest struct {
+	text string
+	in   interface{}
+	out  interface{}
+}
+
+type ScanfTest struct {
+	format string
+	text   string
+	in     interface{}
+	out    interface{}
+}
+
+type ScanfMultiTest struct {
+	format string
+	text   string
+	in     []interface{}
+	out    []interface{}
+	err    string
+}
+
+var (
+	boolVal              bool
+	intVal               int
+	int8Val              int8
+	int16Val             int16
+	int32Val             int32
+	int64Val             int64
+	uintVal              uint
+	uint8Val             uint8
+	uint16Val            uint16
+	uint32Val            uint32
+	uint64Val            uint64
+	floatVal             float
+	float32Val           float32
+	float64Val           float64
+	stringVal            string
+	stringVal1           string
+	bytesVal             []byte
+	complexVal           complex
+	complex64Val         complex64
+	complex128Val        complex128
+	renamedBoolVal       renamedBool
+	renamedIntVal        renamedInt
+	renamedInt8Val       renamedInt8
+	renamedInt16Val      renamedInt16
+	renamedInt32Val      renamedInt32
+	renamedInt64Val      renamedInt64
+	renamedUintVal       renamedUint
+	renamedUint8Val      renamedUint8
+	renamedUint16Val     renamedUint16
+	renamedUint32Val     renamedUint32
+	renamedUint64Val     renamedUint64
+	renamedUintptrVal    renamedUintptr
+	renamedStringVal     renamedString
+	renamedBytesVal      renamedBytes
+	renamedFloatVal      renamedFloat
+	renamedFloat32Val    renamedFloat32
+	renamedFloat64Val    renamedFloat64
+	renamedComplexVal    renamedComplex
+	renamedComplex64Val  renamedComplex64
+	renamedComplex128Val renamedComplex128
+)
+
+// Xs accepts any non-empty run of the verb character
+type Xs string
+
+func (x *Xs) Scan(state ScanState, verb int) os.Error {
+	var tok string
+	var c int
+	var err os.Error
+	wid, present := state.Width()
+	if !present {
+		tok, err = state.Token()
+	} else {
+		for i := 0; i < wid; i++ {
+			c, err = state.GetRune()
+			if err != nil {
+				break
+			}
+			tok += string(c)
+		}
+	}
+	if err != nil {
+		return err
+	}
+	if !regexp.MustCompile("^" + string(verb) + "+$").MatchString(tok) {
+		return os.ErrorString("syntax error for xs")
+	}
+	*x = Xs(tok)
+	return nil
+}
+
+var xVal Xs
+
+// myStringReader implements Read but not ReadRune, allowing us to test our readRune wrapper
+// type that creates something that can read runes given only Read().
+type myStringReader struct {
+	r *strings.Reader
+}
+
+func (s *myStringReader) Read(p []byte) (n int, err os.Error) {
+	return s.r.Read(p)
+}
+
+func newReader(s string) *myStringReader {
+	return &myStringReader{strings.NewReader(s)}
+}
+
+var scanTests = []ScanTest{
+	// Numbers
+	{"T\n", &boolVal, true},  // boolean test vals toggle to be sure they are written
+	{"F\n", &boolVal, false}, // restored to zero value
+	{"21\n", &intVal, 21},
+	{"22\n", &int8Val, int8(22)},
+	{"23\n", &int16Val, int16(23)},
+	{"24\n", &int32Val, int32(24)},
+	{"25\n", &int64Val, int64(25)},
+	{"127\n", &int8Val, int8(127)},
+	{"-21\n", &intVal, -21},
+	{"-22\n", &int8Val, int8(-22)},
+	{"-23\n", &int16Val, int16(-23)},
+	{"-24\n", &int32Val, int32(-24)},
+	{"-25\n", &int64Val, int64(-25)},
+	{"-128\n", &int8Val, int8(-128)},
+	{"+21\n", &intVal, +21},
+	{"+22\n", &int8Val, int8(+22)},
+	{"+23\n", &int16Val, int16(+23)},
+	{"+24\n", &int32Val, int32(+24)},
+	{"+25\n", &int64Val, int64(+25)},
+	{"+127\n", &int8Val, int8(+127)},
+	{"26\n", &uintVal, uint(26)},
+	{"27\n", &uint8Val, uint8(27)},
+	{"28\n", &uint16Val, uint16(28)},
+	{"29\n", &uint32Val, uint32(29)},
+	{"30\n", &uint64Val, uint64(30)},
+	{"255\n", &uint8Val, uint8(255)},
+	{"32767\n", &int16Val, int16(32767)},
+	{"2.3\n", &floatVal, 2.3},
+	{"2.3e1\n", &float32Val, float32(2.3e1)},
+	{"2.3e2\n", &float64Val, float64(2.3e2)},
+	{"2.35\n", &stringVal, "2.35"},
+	{"2345678\n", &bytesVal, []byte("2345678")},
+	{"(3.4e1-2i)\n", &complexVal, 3.4e1 - 2i},
+	{"-3.45e1-3i\n", &complex64Val, complex64(-3.45e1 - 3i)},
+	{"-.45e1-1e2i\n", &complex128Val, complex128(-.45e1 - 100i)},
+	{"hello\n", &stringVal, "hello"},
+
+	// Renamed types
+	{"true\n", &renamedBoolVal, renamedBool(true)},
+	{"F\n", &renamedBoolVal, renamedBool(false)},
+	{"101\n", &renamedIntVal, renamedInt(101)},
+	{"102\n", &renamedIntVal, renamedInt(102)},
+	{"103\n", &renamedUintVal, renamedUint(103)},
+	{"104\n", &renamedUintVal, renamedUint(104)},
+	{"105\n", &renamedInt8Val, renamedInt8(105)},
+	{"106\n", &renamedInt16Val, renamedInt16(106)},
+	{"107\n", &renamedInt32Val, renamedInt32(107)},
+	{"108\n", &renamedInt64Val, renamedInt64(108)},
+	{"109\n", &renamedUint8Val, renamedUint8(109)},
+	{"110\n", &renamedUint16Val, renamedUint16(110)},
+	{"111\n", &renamedUint32Val, renamedUint32(111)},
+	{"112\n", &renamedUint64Val, renamedUint64(112)},
+	{"113\n", &renamedUintptrVal, renamedUintptr(113)},
+	{"114\n", &renamedStringVal, renamedString("114")},
+	{"115\n", &renamedBytesVal, renamedBytes([]byte("115"))},
+
+	// Custom scanner.
+	{"  vvv ", &xVal, Xs("vvv")},
+
+	// Fixed bugs
+	{"2147483648\n", &int64Val, int64(2147483648)}, // was: integer overflow
+}
+
+var scanfTests = []ScanfTest{
+	{"%v", "TRUE\n", &boolVal, true},
+	{"%t", "false\n", &boolVal, false},
+	{"%v", "-71\n", &intVal, -71},
+	{"%d", "72\n", &intVal, 72},
+	{"%c", "a\n", &intVal, 'a'},
+	{"%c", "\u5072\n", &intVal, 0x5072},
+	{"%c", "\u1234\n", &intVal, '\u1234'},
+	{"%d", "73\n", &int8Val, int8(73)},
+	{"%d", "+74\n", &int16Val, int16(74)},
+	{"%d", "75\n", &int32Val, int32(75)},
+	{"%d", "76\n", &int64Val, int64(76)},
+	{"%b", "1001001\n", &intVal, 73},
+	{"%o", "075\n", &intVal, 075},
+	{"%x", "a75\n", &intVal, 0xa75},
+	{"%v", "71\n", &uintVal, uint(71)},
+	{"%d", "72\n", &uintVal, uint(72)},
+	{"%d", "73\n", &uint8Val, uint8(73)},
+	{"%d", "74\n", &uint16Val, uint16(74)},
+	{"%d", "75\n", &uint32Val, uint32(75)},
+	{"%d", "76\n", &uint64Val, uint64(76)},
+	{"%b", "1001001\n", &uintVal, uint(73)},
+	{"%o", "075\n", &uintVal, uint(075)},
+	{"%x", "a75\n", &uintVal, uint(0xa75)},
+	{"%x", "A75\n", &uintVal, uint(0xa75)},
+
+	// Strings
+	{"%s", "using-%s\n", &stringVal, "using-%s"},
+	{"%x", "7573696e672d2578\n", &stringVal, "using-%x"},
+	{"%q", `"quoted\twith\\do\u0075bl\x65s"` + "\n", &stringVal, "quoted\twith\\doubles"},
+	{"%q", "`quoted with backs`\n", &stringVal, "quoted with backs"},
+
+	// Byte slices
+	{"%s", "bytes-%s\n", &bytesVal, []byte("bytes-%s")},
+	{"%x", "62797465732d2578\n", &bytesVal, []byte("bytes-%x")},
+	{"%q", `"bytes\rwith\vdo\u0075bl\x65s"` + "\n", &bytesVal, []byte("bytes\rwith\vdoubles")},
+	{"%q", "`bytes with backs`\n", &bytesVal, []byte("bytes with backs")},
+
+	// Renamed types
+	{"%v\n", "true\n", &renamedBoolVal, renamedBool(true)},
+	{"%t\n", "F\n", &renamedBoolVal, renamedBool(false)},
+	{"%v", "101\n", &renamedIntVal, renamedInt(101)},
+	{"%c", "\u0101\n", &renamedIntVal, renamedInt('\u0101')},
+	{"%o", "0146\n", &renamedIntVal, renamedInt(102)},
+	{"%v", "103\n", &renamedUintVal, renamedUint(103)},
+	{"%d", "104\n", &renamedUintVal, renamedUint(104)},
+	{"%d", "105\n", &renamedInt8Val, renamedInt8(105)},
+	{"%d", "106\n", &renamedInt16Val, renamedInt16(106)},
+	{"%d", "107\n", &renamedInt32Val, renamedInt32(107)},
+	{"%d", "108\n", &renamedInt64Val, renamedInt64(108)},
+	{"%x", "6D\n", &renamedUint8Val, renamedUint8(109)},
+	{"%o", "0156\n", &renamedUint16Val, renamedUint16(110)},
+	{"%d", "111\n", &renamedUint32Val, renamedUint32(111)},
+	{"%d", "112\n", &renamedUint64Val, renamedUint64(112)},
+	{"%d", "113\n", &renamedUintptrVal, renamedUintptr(113)},
+	{"%s", "114\n", &renamedStringVal, renamedString("114")},
+	{"%q", "\"1155\"\n", &renamedBytesVal, renamedBytes([]byte("1155"))},
+	{"%g", "115.1\n", &renamedFloatVal, renamedFloat(115.1)},
+	{"%g", "116e1\n", &renamedFloat32Val, renamedFloat32(116e1)},
+	{"%g", "-11.7e+1", &renamedFloat64Val, renamedFloat64(-11.7e+1)},
+	{"%g", "11+5.1i\n", &renamedComplexVal, renamedComplex(11 + 5.1i)},
+	{"%g", "11+6e1i\n", &renamedComplex64Val, renamedComplex64(11 + 6e1i)},
+	{"%g", "-11.+7e+1i", &renamedComplex128Val, renamedComplex128(-11. + 7e+1i)},
+
+	// Interesting formats
+	{"here is\tthe value:%d", "here is   the\tvalue:118\n", &intVal, 118},
+	{"%% %%:%d", "% %:119\n", &intVal, 119},
+
+	// Corner cases
+	{"%x", "FFFFFFFF\n", &uint32Val, uint32(0xFFFFFFFF)},
+
+	// Custom scanner.
+	{"%s", "  sss ", &xVal, Xs("sss")},
+	{"%2s", "sssss", &xVal, Xs("ss")},
+
+	// Fixed bugs
+	{"%d\n", "27\n", &intVal, 27},  // ok
+	{"%d\n", "28 \n", &intVal, 28}, // was: "unexpected newline"
+}
+
+var overflowTests = []ScanTest{
+	{"128", &int8Val, 0},
+	{"32768", &int16Val, 0},
+	{"-129", &int8Val, 0},
+	{"-32769", &int16Val, 0},
+	{"256", &uint8Val, 0},
+	{"65536", &uint16Val, 0},
+	{"1e100", &float32Val, 0},
+	{"1e500", &float64Val, 0},
+	{"(1e100+0i)", &complexVal, 0},
+	{"(1+1e100i)", &complex64Val, 0},
+	{"(1-1e500i)", &complex128Val, 0},
+}
+
+var i, j, k int
+var f float
+var s, t string
+var c complex
+var x, y Xs
+
+var multiTests = []ScanfMultiTest{
+	{"", "", nil, nil, ""},
+	{"%d", "23", args(&i), args(23), ""},
+	{"%2s%3s", "22333", args(&s, &t), args("22", "333"), ""},
+	{"%2d%3d", "44555", args(&i, &j), args(44, 555), ""},
+	{"%2d.%3d", "66.777", args(&i, &j), args(66, 777), ""},
+	{"%d, %d", "23, 18", args(&i, &j), args(23, 18), ""},
+	{"%3d22%3d", "33322333", args(&i, &j), args(333, 333), ""},
+	{"%6vX=%3fY", "3+2iX=2.5Y", args(&c, &f), args((3 + 2i), float(2.5)), ""},
+	{"%d%s", "123abc", args(&i, &s), args(123, "abc"), ""},
+	{"%c%c%c", "2\u50c2X", args(&i, &j, &k), args('2', '\u50c2', 'X'), ""},
+
+	// Custom scanner.
+	{"%2e%f", "eefffff", args(&x, &y), args(Xs("ee"), Xs("fffff")), ""},
+
+	// Errors
+	{"%t", "23 18", args(&i), nil, "bad verb"},
+	{"%d %d %d", "23 18", args(&i, &j), args(23, 18), "too few operands"},
+	{"%d %d", "23 18 27", args(&i, &j, &k), args(23, 18), "too many operands"},
+	{"%c", "\u0100", args(&int8Val), nil, "overflow"},
+	{"X%d", "10X", args(&intVal), nil, "input does not match format"},
+
+	// Bad UTF-8: should see every byte.
+	{"%c%c%c", "\xc2X\xc2", args(&i, &j, &k), args(utf8.RuneError, 'X', utf8.RuneError), ""},
+}
+
+func testScan(name string, t *testing.T, scan func(r io.Reader, a ...interface{}) (int, os.Error)) {
+	for _, test := range scanTests {
+		var r io.Reader
+		if name == "StringReader" {
+			r = strings.NewReader(test.text)
+		} else {
+			r = newReader(test.text)
+		}
+		n, err := scan(r, test.in)
+		if err != nil {
+			t.Errorf("%s got error scanning %q: %s", name, test.text, err)
+			continue
+		}
+		if n != 1 {
+			t.Errorf("%s count error on entry %q: got %d", name, test.text, n)
+			continue
+		}
+		// The incoming value may be a pointer
+		v := reflect.NewValue(test.in)
+		if p, ok := v.(*reflect.PtrValue); ok {
+			v = p.Elem()
+		}
+		val := v.Interface()
+		if !reflect.DeepEqual(val, test.out) {
+			t.Errorf("%s scanning %q: expected %v got %v, type %T", name, test.text, test.out, val, val)
+		}
+	}
+}
+
+func TestScan(t *testing.T) {
+	testScan("StringReader", t, Fscan)
+}
+
+func TestMyReaderScan(t *testing.T) {
+	testScan("myStringReader", t, Fscan)
+}
+
+func TestScanln(t *testing.T) {
+	testScan("StringReader", t, Fscanln)
+}
+
+func TestMyReaderScanln(t *testing.T) {
+	testScan("myStringReader", t, Fscanln)
+}
+
+func TestScanf(t *testing.T) {
+	for _, test := range scanfTests {
+		n, err := Sscanf(test.text, test.format, test.in)
+		if err != nil {
+			t.Errorf("got error scanning (%q, %q): %s", test.format, test.text, err)
+			continue
+		}
+		if n != 1 {
+			t.Errorf("count error on entry (%q, %q): got %d", test.format, test.text, n)
+			continue
+		}
+		// The incoming value may be a pointer
+		v := reflect.NewValue(test.in)
+		if p, ok := v.(*reflect.PtrValue); ok {
+			v = p.Elem()
+		}
+		val := v.Interface()
+		if !reflect.DeepEqual(val, test.out) {
+			t.Errorf("scanning (%q, %q): expected %v got %v, type %T", test.format, test.text, test.out, val, val)
+		}
+	}
+}
+
+func TestScanOverflow(t *testing.T) {
+	// different machines and different types report errors with different strings.
+	re := regexp.MustCompile("overflow|too large|out of range|not representable")
+	for _, test := range overflowTests {
+		_, err := Sscan(test.text, test.in)
+		if err == nil {
+			t.Errorf("expected overflow scanning %q", test.text)
+			continue
+		}
+		if !re.MatchString(err.String()) {
+			t.Errorf("expected overflow error scanning %q: %s", test.text, err)
+		}
+	}
+}
+
+// TODO: there's no conversion from []T to ...T, but we can fake it.  These
+// functions do the faking.  We index the table by the length of the param list.
+var fscanf = []func(io.Reader, string, []interface{}) (int, os.Error){
+	0: func(r io.Reader, f string, i []interface{}) (int, os.Error) { return Fscanf(r, f) },
+	1: func(r io.Reader, f string, i []interface{}) (int, os.Error) { return Fscanf(r, f, i[0]) },
+	2: func(r io.Reader, f string, i []interface{}) (int, os.Error) { return Fscanf(r, f, i[0], i[1]) },
+	3: func(r io.Reader, f string, i []interface{}) (int, os.Error) { return Fscanf(r, f, i[0], i[1], i[2]) },
+}
+
+func testScanfMulti(name string, t *testing.T) {
+	sliceType := reflect.Typeof(make([]interface{}, 1)).(*reflect.SliceType)
+	for _, test := range multiTests {
+		var r io.Reader
+		if name == "StringReader" {
+			r = strings.NewReader(test.text)
+		} else {
+			r = newReader(test.text)
+		}
+		n, err := fscanf[len(test.in)](r, test.format, test.in)
+		if err != nil {
+			if test.err == "" {
+				t.Errorf("got error scanning (%q, %q): %q", test.format, test.text, err)
+			} else if strings.Index(err.String(), test.err) < 0 {
+				t.Errorf("got wrong error scanning (%q, %q): %q; expected %q", test.format, test.text, err, test.err)
+			}
+			continue
+		}
+		if test.err != "" {
+			t.Errorf("expected error %q error scanning (%q, %q)", test.err, test.format, test.text)
+		}
+		if n != len(test.out) {
+			t.Errorf("count error on entry (%q, %q): expected %d got %d", test.format, test.text, len(test.out), n)
+			continue
+		}
+		// Convert the slice of pointers into a slice of values
+		resultVal := reflect.MakeSlice(sliceType, n, n)
+		for i := 0; i < n; i++ {
+			v := reflect.NewValue(test.in[i]).(*reflect.PtrValue).Elem()
+			resultVal.Elem(i).(*reflect.InterfaceValue).Set(v)
+		}
+		result := resultVal.Interface()
+		if !reflect.DeepEqual(result, test.out) {
+			t.Errorf("scanning (%q, %q): expected %v got %v", test.format, test.text, test.out, result)
+		}
+	}
+}
+
+func TestScanfMulti(t *testing.T) {
+	testScanfMulti("StringReader", t)
+}
+
+func TestMyReaderScanfMulti(t *testing.T) {
+	testScanfMulti("myStringReader", t)
+}
+
+func TestScanMultiple(t *testing.T) {
+	var a int
+	var s string
+	n, err := Sscan("123abc", &a, &s)
+	if n != 2 {
+		t.Errorf("Sscan count error: expected 2: got %d", n)
+	}
+	if err != nil {
+		t.Errorf("Sscan expected no error; got %s", err)
+	}
+	if a != 123 || s != "abc" {
+		t.Errorf("Sscan wrong values: got (%d %q) expected (123 \"abc\")", a, s)
+	}
+	n, err = Sscan("asdf", &s, &a)
+	if n != 1 {
+		t.Errorf("Sscan count error: expected 1: got %d", n)
+	}
+	if err == nil {
+		t.Errorf("Sscan expected error; got none", err)
+	}
+	if s != "asdf" {
+		t.Errorf("Sscan wrong values: got %q expected \"asdf\"", s)
+	}
+}
+
+// Empty strings are not valid input when scanning a string.
+func TestScanEmpty(t *testing.T) {
+	var s1, s2 string
+	n, err := Sscan("abc", &s1, &s2)
+	if n != 1 {
+		t.Errorf("Sscan count error: expected 1: got %d", n)
+	}
+	if err == nil {
+		t.Errorf("Sscan <one item> expected error; got none")
+	}
+	if s1 != "abc" {
+		t.Errorf("Sscan wrong values: got %q expected \"abc\"", s1)
+	}
+	n, err = Sscan("", &s1, &s2)
+	if n != 0 {
+		t.Errorf("Sscan count error: expected 0: got %d", n)
+	}
+	if err == nil {
+		t.Errorf("Sscan <empty> expected error; got none")
+	}
+	// Quoted empty string is OK.
+	n, err = Sscanf(`""`, "%q", &s1)
+	if n != 1 {
+		t.Errorf("Sscanf count error: expected 1: got %d", n)
+	}
+	if err != nil {
+		t.Errorf("Sscanf <empty> expected no error with quoted string; got %s", err)
+	}
+}
+
+func TestScanNotPointer(t *testing.T) {
+	r := strings.NewReader("1")
+	var a int
+	_, err := Fscan(r, a)
+	if err == nil {
+		t.Error("expected error scanning non-pointer")
+	} else if strings.Index(err.String(), "pointer") < 0 {
+		t.Errorf("expected pointer error scanning non-pointer, got: %s", err)
+	}
+}
+
+func TestScanlnNoNewline(t *testing.T) {
+	var a int
+	_, err := Sscanln("1 x\n", &a)
+	if err == nil {
+		t.Error("expected error scanning string missing newline")
+	} else if strings.Index(err.String(), "newline") < 0 {
+		t.Errorf("expected newline error scanning string missing newline, got: %s", err)
+	}
+}
+
+func TestScanlnWithMiddleNewline(t *testing.T) {
+	r := strings.NewReader("123\n456\n")
+	var a, b int
+	_, err := Fscanln(r, &a, &b)
+	if err == nil {
+		t.Error("expected error scanning string with extra newline")
+	} else if strings.Index(err.String(), "newline") < 0 {
+		t.Errorf("expected newline error scanning string with extra newline, got: %s", err)
+	}
+}
+
+// Special Reader that counts reads at end of file.
+type eofCounter struct {
+	reader   *strings.Reader
+	eofCount int
+}
+
+func (ec *eofCounter) Read(b []byte) (n int, err os.Error) {
+	n, err = ec.reader.Read(b)
+	if n == 0 {
+		ec.eofCount++
+	}
+	return
+}
+
+// Verify that when we scan, we see at most EOF once per call to a Scan function,
+// and then only when it's really an EOF
+func TestEOF(t *testing.T) {
+	ec := &eofCounter{strings.NewReader("123\n"), 0}
+	var a int
+	n, err := Fscanln(ec, &a)
+	if err != nil {
+		t.Error("unexpected error", err)
+	}
+	if n != 1 {
+		t.Error("expected to scan one item, got", n)
+	}
+	if ec.eofCount != 0 {
+		t.Error("expected zero EOFs", ec.eofCount)
+		ec.eofCount = 0 // reset for next test
+	}
+	n, err = Fscanln(ec, &a)
+	if err == nil {
+		t.Error("expected error scanning empty string")
+	}
+	if n != 0 {
+		t.Error("expected to scan zero items, got", n)
+	}
+	if ec.eofCount != 1 {
+		t.Error("expected one EOF, got", ec.eofCount)
+	}
+}
+
+// Verify that, at least when using bufio, successive calls to Fscan do not lose runes.
+func TestUnreadRuneWithBufio(t *testing.T) {
+	r := bufio.NewReader(strings.NewReader("123αb"))
+	var i int
+	var a string
+	n, err := Fscanf(r, "%d", &i)
+	if n != 1 || err != nil {
+		t.Errorf("reading int expected one item, no errors; got %d %q", n, err)
+	}
+	if i != 123 {
+		t.Errorf("expected 123; got %d", i)
+	}
+	n, err = Fscanf(r, "%s", &a)
+	if n != 1 || err != nil {
+		t.Errorf("reading string expected one item, no errors; got %d %q", n, err)
+	}
+	if a != "αb" {
+		t.Errorf("expected αb; got %q", a)
+	}
+}
diff --git a/libgo/go/fmt/stringer_test.go b/libgo/go/fmt/stringer_test.go
new file mode 100644
index 0000000..815147e
--- /dev/null
+++ b/libgo/go/fmt/stringer_test.go
@@ -0,0 +1,61 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt_test
+
+import (
+	. "fmt"
+	"testing"
+)
+
+type TI int
+type TI8 int8
+type TI16 int16
+type TI32 int32
+type TI64 int64
+type TU uint
+type TU8 uint8
+type TU16 uint16
+type TU32 uint32
+type TU64 uint64
+type TUI uintptr
+type TF float
+type TF32 float32
+type TF64 float64
+type TB bool
+type TS string
+
+func (v TI) String() string   { return Sprintf("I: %d", int(v)) }
+func (v TI8) String() string  { return Sprintf("I8: %d", int8(v)) }
+func (v TI16) String() string { return Sprintf("I16: %d", int16(v)) }
+func (v TI32) String() string { return Sprintf("I32: %d", int32(v)) }
+func (v TI64) String() string { return Sprintf("I64: %d", int64(v)) }
+func (v TU) String() string   { return Sprintf("U: %d", uint(v)) }
+func (v TU8) String() string  { return Sprintf("U8: %d", uint8(v)) }
+func (v TU16) String() string { return Sprintf("U16: %d", uint16(v)) }
+func (v TU32) String() string { return Sprintf("U32: %d", uint32(v)) }
+func (v TU64) String() string { return Sprintf("U64: %d", uint64(v)) }
+func (v TUI) String() string  { return Sprintf("UI: %d", uintptr(v)) }
+func (v TF) String() string   { return Sprintf("F: %f", float(v)) }
+func (v TF32) String() string { return Sprintf("F32: %f", float32(v)) }
+func (v TF64) String() string { return Sprintf("F64: %f", float64(v)) }
+func (v TB) String() string   { return Sprintf("B: %t", bool(v)) }
+func (v TS) String() string   { return Sprintf("S: %q", string(v)) }
+
+func check(t *testing.T, got, want string) {
+	if got != want {
+		t.Error(got, "!=", want)
+	}
+}
+
+func TestStringer(t *testing.T) {
+	s := Sprintf("%v %v %v %v %v", TI(0), TI8(1), TI16(2), TI32(3), TI64(4))
+	check(t, s, "I: 0 I8: 1 I16: 2 I32: 3 I64: 4")
+	s = Sprintf("%v %v %v %v %v %v", TU(5), TU8(6), TU16(7), TU32(8), TU64(9), TUI(10))
+	check(t, s, "U: 5 U8: 6 U16: 7 U32: 8 U64: 9 UI: 10")
+	s = Sprintf("%v %v %v", TF(1.0), TF32(2.0), TF64(3.0))
+	check(t, s, "F: 1.000000 F32: 2.000000 F64: 3.000000")
+	s = Sprintf("%v %v", TB(true), TS("x"))
+	check(t, s, "B: true S: \"x\"")
+}