reported by erik quanstrom.

R=ken2
https://golang.org/cl/181071

also a way to run code when object is deleted.
both of these are possibilities, not certainties.

R=rsc, iant
CC=golang-dev
https://golang.org/cl/181057

a possible interface for more granular sleep times.

Fixes issue #260.

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

(i thought these were legal in <pre> blocks)

R=rsc
CC=golang-dev, pwil3058
https://golang.org/cl/181055

R=dsymonds1
CC=golang-dev
https://golang.org/cl/183049

gccgo currently miscompiles this test.

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

Without this change, the spec parses <-c.(type) as (<-c).(type)
but parses <-c.(int) as <-(c.(int)).

With this change, the former parses as <-(c.(type)).

All three parsers already implement this rule, because
they look for the "type" word during parsing of a standard
type assertion.  This change merely brings the
spec in line with the implementations.

http://code.google.com/p/go/source/browse/src/cmd/gc/go.y#801
http://code.google.com/p/go/source/browse/src/pkg/go/parser/parser.go#900
http://gcc.gnu.org/viewcvs/branches/gccgo/gcc/go/parse.cc?revision=155389&view=markup#l2469

Pointed out by Brett Kail on golang-nuts.

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

This was convenient for me to have without being forced
to parse the regexp myself. I'd understand if it's not
really wanted, but I also think that some meta information
about compiled regexps would be fine.

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

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

Fixes #309.

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

for now, it's amd64 and 386 only but it's trivial to add more.

Fixes #385.

(why couldn't it have been issue 386?)

tested for amd64 and 386 on darwin.

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

Add support for TLS extensions in general and Next Protocol
Negotiation in particular.

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

It's expected to be shared between all files so that all types are output.
Fixes bug reported on mailing list by Peter Froehlich.

R=rsc, phf
CC=golang-dev
https://golang.org/cl/183043

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

Fixes #452.

R=gri
CC=golang-dev, dougfelt
https://golang.org/cl/181043

as it is not needed anymore (only one impl.
of vector package).

Makefile, vector_test.go, and nogen_test.go
were modified manually (find/replace), the
other files (intvector_test.go, strinvector_test.go
are generated).

Runs all tests.

R=r
https://golang.org/cl/182041

Manual changes to the following files:
src/pkg/Makefile
src/pkg/exp/vector/Makefile (now: src/pkg/container/vector/Makefile)

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

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

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

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

- use an interface {Get()}
- implement Get for maps, slices
- for slices, retrieves the address of the end of the array, which will give the
	same value for every slice of the same array.

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

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

(Also fix case sensitivity in test for PTR inside fmt_test.go)
Fixes #441.

R=rsc, iant
CC=golang-dev
https://golang.org/cl/180112

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

R=gri
CC=rsc
https://golang.org/cl/178048

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

Fixes #436.

R=ken2
https://golang.org/cl/180105

R=dho
CC=golang-dev
https://golang.org/cl/180099

gccgo currently fails this test.

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

R=ken2
https://golang.org/cl/180092

corrects a common misunderstanding about NewBuffer.

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

(Thanks to ken and rsc for pointing this out)

rsc:
	ken pointed out that there's a race in the new
	one-lock-per-channel code.  the issue is that
	if one goroutine has gone to sleep doing

	select {
	case <-c1:
	case <-c2:
	}

	and then two more goroutines try to send
	on c1 and c2 simultaneously, the way that
	the code makes sure only one wins is the
	selgen field manipulation in dequeue:

	       // if sgp is stale, ignore it
	       if(sgp->selgen != sgp->g->selgen) {
		       //prints("INVALID PSEUDOG POINTER\n");
		       freesg(c, sgp);
		       goto loop;
	       }

	       // invalidate any others
	       sgp->g->selgen++;

	but because the global lock is gone both
	goroutines will be fiddling with sgp->g->selgen
	at the same time.

This results in a 7% slowdown in the single threaded case for a
ping-pong microbenchmark.

Since the cas predominantly succeeds, adding a simple check first
didn't make any difference.

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

now that the parser doesn't do this test anymore

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

added more test cases
some capitalization cleanups

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

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

R=dho, phf
CC=golang-dev
https://golang.org/cl/180082

Fixes #443.

R=dho
CC=golang-dev
https://golang.org/cl/179095

        them in the stream.

R=rsc
https://golang.org/cl/174052

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

R=ken2
CC=dho
https://golang.org/cl/179097