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

R=rsc, ken2, ken3
https://golang.org/cl/174042

registers.

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

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

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

R=rsc, r
https://golang.org/cl/172045

R=rsc, r
https://golang.org/cl/171051

- remove use of implicit string concatenation
- these appear to be the only files correctly compiling under test
  that used implicit string concatenation

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

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

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

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

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

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

   and release.2009-12-09 (where we are)

shorten tags because it is too hard to look up the
full size hash and overkill anyway.

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

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

removed superfluous field name in lockedSource.

R=r, rsc
https://golang.org/cl/170043

negative counts in return values.

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

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

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

UTF-8 string, Yconv() converts it into an octal sequence. If the
string converted to more than 30 bytes, the str buffer would
overflow. For example, 4 Greek runes became 32 bytes, 3 Hiragana
runes became 36 bytes, and 2 Gothic runes became 32 bytes. In
8l, 6l and 5l the function is Sconv(). For some reason, only 5l uses
the constant STRINGSZ (defined as 200) for the buffer size.

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

Fixes #400.

R=golang-dev, rsc
https://golang.org/cl/167058

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

This is an adaption of the code from http://en.wikipedia.org/wiki/XTEA. The package also implements the block.Cipher
interface so that it can be used with the various block modes.

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

    then enable stack check.

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

   Kei Son has completed the CLA.
   Yves Junqueira is a Google employee.

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

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

FreeBSD was passing stk as the new thread's stack base, while
stk is the top of the stack in go. The added check should cause
a trap if this ever comes up in any new ports, or regresses
in current ones.

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

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

Fixes #221.

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

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

cuts working size for hello world from 6 MB to 1.2 MB.
still some work to be done, but diminishing returns.

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

    to provide functionality previously hacked in to
    reflect and gob.

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

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

R=r, rsc
https://golang.org/cl/165068

the one-item case could be generalized easily with no cost. worth considering.

R=rsc
CC=golang-dev, cw
https://golang.org/cl/167044

nodes in the tree are nested with respect to one another.
a simple change to the Visitor interface makes it possible
to do this (for example to maintain a current node-depth, or a
knowledge of the name of the current function).

Visit(nil) is called at the end of a node's children;
this make possible the channel-based interface below,
amongst other possibilities.

It is still just as simple to get the original behaviour - just
return the same Visitor from Visit.

Here are a couple of possible Visitor types.

// closure-based
type FVisitor func(n interface{}) FVisitor
func (f FVisitor) Visit(n interface{}) Visitor {
	return f(n);
}

// channel-based
type CVisitor chan Visit;
type Visit struct {
	node interface{};
	reply chan CVisitor;
};
func (v CVisitor) Visit(n interface{}) Visitor
{
	if n == nil {
		close(v);
	} else {
		reply := make(chan CVisitor);
		v <- Visit{n, reply};
		r := <-reply;
		if r == nil {
			return nil;
		}
		return r;
	}
	return nil;
}

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

it's now there: http://shootout.alioth.debian.org/u32q/benchmark.php?test=chameneosredux&lang=all&box=1!

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

a couple of cleanups.
don't keep big buffers in the free list.

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

cleans up godoc's output for package fmt substantially.

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

Roughly 33% faster for simple cases, probably more for complex ones.

Before:

mallocs per Sprintf(""): 4
mallocs per Sprintf("xxx"): 6
mallocs per Sprintf("%x"): 10
mallocs per Sprintf("%x %x"): 12

Now:

mallocs per Sprintf(""): 2
mallocs per Sprintf("xxx"): 3
mallocs per Sprintf("%x"): 5
mallocs per Sprintf("%x %x"): 7

Speed improves because of avoiding mallocs and also by sharing a bytes.Buffer
between print.go and format.go rather than copying the data back after each
printed item.

Before:

fmt_test.BenchmarkSprintfEmpty	1000000	      1346 ns/op
fmt_test.BenchmarkSprintfString	500000	      3461 ns/op
fmt_test.BenchmarkSprintfInt	500000	      3671 ns/op

Now:

fmt_test.BenchmarkSprintfEmpty	 2000000	       995 ns/op
fmt_test.BenchmarkSprintfString	 1000000	      2745 ns/op
fmt_test.BenchmarkSprintfInt	 1000000	      2391 ns/op
fmt_test.BenchmarkSprintfIntInt	  500000	      3751 ns/op

I believe there is more to get but this is a good milestone.

R=rsc
CC=golang-dev, hong
https://golang.org/cl/166076