R=r
CC=golang-dev
https://golang.org/cl/3026041

R=r, r2
CC=golang-dev
https://golang.org/cl/3024041

R=gri
CC=golang-dev
https://golang.org/cl/2986042

R=gri
CC=golang-dev
https://golang.org/cl/3022041

When searching a list of directories, the files which match
the pattern are accumulated in a slice.  If the glob has a
wildcard for the directory, and the wildcard matches a file
rather than a directory, then the files found so far are
discarded.  E.g., path.Glob("*/x") in a directory which
contains both files and subdirectories.  This patch avoids
discarding matches found so far when a file is found.

R=r
CC=bsiegert, golang-dev
https://golang.org/cl/3015042

R=r, r2
CC=golang-dev
https://golang.org/cl/2997041

[it was a carry over from the previous iteration]

R=r
CC=golang-dev
https://golang.org/cl/3016041

division. resolves issue 1261.

R=rsc
CC=golang-dev
https://golang.org/cl/2985043

This is in preparation for a different position representation.
It also resolves situations where a node would be printed as
it's node position simply because the embedded token.Position
has a String method.

R=r
CC=golang-dev
https://golang.org/cl/2991041

R=gri
CC=golang-dev
https://golang.org/cl/2970042

When it is known that there is already at least one element in the
list, it is awkwardly verbose to use three lines and an extra
variable declaration to remove the first or last item (a common
case), rather than use a simple expression.

a stack:
	stk.PushFront(x)
	x = stk.Front().Remove().(T)

vs.
	stk.PushFront(x)
	e := stk.Front()
	e.Remove()
	x = e.Value.(T)
[An alternative CL might be to add PopFront and PopBack methods].

R=gri
CC=golang-dev
https://golang.org/cl/3000041

R=rsc, gri
CC=golang-dev
https://golang.org/cl/2985041

Performance on 2.8 GHz Intel Core i7:

Before:
BenchmarkIndexByte4K  1000000              2997 ns/op        1366.70 MB/s
BenchmarkIndexByte4M      500           3049772 ns/op        1375.28 MB/s
BenchmarkIndexByte64M      50          49582280 ns/op        1353.48 MB/s

After:
BenchmarkIndexByte4K 10000000               298 ns/op       13744.97 MB/s
BenchmarkIndexByte4M    10000            285993 ns/op       14665.76 MB/s
BenchmarkIndexByte64M     500           4618172 ns/op       14531.48 MB/s

R=rsc, PeterGo, r2, r
CC=golang-dev
https://golang.org/cl/2888041

Fixes #1260.

R=gri
CC=golang-dev
https://golang.org/cl/2994041

R=r
CC=golang-dev
https://golang.org/cl/2993041

Fixes #1253.

R=gri
CC=golang-dev
https://golang.org/cl/2990041

Fixes #1258.

R=gri, msolo, bradfitzpatrick, r2
CC=golang-dev
https://golang.org/cl/2988041

R=rsc
CC=golang-dev
https://golang.org/cl/2733042

R=adg, r
CC=golang-dev
https://golang.org/cl/2984041

R=rsc
CC=golang-dev
https://golang.org/cl/2932041

type Benchmark has been renamed to InternalBenchmark

R=rsc
CC=golang-dev
https://golang.org/cl/2942042

R=r, r2
CC=golang-dev
https://golang.org/cl/2938041

R=r, r2
CC=golang-dev
https://golang.org/cl/2937041

Truncate and Ftruncate for 32-bit Linux should use 64-bit
offset system calls.

R=rsc
CC=golang-dev, royger
https://golang.org/cl/2943041

(this works now that issue 751 is resolved)

R=rsc
CC=golang-dev
https://golang.org/cl/2834041

R=rsc
CC=golang-dev
https://golang.org/cl/2939041

R=rsc, r
CC=golang-dev
https://golang.org/cl/2918042

Fixes #918.

R=rsc, rog, brainman
CC=golang-dev
https://golang.org/cl/2904041

R=r, r2
CC=golang-dev, kr
https://golang.org/cl/2894042

R=r, r2
CC=golang-dev
https://golang.org/cl/2889042

PSADBW and PSHUFL had the wrong prefixes.

R=rsc
CC=golang-dev
https://golang.org/cl/2836041

As discussed in http://groups.google.com/group/golang-dev/browse_thread/thread/926b7d550d98ec9e,
add a simple "path expander" function, which returns all the
files matching the given pattern. This function is called Glob
after glob(3) in libc.

Also add a convenience function, hasMeta, that checks whether
a string contains one of the characters which are specially handled
by Match.

R=rsc, r, r2
CC=golang-dev
https://golang.org/cl/2476041

R=rsc
CC=golang-dev
https://golang.org/cl/2934041

underlying type; otherwise encoding fails when sending
a pointer value.

R=rsc
CC=golang-dev
https://golang.org/cl/2922041

Previously we checked the certificate chain from the leaf
upwards and expected to jump from the last cert in the chain to
a root certificate.

Although technically correct, there are a number of sites with
problems including out-of-order certs, superfluous certs and
missing certs.

The last of these requires AIA chasing, which is a lot of
complexity. However, we can address the more common cases by
using a pool building algorithm, as browsers do.

We build a pool of root certificates and a pool from the
server's chain. We then try to build a path to a root
certificate, using either of these pools.

This differs from the behaviour of, say, Firefox in that Firefox
will accumulate intermedite certificate in a persistent pool in
the hope that it can use them to fill in gaps in future chains.

We don't do that because it leads to confusing errors which only
occur based on the order to sites visited.

This change also enabled SNI for tls.Dial so that sites will return
the correct certificate chain.

R=rsc
CC=golang-dev
https://golang.org/cl/2916041

R=rsc
CC=golang-dev
https://golang.org/cl/2923041

R=r
CC=golang-dev
https://golang.org/cl/2925041

Consistency argument: A valid Go program should
remain valid after stripping leading and trailing
whitespace. This was not true so far if the last
text in the source was a line comment.

R=iant, ken2, r, rsc, r2
CC=golang-dev
https://golang.org/cl/2906041

Small addition to previous optimization of memequal as discussed here: http://groups.google.com/group/golang-nuts/browse_thread/thread/f591ba36d83723c0/9aba02d344045f38

R=golang-dev, r, r2
CC=golang-dev
https://golang.org/cl/2880041

R=rsc
CC=golang-dev
https://golang.org/cl/2908041