Update Go library to release r60.1.

From-SVN: r179076

libgo/MERGE

@@ -1,4 +1,4 @@
-504f4e9b079c
+fd30c132d1bd
 
 The first line of this file holds the Mercurial revision number of the
 last merge done from the master library sources.

libgo/Makefile.am

@@ -636,7 +636,8 @@ go_json_files = \
 	go/json/encode.go \
 	go/json/indent.go \
 	go/json/scanner.go \
-	go/json/stream.go
+	go/json/stream.go \
+	go/json/tags.go
 
 go_log_files = \
 	go/log/log.go

libgo/Makefile.in

@@ -1037,7 +1037,8 @@ go_json_files = \
 	go/json/encode.go \
 	go/json/indent.go \
 	go/json/scanner.go \
-	go/json/stream.go
+	go/json/stream.go \
+	go/json/tags.go
 
 go_log_files = \
 	go/log/log.go

libgo/go/go/types/testdata/test0.src

@@ -0,0 +1,154 @@
+// Copyright 2011 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.
+
+// type declarations
+
+package test0
+
+import "unsafe"
+
+const pi = 3.1415
+
+type (
+	N undeclared /* ERROR "undeclared" */
+	B bool
+	I int32
+	A [10]P
+	T struct {
+		x, y P
+	}
+	P *T
+	R (*R)
+	F func(A) I
+	Y interface {
+		f(A) I
+	}
+	S [](((P)))
+	M map[I]F
+	C chan<- I
+)
+
+
+type (
+	p1 pi /* ERROR "not a package" */ .foo
+	p2 unsafe.Pointer
+)
+
+
+type (
+	Pi pi /* ERROR "not a type" */
+
+	a /* DISABLED "illegal cycle" */ a
+	a /* ERROR "redeclared" */ int
+
+	// where the cycle error appears depends on the
+	// order in which declarations are processed
+	// (which depends on the order in which a map
+	// is iterated through)
+	b c
+	c /* DISABLED "illegal cycle" */ d
+	d e
+	e b
+
+	t *t
+
+	U V
+	V *W
+	W U
+
+	P1 *S2
+	P2 P1
+
+	S0 struct {
+	}
+	S1 struct {
+		a, b, c int
+		u, v, a /* ERROR "redeclared" */ float32
+	}
+	S2 struct {
+		U // anonymous field
+		// TODO(gri) recognize double-declaration below
+		// U /* ERROR "redeclared" */ int
+	}
+	S3 struct {
+		x S2
+	}
+	S4/* DISABLED "illegal cycle" */ struct {
+		S4
+	}
+	S5 struct {
+		S6
+	}
+	S6 /* DISABLED "illegal cycle" */ struct {
+		field S7
+	}
+	S7 struct {
+		S5
+	}
+
+	L1 []L1
+	L2 []int
+
+	A1 [10]int
+	A2 /* DISABLED "illegal cycle" */ [10]A2
+	A3 /* DISABLED "illegal cycle" */ [10]struct {
+		x A4
+	}
+	A4 [10]A3
+
+	F1 func()
+	F2 func(x, y, z float32)
+	F3 func(x, y, x /* ERROR "redeclared" */ float32)
+	F4 func() (x, y, x /* ERROR "redeclared" */ float32)
+	F5 func(x int) (x /* ERROR "redeclared" */ float32)
+	F6 func(x ...int)
+
+	I1 interface{}
+	I2 interface {
+		m1()
+	}
+	I3 interface {
+		m1()
+		m1 /* ERROR "redeclared" */ ()
+	}
+	I4 interface {
+		m1(x, y, x /* ERROR "redeclared" */ float32)
+		m2() (x, y, x /* ERROR "redeclared" */ float32)
+		m3(x int) (x /* ERROR "redeclared" */ float32)
+	}
+	I5 interface {
+		m1(I5)
+	}
+	I6 interface {
+		S0 /* ERROR "non-interface" */
+	}
+	I7 interface {
+		I1
+		I1
+	}
+	I8 /* DISABLED "illegal cycle" */ interface {
+		I8
+	}
+	I9 /* DISABLED "illegal cycle" */ interface {
+		I10
+	}
+	I10 interface {
+		I11
+	}
+	I11 interface {
+		I9
+	}
+
+	C1 chan int
+	C2 <-chan int
+	C3 chan<- C3
+	C4 chan C5
+	C5 chan C6
+	C6 chan C4
+
+	M1 map[Last]string
+	M2 map[string]M2
+
+	Last int
+)

libgo/go/gob/doc.go

@@ -221,6 +221,9 @@ In summary, a gob stream looks like
 
 where * signifies zero or more repetitions and the type id of a value must
 be predefined or be defined before the value in the stream.
+
+See "Gobs of data" for a design discussion of the gob wire format:
+http://blog.golang.org/2011/03/gobs-of-data.html
 */
 package gob
 

libgo/go/http/cgi/host_test.go

@@ -374,6 +374,8 @@ func TestCopyError(t *testing.T) {
 	}
 }
 
+/* This test doesn't work in gccgo's testing environment.
+
 func TestDirUnix(t *testing.T) {
 	if skipTest(t) || runtime.GOOS == "windows" {
 		return
@@ -402,6 +404,8 @@ func TestDirUnix(t *testing.T) {
 	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
 }
 
+*/
+
 func TestDirWindows(t *testing.T) {
 	if skipTest(t) || runtime.GOOS != "windows" {
 		return

libgo/go/http/cgi/testdata/test.cgi

@@ -0,0 +1,96 @@
+#!/usr/bin/perl
+# Copyright 2011 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.
+#
+# Test script run as a child process under cgi_test.go
+
+use strict;
+use Cwd;
+
+my $q = MiniCGI->new;
+my $params = $q->Vars;
+
+if ($params->{"loc"}) {
+    print "Location: $params->{loc}\r\n\r\n";
+    exit(0);
+}
+
+my $NL = "\r\n";
+$NL = "\n" if $params->{mode} eq "NL";
+
+my $p = sub {
+  print "$_[0]$NL";
+};
+
+# With carriage returns
+$p->("Content-Type: text/html");
+$p->("X-CGI-Pid: $$");
+$p->("X-Test-Header: X-Test-Value");
+$p->("");
+
+if ($params->{"bigresponse"}) {
+    for (1..1024) {
+        print "A" x 1024, "\n";
+    }
+    exit 0;
+}
+
+print "test=Hello CGI\n";
+
+foreach my $k (sort keys %$params) {
+  print "param-$k=$params->{$k}\n";
+}
+
+foreach my $k (sort keys %ENV) {
+  my $clean_env = $ENV{$k};
+  $clean_env =~ s/[\n\r]//g;
+  print "env-$k=$clean_env\n";
+}
+
+# NOTE: don't call getcwd() for windows.
+# msys return /c/go/src/... not C:\go\...
+my $dir;
+if ($^O eq 'MSWin32' || $^O eq 'msys') {
+  my $cmd = $ENV{'COMSPEC'} || 'c:\\windows\\system32\\cmd.exe';
+  $cmd =~ s!\\!/!g;
+  $dir = `$cmd /c cd`;
+  chomp $dir;
+} else {
+  $dir = getcwd();
+}
+print "cwd=$dir\n";
+
+
+# A minimal version of CGI.pm, for people without the perl-modules
+# package installed.  (CGI.pm used to be part of the Perl core, but
+# some distros now bundle perl-base and perl-modules separately...)
+package MiniCGI;
+
+sub new {
+    my $class = shift;
+    return bless {}, $class;
+}
+
+sub Vars {
+    my $self = shift;
+    my $pairs;
+    if ($ENV{CONTENT_LENGTH}) {
+        $pairs = do { local $/; <STDIN> };
+    } else {
+        $pairs = $ENV{QUERY_STRING};
+    }
+    my $vars = {};
+    foreach my $kv (split(/&/, $pairs)) {
+        my ($k, $v) = split(/=/, $kv, 2);
+        $vars->{_urldecode($k)} = _urldecode($v);
+    }
+    return $vars;
+}
+
+sub _urldecode {
+    my $v = shift;
+    $v =~ tr/+/ /;
+    $v =~ s/%([a-fA-F0-9][a-fA-F0-9])/pack("C", hex($1))/eg;
+    return $v;
+}

libgo/go/image/png/testdata/pngsuite/basn3p08-trns.sng

@@ -0,0 +1,301 @@
+#SNG: from basn3p08-trns.png
+IHDR {
+    width: 32; height: 32; bitdepth: 8;
+    using color palette;
+}
+gAMA {1.0000}
+PLTE {
+    (255,  3,  7)     # rgb = (0xff,0x03,0x07)
+    (255,  4,  7)     # rgb = (0xff,0x04,0x07)
+    (255,  9,  7)     # rgb = (0xff,0x09,0x07)
+    (217, 14,  7)     # rgb = (0xd9,0x0e,0x07)
+    (255, 14,  7)     # rgb = (0xff,0x0e,0x07)
+    (  2, 22, 19)     # rgb = (0x02,0x16,0x13)
+    (255, 26,  7)     # rgb = (0xff,0x1a,0x07)
+    (255, 31,  7)     # rgb = (0xff,0x1f,0x07)
+    ( 10, 37, 14)     # rgb = (0x0a,0x25,0x0e)
+    (179, 37,  6)     # rgb = (0xb3,0x25,0x06)
+    (254, 42,  7)     # rgb = (0xfe,0x2a,0x07)
+    (255, 45,  7)     # rgb = (0xff,0x2d,0x07)
+    ( 25, 46,  9)     # rgb = (0x19,0x2e,0x09)
+    (  0, 48,254)     # rgb = (0x00,0x30,0xfe)
+    (  0, 48,255)     # rgb = (0x00,0x30,0xff)
+    (  0, 49,255)     # rgb = (0x00,0x31,0xff)
+    (  0, 51,254)     # rgb = (0x00,0x33,0xfe)
+    (  0, 52,255)     # rgb = (0x00,0x34,0xff)
+    (255, 53,  7)     # rgb = (0xff,0x35,0x07)
+    (  0, 54,252)     # rgb = (0x00,0x36,0xfc)
+    (254, 57,  7)     # rgb = (0xfe,0x39,0x07)
+    (251, 57,  7)     # rgb = (0xfb,0x39,0x07)
+    (247, 59,  7)     # rgb = (0xf7,0x3b,0x07)
+    (  0, 59, 61)     # rgb = (0x00,0x3b,0x3d)
+    (  0, 62,255)     # rgb = (0x00,0x3e,0xff)
+    (142, 63,  5)     # rgb = (0x8e,0x3f,0x05)
+    (  0, 63,250)     # rgb = (0x00,0x3f,0xfa)
+    (255, 63,  7)     # rgb = (0xff,0x3f,0x07)
+    (253, 68,  7)     # rgb = (0xfd,0x44,0x07)
+    (  0, 73,255)     # rgb = (0x00,0x49,0xff)
+    (  0, 73,246)     # rgb = (0x00,0x49,0xf6)
+    (255, 75,  7)     # rgb = (0xff,0x4b,0x07)
+    ( 82, 85,  9)     # rgb = (0x52,0x55,0x09)
+    (255, 85,  7)     # rgb = (0xff,0x55,0x07)
+    (  0, 89,255)     # rgb = (0x00,0x59,0xff)
+    (  0, 91,237)     # rgb = (0x00,0x5b,0xed)
+    (255, 94,  7)     # rgb = (0xff,0x5e,0x07)
+    (241,100,  7)     # rgb = (0xf1,0x64,0x07)
+    (  0,101,255)     # rgb = (0x00,0x65,0xff)
+    (253,105,  7)     # rgb = (0xfd,0x69,0x07)
+    (  0,107,223)     # rgb = (0x00,0x6b,0xdf)
+    (255,106,  7)     # rgb = (0xff,0x6a,0x07)
+    (  1,110, 95)     # rgb = (0x01,0x6e,0x5f)
+    (255,115,  7)     # rgb = (0xff,0x73,0x07)
+    (  0,117,255)     # rgb = (0x00,0x75,0xff)
+    (255,124,  7)     # rgb = (0xff,0x7c,0x07)
+    (118,126, 10)     # rgb = (0x76,0x7e,0x0a)
+    (  0,130,250)     # rgb = (0x00,0x82,0xfa)
+    (  0,132,255)     # rgb = (0x00,0x84,0xff)
+    (  0,134,207)     # rgb = (0x00,0x86,0xcf)
+    (255,134,  7)     # rgb = (0xff,0x86,0x07)
+    (  0,136,249)     # rgb = (0x00,0x88,0xf9)
+    (219,140,  6)     # rgb = (0xdb,0x8c,0x06)
+    (  0,140,252)     # rgb = (0x00,0x8c,0xfc)
+    (  0,140,255)     # rgb = (0x00,0x8c,0xff)
+    (  1,142,136)     # rgb = (0x01,0x8e,0x88)
+    (255,143,  7)     # rgb = (0xff,0x8f,0x07)
+    (243,150,  7)     # rgb = (0xf3,0x96,0x07)
+    (198,152,  7)     # rgb = (0xc6,0x98,0x07)
+    (165,153,  7)     # rgb = (0xa5,0x99,0x07)
+    (  0,157,255)     # rgb = (0x00,0x9d,0xff)
+    (255,158,  7)     # rgb = (0xff,0x9e,0x07)
+    ( 70,159,  4)     # rgb = (0x46,0x9f,0x04)
+    (  0,160,251)     # rgb = (0x00,0xa0,0xfb)
+    (203,163,  6)     # rgb = (0xcb,0xa3,0x06)
+    (  0,163,239)     # rgb = (0x00,0xa3,0xef)
+    (  1,164,178)     # rgb = (0x01,0xa4,0xb2)
+    (255,166,  7)     # rgb = (0xff,0xa6,0x07)
+    (  1,169,165)     # rgb = (0x01,0xa9,0xa5)
+    (  1,170,255)     # rgb = (0x01,0xaa,0xff)
+    (232,172,  6)     # rgb = (0xe8,0xac,0x06)
+    (255,175,  7)     # rgb = (0xff,0xaf,0x07)
+    (185,176,131)     # rgb = (0xb9,0xb0,0x83)
+    (  1,179,225)     # rgb = (0x01,0xb3,0xe1)
+    (188,179,118)     # rgb = (0xbc,0xb3,0x76)
+    (199,180,  6)     # rgb = (0xc7,0xb4,0x06)
+    (  1,182,255)     # rgb = (0x01,0xb6,0xff)
+    (  1,184,249)     # rgb = (0x01,0xb8,0xf9)
+    (255,184,  7)     # rgb = (0xff,0xb8,0x07)
+    (207,186, 71)     # rgb = (0xcf,0xba,0x47)
+    (193,187,  6)     # rgb = (0xc1,0xbb,0x06)
+    (253,191,  7)     # rgb = (0xfd,0xbf,0x07)
+    (218,193, 48)     # rgb = (0xda,0xc1,0x30)
+    (  1,193,157)     # rgb = (0x01,0xc1,0x9d)
+    (  1,196,244)     # rgb = (0x01,0xc4,0xf4)
+    (  1,196,254)     # rgb = (0x01,0xc4,0xfe)
+    ( 48,199,  3)     # rgb = (0x30,0xc7,0x03)
+    (164,199,  5)     # rgb = (0xa4,0xc7,0x05)
+    (220,202,  6)     # rgb = (0xdc,0xca,0x06)
+    (253,203,  7)     # rgb = (0xfd,0xcb,0x07)
+    (  1,204,204)     # rgb = (0x01,0xcc,0xcc)
+    (251,209,  7)     # rgb = (0xfb,0xd1,0x07)
+    (231,208, 24)     # rgb = (0xe7,0xd0,0x18)
+    (  1,210,254)     # rgb = (0x01,0xd2,0xfe)
+    (  2,211,146)     # rgb = (0x02,0xd3,0x92)
+    (  1,212,156)     # rgb = (0x01,0xd4,0x9c)
+    (  1,213,252)     # rgb = (0x01,0xd5,0xfc)
+    (237,219, 15)     # rgb = (0xed,0xdb,0x0f)
+    (  1,218,240)     # rgb = (0x01,0xda,0xf0)
+    (165,220,  5)     # rgb = (0xa5,0xdc,0x05)
+    (  1,221,250)     # rgb = (0x01,0xdd,0xfa)
+    (249,221,  6)     # rgb = (0xf9,0xdd,0x06)
+    (146,222,  4)     # rgb = (0x92,0xde,0x04)
+    (  1,224,184)     # rgb = (0x01,0xe0,0xb8)
+    (  2,224,155)     # rgb = (0x02,0xe0,0x9b)
+    (244,225, 10)     # rgb = (0xf4,0xe1,0x0a)
+    (249,227,  7)     # rgb = (0xf9,0xe3,0x07)
+    (  2,229,133)     # rgb = (0x02,0xe5,0x85)
+    (192,228,  6)     # rgb = (0xc0,0xe4,0x06)
+    ( 37,230,  3)     # rgb = (0x25,0xe6,0x03)
+    (246,230,  7)     # rgb = (0xf6,0xe6,0x07)
+    (143,232,  4)     # rgb = (0x8f,0xe8,0x04)
+    (244,233,  8)     # rgb = (0xf4,0xe9,0x08)
+    (  2,236,139)     # rgb = (0x02,0xec,0x8b)
+    (  1,236,227)     # rgb = (0x01,0xec,0xe3)
+    (  1,238,238)     # rgb = (0x01,0xee,0xee)
+    (101,241,  4)     # rgb = (0x65,0xf1,0x04)
+    (  1,241,218)     # rgb = (0x01,0xf1,0xda)
+    (  1,240,232)     # rgb = (0x01,0xf0,0xe8)
+    (167,240,  5)     # rgb = (0xa7,0xf0,0x05)
+    ( 27,243,  2)     # rgb = (0x1b,0xf3,0x02)
+    (126,243,  4)     # rgb = (0x7e,0xf3,0x04)
+    (  2,246,113)     # rgb = (0x02,0xf6,0x71)
+    (133,248,  5)     # rgb = (0x85,0xf8,0x05)
+    ( 22,250,  1)     # rgb = (0x16,0xfa,0x01)
+    (  2,249,219)     # rgb = (0x02,0xf9,0xdb)
+    (148,250,  5)     # rgb = (0x94,0xfa,0x05)
+    (  2,250,199)     # rgb = (0x02,0xfa,0xc7)
+    (183,252,  5)     # rgb = (0xb7,0xfc,0x05)
+    (176,252,  5)     # rgb = (0xb0,0xfc,0x05)
+    (  2,252,211)     # rgb = (0x02,0xfc,0xd3)
+    (  2,252,190)     # rgb = (0x02,0xfc,0xbe)
+    (164,251,  5)     # rgb = (0xa4,0xfb,0x05)
+    ( 12,254,128)     # rgb = (0x0c,0xfe,0x80)
+    (192,253,  5)     # rgb = (0xc0,0xfd,0x05)
+    (164,253,  5)     # rgb = (0xa4,0xfd,0x05)
+    ( 26,254, 85)     # rgb = (0x1a,0xfe,0x55)
+    ( 14,254,  1)     # rgb = (0x0e,0xfe,0x01)
+    (133,253,  5)     # rgb = (0x85,0xfd,0x05)
+    (  4,253,180)     # rgb = (0x04,0xfd,0xb4)
+    (196,253,  5)     # rgb = (0xc4,0xfd,0x05)
+    (  2,253,198)     # rgb = (0x02,0xfd,0xc6)
+    (  3,255, 91)     # rgb = (0x03,0xff,0x5b)
+    (  3,255, 80)     # rgb = (0x03,0xff,0x50)
+    (186,255,  5)     # rgb = (0xba,0xff,0x05)
+    (  9,255,  2)     # rgb = (0x09,0xff,0x02)
+    (  3,255,118)     # rgb = (0x03,0xff,0x76)
+    (  9,255,  3)     # rgb = (0x09,0xff,0x03)
+    ( 10,255,  1)     # rgb = (0x0a,0xff,0x01)
+    (  3,255, 76)     # rgb = (0x03,0xff,0x4c)
+    (  3,255, 86)     # rgb = (0x03,0xff,0x56)
+    (  3,255, 82)     # rgb = (0x03,0xff,0x52)
+    ( 13,255,  1)     # rgb = (0x0d,0xff,0x01)
+    (  3,255, 49)     # rgb = (0x03,0xff,0x31)
+    (  3,255,101)     # rgb = (0x03,0xff,0x65)
+    ( 61,255, 32)     # rgb = (0x3d,0xff,0x20)
+    (129,255,  5)     # rgb = (0x81,0xff,0x05)
+    (177,255,  5)     # rgb = (0xb1,0xff,0x05)
+    (  3,255, 37)     # rgb = (0x03,0xff,0x25)
+    (149,255,  5)     # rgb = (0x95,0xff,0x05)
+    (  7,255,  6)     # rgb = (0x07,0xff,0x06)
+    (192,255,  5)     # rgb = (0xc0,0xff,0x05)
+    (  2,255,131)     # rgb = (0x02,0xff,0x83)
+    (  3,255, 98)     # rgb = (0x03,0xff,0x62)
+    ( 85,255, 11)     # rgb = (0x55,0xff,0x0b)
+    (  2,255,163)     # rgb = (0x02,0xff,0xa3)
+    (  2,255,149)     # rgb = (0x02,0xff,0x95)
+    (  4,255, 23)     # rgb = (0x04,0xff,0x17)
+    (  6,255, 12)     # rgb = (0x06,0xff,0x0c)
+    (  3,255, 67)     # rgb = (0x03,0xff,0x43)
+    (160,255,  5)     # rgb = (0xa0,0xff,0x05)
+    (119,255,  6)     # rgb = (0x77,0xff,0x06)
+    (102,255,  8)     # rgb = (0x66,0xff,0x08)
+    (255,255,255)     # rgb = (0xff,0xff,0xff)
+    (254,254,254)     # rgb = (0xfe,0xfe,0xfe)
+    (254,254,254)     # rgb = (0xfe,0xfe,0xfe)
+    (252,252,252)     # rgb = (0xfc,0xfc,0xfc)
+    (252,252,252)     # rgb = (0xfc,0xfc,0xfc)
+    (250,250,250)     # rgb = (0xfa,0xfa,0xfa)
+    (250,250,250)     # rgb = (0xfa,0xfa,0xfa)
+    (248,248,248)     # rgb = (0xf8,0xf8,0xf8)
+    (248,248,248)     # rgb = (0xf8,0xf8,0xf8)
+    (247,247,247)     # rgb = (0xf7,0xf7,0xf7)
+    (245,245,245)     # rgb = (0xf5,0xf5,0xf5)
+    (245,245,245)     # rgb = (0xf5,0xf5,0xf5)
+    (243,243,243)     # rgb = (0xf3,0xf3,0xf3)
+    (243,243,243)     # rgb = (0xf3,0xf3,0xf3)
+    (241,241,241)     # rgb = (0xf1,0xf1,0xf1)
+    (241,241,241)     # rgb = (0xf1,0xf1,0xf1)
+    (239,239,239)     # rgb = (0xef,0xef,0xef)
+    (238,238,238)     # rgb = (0xee,0xee,0xee)
+    (238,238,238)     # rgb = (0xee,0xee,0xee)
+    (236,236,236)     # rgb = (0xec,0xec,0xec)
+    (236,236,236)     # rgb = (0xec,0xec,0xec)
+    (234,234,234)     # rgb = (0xea,0xea,0xea)
+    (234,234,234)     # rgb = (0xea,0xea,0xea)
+    (232,232,232)     # rgb = (0xe8,0xe8,0xe8)
+    (231,231,231)     # rgb = (0xe7,0xe7,0xe7)
+    (231,231,231)     # rgb = (0xe7,0xe7,0xe7)
+    (229,229,229)     # rgb = (0xe5,0xe5,0xe5)
+    (229,229,229)     # rgb = (0xe5,0xe5,0xe5)
+    (227,227,227)     # rgb = (0xe3,0xe3,0xe3)
+    (226,226,226)     # rgb = (0xe2,0xe2,0xe2)
+    (226,226,226)     # rgb = (0xe2,0xe2,0xe2)
+    (224,224,224)     # rgb = (0xe0,0xe0,0xe0)
+    (224,224,224)     # rgb = (0xe0,0xe0,0xe0)
+    (222,222,222)     # rgb = (0xde,0xde,0xde)
+    (222,222,222)     # rgb = (0xde,0xde,0xde)
+    (220,220,220)     # rgb = (0xdc,0xdc,0xdc)
+    (219,219,219)     # rgb = (0xdb,0xdb,0xdb)
+    (219,219,219)     # rgb = (0xdb,0xdb,0xdb)
+    (217,217,217)     # rgb = (0xd9,0xd9,0xd9)
+    (217,217,217)     # rgb = (0xd9,0xd9,0xd9)
+    (215,215,215)     # rgb = (0xd7,0xd7,0xd7)
+    (214,214,214)     # rgb = (0xd6,0xd6,0xd6)
+    (214,214,214)     # rgb = (0xd6,0xd6,0xd6)
+    (212,212,212)     # rgb = (0xd4,0xd4,0xd4)
+    (212,212,212)     # rgb = (0xd4,0xd4,0xd4)
+    (210,210,210)     # rgb = (0xd2,0xd2,0xd2)
+    (209,209,209)     # rgb = (0xd1,0xd1,0xd1)
+    (209,209,209)     # rgb = (0xd1,0xd1,0xd1)
+    (207,207,207)     # rgb = (0xcf,0xcf,0xcf)
+    (205,205,205)     # rgb = (0xcd,0xcd,0xcd)
+    (205,205,205)     # rgb = (0xcd,0xcd,0xcd)
+    (204,204,204)     # rgb = (0xcc,0xcc,0xcc)
+    (204,204,204)     # rgb = (0xcc,0xcc,0xcc)
+    (202,202,202)     # rgb = (0xca,0xca,0xca)
+    (201,201,201)     # rgb = (0xc9,0xc9,0xc9)
+    (201,201,201)     # rgb = (0xc9,0xc9,0xc9)
+    (199,199,199)     # rgb = (0xc7,0xc7,0xc7)
+    (199,199,199)     # rgb = (0xc7,0xc7,0xc7)
+    (197,197,197)     # rgb = (0xc5,0xc5,0xc5)
+    (196,196,196)     # rgb = (0xc4,0xc4,0xc4)
+    (196,196,196)     # rgb = (0xc4,0xc4,0xc4)
+    (194,194,194)     # rgb = (0xc2,0xc2,0xc2)
+    (193,193,193)     # rgb = (0xc1,0xc1,0xc1)
+    (193,193,193)     # rgb = (0xc1,0xc1,0xc1)
+    (191,191,191)     # rgb = (0xbf,0xbf,0xbf)
+    (191,191,191)     # rgb = (0xbf,0xbf,0xbf)
+    (189,189,189)     # rgb = (0xbd,0xbd,0xbd)
+    (188,188,188)     # rgb = (0xbc,0xbc,0xbc)
+    (188,188,188)     # rgb = (0xbc,0xbc,0xbc)
+    (186,186,186)     # rgb = (0xba,0xba,0xba)
+    (185,185,185)     # rgb = (0xb9,0xb9,0xb9)
+    (185,185,185)     # rgb = (0xb9,0xb9,0xb9)
+    (183,183,183)     # rgb = (0xb7,0xb7,0xb7)
+    (182,182,182)     # rgb = (0xb6,0xb6,0xb6)
+    (182,182,182)     # rgb = (0xb6,0xb6,0xb6)
+    (180,180,180)     # rgb = (0xb4,0xb4,0xb4)
+    (178,178,178)     # rgb = (0xb2,0xb2,0xb2)
+    (178,178,178)     # rgb = (0xb2,0xb2,0xb2)
+    (177,177,177)     # rgb = (0xb1,0xb1,0xb1)
+    (177,177,177)     # rgb = (0xb1,0xb1,0xb1)
+    (175,175,175)     # rgb = (0xaf,0xaf,0xaf)
+    (174,174,174)     # rgb = (0xae,0xae,0xae)
+    (174,174,174)     # rgb = (0xae,0xae,0xae)
+}
+tRNS {
+ 197 187 190 194 186 4 186 189 4 195 84 191 5 193 175 163 205 150 191 213 88 75 67 8 147 191 220 203 95 151 223 199 8 207 156 227 199 65 163 98 226 204 12 202 167 201 11 65 178 228 205 74 59 87 178 19 201 99 18 14 184 204 184 96 22 61 227 199 22 193 97 197 254 59 253 28 192 102 199 247 58 198 244 30 109 202 188 32 96 196 60 203 239 202 230 41 207 237 119 53 213 209 37 55 45 230 214 233 92 185 223 50 230 57 124 217 43 133 221 95 198 47 233 99 194 221 107 138 152 144 226 140 133 220 172 125 218 196 118 225 161 223 235 238 200 155 147 146 172 236 236 151 183 150 234 216 217 211 151 219 132 185 145 147 217 138 144 137 142 151 217 217 213}
+IMAGE {
+    pixels hex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}

libgo/go/json/decode.go

@@ -140,6 +140,7 @@ type decodeState struct {
 	scan       scanner
 	nextscan   scanner // for calls to nextValue
 	savedError os.Error
+	tempstr    string // scratch space to avoid some allocations
 }
 
 // errPhase is used for errors that should not happen unless
@@ -470,6 +471,8 @@ func (d *decodeState) object(v reflect.Value) {
 
 		// Figure out field corresponding to key.
 		var subv reflect.Value
+		destring := false // whether the value is wrapped in a string to be decoded first
+
 		if mv.IsValid() {
 			elemType := mv.Type().Elem()
 			if !mapElem.IsValid() {
@@ -486,7 +489,8 @@ func (d *decodeState) object(v reflect.Value) {
 			if isValidTag(key) {
 				for i := 0; i < sv.NumField(); i++ {
 					f = st.Field(i)
-					if f.Tag.Get("json") == key {
+					tagName, _ := parseTag(f.Tag.Get("json"))
+					if tagName == key {
 						ok = true
 						break
 					}
@@ -508,6 +512,8 @@ func (d *decodeState) object(v reflect.Value) {
 				} else {
 					subv = sv.FieldByIndex(f.Index)
 				}
+				_, opts := parseTag(f.Tag.Get("json"))
+				destring = opts.Contains("string")
 			}
 		}
 
@@ -520,8 +526,12 @@ func (d *decodeState) object(v reflect.Value) {
 		}
 
 		// Read value.
-		d.value(subv)
-
+		if destring {
+			d.value(reflect.ValueOf(&d.tempstr))
+			d.literalStore([]byte(d.tempstr), subv)
+		} else {
+			d.value(subv)
+		}
 		// Write value back to map;
 		// if using struct, subv points into struct already.
 		if mv.IsValid() {
@@ -550,8 +560,12 @@ func (d *decodeState) literal(v reflect.Value) {
 	// Scan read one byte too far; back up.
 	d.off--
 	d.scan.undo(op)
-	item := d.data[start:d.off]
 
+	d.literalStore(d.data[start:d.off], v)
+}
+
+// literalStore decodes a literal stored in item into v.
+func (d *decodeState) literalStore(item []byte, v reflect.Value) {
 	// Check for unmarshaler.
 	wantptr := item[0] == 'n' // null
 	unmarshaler, pv := d.indirect(v, wantptr)

libgo/go/json/decode_test.go

@@ -262,7 +262,10 @@ type All struct {
 	Float32 float32
 	Float64 float64
 
-	Foo string `json:"bar"`
+	Foo  string `json:"bar"`
+	Foo2 string `json:"bar2,dummyopt"`
+
+	IntStr int64 `json:",string"`
 
 	PBool    *bool
 	PInt     *int
@@ -331,6 +334,8 @@ var allValue = All{
 	Float32: 14.1,
 	Float64: 15.1,
 	Foo:     "foo",
+	Foo2:    "foo2",
+	IntStr:  42,
 	String:  "16",
 	Map: map[string]Small{
 		"17": {Tag: "tag17"},
@@ -391,6 +396,8 @@ var allValueIndent = `{
 	"Float32": 14.1,
 	"Float64": 15.1,
 	"bar": "foo",
+	"bar2": "foo2",
+	"IntStr": "42",
 	"PBool": null,
 	"PInt": null,
 	"PInt8": null,
@@ -481,6 +488,8 @@ var pallValueIndent = `{
 	"Float32": 0,
 	"Float64": 0,
 	"bar": "",
+	"bar2": "",
+        "IntStr": "0",
 	"PBool": true,
 	"PInt": 2,
 	"PInt8": 3,

libgo/go/json/encode.go

@@ -4,6 +4,9 @@
 
 // Package json implements encoding and decoding of JSON objects as defined in
 // RFC 4627.
+//
+// See "JSON and Go" for an introduction to this package:
+// http://blog.golang.org/2011/01/json-and-go.html
 package json
 
 import (
@@ -14,7 +17,6 @@ import (
 	"runtime"
 	"sort"
 	"strconv"
-	"strings"
 	"unicode"
 	"utf8"
 )
@@ -59,6 +61,12 @@ import (
 //   // Note the leading comma.
 //   Field int `json:",omitempty"`
 //
+// The "string" option signals that a field is stored as JSON inside a
+// JSON-encoded string.  This extra level of encoding is sometimes
+// used when communicating with JavaScript programs:
+//
+//    Int64String int64 `json:",string"`
+//
 // The key name will be used if it's a non-empty string consisting of
 // only Unicode letters, digits, dollar signs, hyphens, and underscores.
 //
@@ -221,6 +229,12 @@ func isEmptyValue(v reflect.Value) bool {
 }
 
 func (e *encodeState) reflectValue(v reflect.Value) {
+	e.reflectValueQuoted(v, false)
+}
+
+// reflectValueQuoted writes the value in v to the output.
+// If quoted is true, the serialization is wrapped in a JSON string.
+func (e *encodeState) reflectValueQuoted(v reflect.Value, quoted bool) {
 	if !v.IsValid() {
 		e.WriteString("null")
 		return
@@ -238,26 +252,39 @@ func (e *encodeState) reflectValue(v reflect.Value) {
 		return
 	}
 
+	writeString := (*encodeState).WriteString
+	if quoted {
+		writeString = (*encodeState).string
+	}
+
 	switch v.Kind() {
 	case reflect.Bool:
 		x := v.Bool()
 		if x {
-			e.WriteString("true")
+			writeString(e, "true")
 		} else {
-			e.WriteString("false")
+			writeString(e, "false")
 		}
 
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		e.WriteString(strconv.Itoa64(v.Int()))
+		writeString(e, strconv.Itoa64(v.Int()))
 
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		e.WriteString(strconv.Uitoa64(v.Uint()))
+		writeString(e, strconv.Uitoa64(v.Uint()))
 
 	case reflect.Float32, reflect.Float64:
-		e.WriteString(strconv.FtoaN(v.Float(), 'g', -1, v.Type().Bits()))
+		writeString(e, strconv.FtoaN(v.Float(), 'g', -1, v.Type().Bits()))
 
 	case reflect.String:
-		e.string(v.String())
+		if quoted {
+			sb, err := Marshal(v.String())
+			if err != nil {
+				e.error(err)
+			}
+			e.string(string(sb))
+		} else {
+			e.string(v.String())
+		}
 
 	case reflect.Struct:
 		e.WriteByte('{')
@@ -269,17 +296,14 @@ func (e *encodeState) reflectValue(v reflect.Value) {
 			if f.PkgPath != "" {
 				continue
 			}
-			tag, omitEmpty := f.Name, false
+			tag, omitEmpty, quoted := f.Name, false, false
 			if tv := f.Tag.Get("json"); tv != "" {
-				ss := strings.SplitN(tv, ",", 2)
-				if isValidTag(ss[0]) {
-					tag = ss[0]
-				}
-				if len(ss) > 1 {
-					// Currently the only option is omitempty,
-					// so parsing is trivial.
-					omitEmpty = ss[1] == "omitempty"
+				name, opts := parseTag(tv)
+				if isValidTag(name) {
+					tag = name
 				}
+				omitEmpty = opts.Contains("omitempty")
+				quoted = opts.Contains("string")
 			}
 			fieldValue := v.Field(i)
 			if omitEmpty && isEmptyValue(fieldValue) {
@@ -292,7 +316,7 @@ func (e *encodeState) reflectValue(v reflect.Value) {
 			}
 			e.string(tag)
 			e.WriteByte(':')
-			e.reflectValue(fieldValue)
+			e.reflectValueQuoted(fieldValue, quoted)
 		}
 		e.WriteByte('}')
 
@@ -380,7 +404,8 @@ func (sv stringValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
 func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
 func (sv stringValues) get(i int) string   { return sv[i].String() }
 
-func (e *encodeState) string(s string) {
+func (e *encodeState) string(s string) (int, os.Error) {
+	len0 := e.Len()
 	e.WriteByte('"')
 	start := 0
 	for i := 0; i < len(s); {
@@ -425,4 +450,5 @@ func (e *encodeState) string(s string) {
 		e.WriteString(s[start:])
 	}
 	e.WriteByte('"')
+	return e.Len() - len0, nil
 }

libgo/go/json/encode_test.go

@@ -5,6 +5,8 @@
 package json
 
 import (
+	"bytes"
+	"reflect"
 	"testing"
 )
 
@@ -42,3 +44,39 @@ func TestOmitEmpty(t *testing.T) {
 		t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected)
 	}
 }
+
+type StringTag struct {
+	BoolStr bool   `json:",string"`
+	IntStr  int64  `json:",string"`
+	StrStr  string `json:",string"`
+}
+
+var stringTagExpected = `{
+ "BoolStr": "true",
+ "IntStr": "42",
+ "StrStr": "\"xzbit\""
+}`
+
+func TestStringTag(t *testing.T) {
+	var s StringTag
+	s.BoolStr = true
+	s.IntStr = 42
+	s.StrStr = "xzbit"
+	got, err := MarshalIndent(&s, "", " ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(got); got != stringTagExpected {
+		t.Fatalf(" got: %s\nwant: %s\n", got, stringTagExpected)
+	}
+
+	// Verify that it round-trips.
+	var s2 StringTag
+	err = NewDecoder(bytes.NewBuffer(got)).Decode(&s2)
+	if err != nil {
+		t.Fatalf("Decode: %v", err)
+	}
+	if !reflect.DeepEqual(s, s2) {
+		t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", s, string(got), s2)
+	}
+}

libgo/go/json/tags.go

@@ -0,0 +1,44 @@
+// Copyright 2011 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 json
+
+import (
+	"strings"
+)
+
+// tagOptions is the string following a comma in a struct field's "json"
+// tag, or the empty string. It does not include the leading comma.
+type tagOptions string
+
+// parseTag splits a struct field's json tag into its name and
+// comma-separated options.
+func parseTag(tag string) (string, tagOptions) {
+	if idx := strings.Index(tag, ","); idx != -1 {
+		return tag[:idx], tagOptions(tag[idx+1:])
+	}
+	return tag, tagOptions("")
+}
+
+// Contains returns whether checks that a comma-separated list of options
+// contains a particular substr flag. substr must be surrounded by a
+// string boundary or commas.
+func (o tagOptions) Contains(optionName string) bool {
+	if len(o) == 0 {
+		return false
+	}
+	s := string(o)
+	for s != "" {
+		var next string
+		i := strings.Index(s, ",")
+		if i >= 0 {
+			s, next = s[:i], s[i+1:]
+		}
+		if s == optionName {
+			return true
+		}
+		s = next
+	}
+	return false
+}

libgo/go/json/tags_test.go

@@ -0,0 +1,28 @@
+// Copyright 2011 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 json
+
+import (
+	"testing"
+)
+
+func TestTagParsing(t *testing.T) {
+	name, opts := parseTag("field,foobar,foo")
+	if name != "field" {
+		t.Fatalf("name = %q, want field", name)
+	}
+	for _, tt := range []struct {
+		opt  string
+		want bool
+	}{
+		{"foobar", true},
+		{"foo", true},
+		{"bar", false},
+	} {
+		if opts.Contains(tt.opt) != tt.want {
+			t.Errorf("Contains(%q) = %v", tt.opt, !tt.want)
+		}
+	}
+}

libgo/go/reflect/type.go

@@ -10,6 +10,9 @@
 // A call to ValueOf returns a Value representing the run-time data.
 // Zero takes a Type and returns a Value representing a zero value
 // for that type.
+//
+// See "The Laws of Reflection" for an introduction to reflection in Go:
+// http://blog.golang.org/2011/09/laws-of-reflection.html
 package reflect
 
 import (

libgo/merge.sh

@@ -40,7 +40,7 @@ hg clone -r ${old_rev} ${repository} ${OLDDIR}
 rm -rf ${NEWDIR}
 hg clone -u release ${repository} ${NEWDIR}
 
-new_rev=`cd ${NEWDIR} && hg log | sed 1q | sed -e 's/.*://'`
+new_rev=`cd ${NEWDIR} && hg log -r release | sed 1q | sed -e 's/.*://'`
 
 merge() {
   name=$1