simpler fix for the negative rune problem, spotted seconds after submitting the previous fix.

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

generate replacement rune when asked to encode a negative rune value.
Fixes #425.

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

archive/tar: bug fixes.
1. If all data is exhausted using Read then a following Next will
   fail as if it saw EOF.  (Test case added.)
2. Seeking isn't always possible (i.e. sockets and pipes).  Fallback
   to read.  (Test case added.)
3. Fix to readHeader (cleaner fix pointed out by rsc).
   (TestReader modified.)
4. When Read has consumed all the data, don't try to read 0 bytes from reader.
   In cases where tr.nb is zero we attempt to read zero bytes and thus
   never see an EOF (this is most easily seen when the 'tar source' is
   something like bytes.Buffer{} as opposed to os.File).
5. If write is used to the point of ErrWriteTooLong, allow additional file entries.
6. Make close work as expected.  That is any further Write or
   WriteHeader attempts will result in ErrWriteAfterClose.
Fixes #419.

R=rsc, dsymonds1
https://golang.org/cl/162062

don't show semicolons anymore with godoc

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

A+C: two more names
Andy Davis (individual CLA)
Arvindh Rajesh Tamilmani (individual CLA)

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

fix naked < as reported by pwil3058@gmail.com

R=rsc
CC=pwil3058
https://golang.org/cl/174087

When the buffer is empty, reset b.off to the beginning of the buffer
to avoid growing unnecessarily.

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

syscall: fix error return bug for 64-bit return on 32-bit platform

R=dho, rsc
CC=r
https://golang.org/cl/176058

8l: add support for PE output.

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

clean.bash: stop if $GOROOT is not set

Doing rm -rf /pkg/.. blindly isn't nice.  It could have
unintended consequences.

Secondly set bash to abort on (unexpected) errors.

R=dho, rsc
CC=golang-dev
https://golang.org/cl/176056

Ported godefs to Windows.

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

gc: fix comment

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

Update goyacc to new syntax, still with semicolons.
Update units.y too.
Fixes #417.

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

more on the optimizer
trying to get alizses
to optimize

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

fix bug for large counts: used a one-byte buffer.

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

Various cleanups:
- no need to replace comments for stand-alone blocks
- always print string concatenations with interspersed "+"
  (remove option)
- minor cleanups

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

gc: semicolons

Fixes #89.
Fixes #92.
Fixes #118.
Fixes #182.
Fixes #328.
Fixes #340.

R=ken2, ken3
CC=golang-dev
https://golang.org/cl/172049

bug in 6g optimizer
8g still needs fixing

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

parser changed to reflect new semicolon rules

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

fix printer test for new syntax

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

Remove GOBIN in PATH dependency; don't assume cwd is $GOROOT/src

This change removes the necessity to have GOBIN in $PATH,
and also doesn't assume that the build is being run from
$GOROOT/src. This is a minimal set of necessary changes
to get Go to build happily from the FreeBSD ports
collection.

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

misc/bash: completion file for bash
suggested by Alex Ray <ajray@ncsu.edu>

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

encoding/binary: Add support for slices of arrays of fixed-size values.

R=rsc
CC=krasin
https://golang.org/cl/167050

Add a Makefile in place of all.bash. Update docs to reflect
this change.

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

syslog: new package

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

mkbuiltin: generate builtin.c directly

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

A+C:
Andrey Mirtchovski (individual CLA),
Maxim Ushakov (Google),
Yongjian Xu (individual CLA)

R=gri
https://golang.org/cl/174064

bytes, strings: allow -1 in Map to mean "drop this character".

xml: drop invalid characters in attribute names
    when constructing struct field names.

R=rsc
CC=r
https://golang.org/cl/157104

- make make test working again
- some factoring for easier experimentation

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

New flags for gofmt:
- oldparser            parse old syntax (required semicolons)
- oldprinter           print old syntax (required semicolons)

By default, these flags are enabled for now.
Setting -oldparser=false has no effect until go/parser is changed
to accept the new syntax.

Enabled exp/parser in Makefile; update dependent exp/eval.

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

rename exp/parser package to oldParser
to allow simultaneous import with the
current go/parser

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

Spec modified to reflect new semicolon rules.

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

implement NoSemis and NoStringConcat mode for go/printer

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

implemented InsertSemis mode for go/scanner

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

- unmodified copy of existing go/parser, not yet hooked up

R=rsc
CC=r
https://golang.org/cl/175045

trailing comma's are not accepted with current syntax

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

test/fixedbug: drop obsolete bug125, bug166

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

make test/ken safe for optional semis

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

fix calling convention and make memmove restore the g and m
registers.

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

added SHUT_RD, SHOT_WR and xSHUT_RDWR to fix net compilation error

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

make test/fixedbugs save for optional semis

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

missed a couple of files in test

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

making some more non-gofmt'ed files save for new semicolon rule

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

- gofmt these files
- 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

minor manual format corrections

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

remove uses of string concatenation from src and misc directory

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

hgtags: add release tag, again.

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

hgtags: looks like they have to be full hashes

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

hgtags: add release pointing at 2009-12-09's checkin.

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

hgtags: tag release.2009-12-07 (where gccgo is)
   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

doc/contribute: try to make it clearer that you send a review with hg mail, not hg submit.

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

added benchmarks to rand_test.go;
removed superfluous field name in lockedSource.

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

syscalls can return negative i/o counts. fix bugs in ReadAt and WriteAt not to include
negative counts in return values.

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

doc: split contribute.html into code.html and contribute.html

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

Make the operations on the global rng thread safe.

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

Continuation of issue 221 fix. When 8g or 6g or 5g are called with a
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

json package: Fixed handling of nil values

Fixes #400.

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

Added my name to the AUTHORS and CONTRIBUTORS list

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

Added XTEA block cipher package to src/pkg/crypto

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

runtime: start new darwin/amd64 threads on correct stack,
    then enable stack check.

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

A+C: two more names
   Kei Son has completed the CLA.
   Yves Junqueira is a Google employee.

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

bufio: use copy - significant speedup for writers

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

Fix stack on FreeBSD / add stack check across the board

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

When SA_SIGINFO is set, we should use __sa_sigaction on FreeBSD

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

6l, 8l: make string buffer big enough for 8 chars (and then some)

Fixes #221.

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

test/bench: faster fasta (mostly due to bufio fix)

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

runtime: don't touch pages of memory unnecessarily.
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

runtime: introduce unsafe.New and unsafe.NewArray
    to provide functionality previously hacked in to
    reflect and gob.

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

use a bootstrap array to avoid allocation for short vectors

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

Remove copyBytes completely in favor of copy.

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

pick off special one-byte case in copy. worth 2x in benchmarks (38ns->16ns).
the one-item case could be generalized easily with no cost. worth considering.

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

the AST walker currently provides no way to find out how the
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

changes necessary to get the new chameneosredux onto shootout.alioth.debian.org .
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

save a few ns by inlining (which mostly simplifies things anyway).
a couple of cleanups.
don't keep big buffers in the free list.

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

unexport Fmt. it's not needed outside this package any more
cleans up godoc's output for package fmt substantially.

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

Make printing faster by avoiding mallocs and some other advances.
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

runtime: disable pointer scan optimization
  * broken by reflect, gob

TBR=r
https://golang.org/cl/166077

Fix syscall.Statfs and syscall.Fstatfs for 386 GNU/Linux.

For 386 we use the [f]statfs64 system call, which takes three
parameters: the filename, the size of the statfs64 structure,
and a pointer to the structure itself.

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

test/bench: use range in reverse-complement

1.9s gcc reverse-complement.c

reverse-complement.go
4.5s / 3.5s original, with/without bounds checks
3.5s / 3.3s bounds check reduction
3.3s / 2.8s smarter garbage collector
2.6s / 2.3s assembler bytes.IndexByte
2.5s / 2.1s even smarter garbage collector
2.3s / 2.1s fix optimizer unnecessary spill bug
2.0s / 1.9s change loop to range (this CL)

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

gc/runtime: pass type structure to makeslice.
  * inform garbage collector about memory with no pointers in it

1.9s gcc reverse-complement.c

reverse-complement.go
4.5s / 3.5s original, with/without bounds checks
3.5s / 3.3s bounds check reduction
3.3s / 2.8s smarter garbage collector
2.6s / 2.3s assembler bytes.IndexByte
2.5s / 2.1s even smarter garbage collector (this CL)

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

gc: walk pointer in range on slice/array

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

6g/8g optimizer fix: throw functions now in runtime

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

test/bench: dead code in reverse-complement

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

gotest: stop if the // gotest commands fail

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

net: more fiddling with the udp test.
  i don't know why the timeout needs
  to be so big.

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

libmach: fix disassembly of MOVLQSX

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

gotest: ignore *_test.pb.go

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

Add syscall.Rename for NaCl.  Fixes NaCl build.

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

runtime: shift the index for the sort by one.

Makes the code look cleaner, even if it's a little harder to figure
out from the sort invariants.

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

Add os.Rename.

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

Remove global chanlock.

On a microbenchmark that ping-pongs on lots of channels, this makes
the multithreaded case about 20% faster and the uniprocessor case
about 1% slower. (Due to cache effects, I expect.)

R=rsc, agl
CC=golang-dev
https://golang.org/cl/166043

bytes: asm for bytes.IndexByte

PERFORMANCE DIFFERENCE

SUMMARY

                                                   amd64           386
2.2 GHz AMD Opteron 8214 HE (Linux)             3.0x faster    8.2x faster
3.60 GHz Intel Xeon (Linux)                     2.2x faster    6.2x faster
2.53 GHz Intel Core2 Duo E7200 (Linux)          1.5x faster    4.4x faster
2.66 Ghz Intel Xeon 5150 (Mac Pro, OS X)        1.5x SLOWER    3.0x faster
2.33 GHz Intel Xeon E5435 (Linux)               1.5x SLOWER    3.0x faster
2.33 GHz Intel Core2 T7600 (MacBook Pro, OS X)  1.4x SLOWER    3.0x faster
1.83 GHz Intel Core2 T5600 (Mac Mini, OS X)        none*       3.0x faster

* but yesterday I consistently saw 1.4x SLOWER.

DETAILS

2.2 GHz AMD Opteron 8214 HE (Linux)

amd64 (3x faster)

IndexByte4K            500000           3733 ns/op     1097.24 MB/s
IndexByte4M               500        4328042 ns/op      969.10 MB/s
IndexByte64M               50       67866160 ns/op      988.84 MB/s

IndexBytePortable4K    200000          11161 ns/op      366.99 MB/s
IndexBytePortable4M       100       11795880 ns/op      355.57 MB/s
IndexBytePortable64M       10      188675000 ns/op      355.68 MB/s

386 (8.2x faster)

IndexByte4K            500000           3734 ns/op     1096.95 MB/s
IndexByte4M               500        4209954 ns/op      996.28 MB/s
IndexByte64M               50       68031980 ns/op      986.43 MB/s

IndexBytePortable4K     50000          30670 ns/op      133.55 MB/s
IndexBytePortable4M        50       31868220 ns/op      131.61 MB/s
IndexBytePortable64M        2      508851500 ns/op      131.88 MB/s

3.60 GHz Intel Xeon (Linux)

amd64 (2.2x faster)

IndexByte4K            500000           4612 ns/op      888.12 MB/s
IndexByte4M               500        4835250 ns/op      867.44 MB/s
IndexByte64M               20       77388450 ns/op      867.17 MB/s

IndexBytePortable4K    200000          10306 ns/op      397.44 MB/s
IndexBytePortable4M       100       11201460 ns/op      374.44 MB/s
IndexBytePortable64M       10      179456800 ns/op      373.96 MB/s

386 (6.3x faster)

IndexByte4K            500000           4631 ns/op      884.47 MB/s
IndexByte4M               500        4846388 ns/op      865.45 MB/s
IndexByte64M               20       78691200 ns/op      852.81 MB/s

IndexBytePortable4K    100000          28989 ns/op      141.29 MB/s
IndexBytePortable4M        50       31183180 ns/op      134.51 MB/s
IndexBytePortable64M        5      498347200 ns/op      134.66 MB/s

2.53 GHz Intel Core2 Duo E7200  (Linux)

amd64 (1.5x faster)

IndexByte4K            500000           6502 ns/op      629.96 MB/s
IndexByte4M               500        6692208 ns/op      626.74 MB/s
IndexByte64M               10      107410400 ns/op      624.79 MB/s

IndexBytePortable4K    200000           9721 ns/op      421.36 MB/s
IndexBytePortable4M       100       10013680 ns/op      418.86 MB/s
IndexBytePortable64M       10      160460800 ns/op      418.23 MB/s

386 (4.4x faster)

IndexByte4K            500000           6505 ns/op      629.67 MB/s
IndexByte4M               500        6694078 ns/op      626.57 MB/s
IndexByte64M               10      107397600 ns/op      624.86 MB/s

IndexBytePortable4K    100000          28835 ns/op      142.05 MB/s
IndexBytePortable4M        50       29562680 ns/op      141.88 MB/s
IndexBytePortable64M        5      473221400 ns/op      141.81 MB/s

2.66 Ghz Intel Xeon 5150  (Mac Pro, OS X)

amd64 (1.5x SLOWER)

IndexByte4K            200000           9290 ns/op      440.90 MB/s
IndexByte4M               200        9568925 ns/op      438.33 MB/s
IndexByte64M               10      154473600 ns/op      434.44 MB/s

IndexBytePortable4K    500000           6202 ns/op      660.43 MB/s
IndexBytePortable4M       500        6583614 ns/op      637.08 MB/s
IndexBytePortable64M       20      107166250 ns/op      626.21 MB/s

386 (3x faster)

IndexByte4K            200000           9301 ns/op      440.38 MB/s
IndexByte4M               200        9568025 ns/op      438.37 MB/s
IndexByte64M               10      154391000 ns/op      434.67 MB/s

IndexBytePortable4K    100000          27526 ns/op      148.80 MB/s
IndexBytePortable4M       100       28302490 ns/op      148.20 MB/s
IndexBytePortable64M        5      454170200 ns/op      147.76 MB/s

2.33 GHz Intel Xeon E5435  (Linux)

amd64 (1.5x SLOWER)

IndexByte4K            200000          10601 ns/op      386.38 MB/s
IndexByte4M               100       10827240 ns/op      387.38 MB/s
IndexByte64M               10      173175500 ns/op      387.52 MB/s

IndexBytePortable4K    500000           7082 ns/op      578.37 MB/s
IndexBytePortable4M       500        7391792 ns/op      567.43 MB/s
IndexBytePortable64M       20      122618550 ns/op      547.30 MB/s

386 (3x faster)

IndexByte4K            200000          11074 ns/op      369.88 MB/s
IndexByte4M               100       10902620 ns/op      384.71 MB/s
IndexByte64M               10      181292800 ns/op      370.17 MB/s

IndexBytePortable4K     50000          31725 ns/op      129.11 MB/s
IndexBytePortable4M        50       32564880 ns/op      128.80 MB/s
IndexBytePortable64M        2      545926000 ns/op      122.93 MB/s

2.33 GHz Intel Core2 T7600 (MacBook Pro, OS X)

amd64 (1.4x SLOWER)

IndexByte4K            200000          11120 ns/op      368.35 MB/s
IndexByte4M               100       11531950 ns/op      363.71 MB/s
IndexByte64M               10      184819000 ns/op      363.11 MB/s

IndexBytePortable4K    500000           7419 ns/op      552.10 MB/s
IndexBytePortable4M       200        8018710 ns/op      523.06 MB/s
IndexBytePortable64M       10      127614900 ns/op      525.87 MB/s

386 (3x faster)

IndexByte4K            200000          11114 ns/op      368.54 MB/s
IndexByte4M               100       11443530 ns/op      366.52 MB/s
IndexByte64M               10      185212000 ns/op      362.34 MB/s

IndexBytePortable4K     50000          32891 ns/op      124.53 MB/s
IndexBytePortable4M        50       33930580 ns/op      123.61 MB/s
IndexBytePortable64M        2      545400500 ns/op      123.05 MB/s

1.83 GHz Intel Core2 T5600  (Mac Mini, OS X)

amd64 (no difference)

IndexByte4K            200000          13497 ns/op      303.47 MB/s
IndexByte4M               100       13890650 ns/op      301.95 MB/s
IndexByte64M                5      222358000 ns/op      301.81 MB/s

IndexBytePortable4K    200000          13584 ns/op      301.53 MB/s
IndexBytePortable4M       100       13913280 ns/op      301.46 MB/s
IndexBytePortable64M       10      222572600 ns/op      301.51 MB/s

386 (3x faster)

IndexByte4K            200000          13565 ns/op      301.95 MB/s
IndexByte4M               100       13882640 ns/op      302.13 MB/s
IndexByte64M                5      221411600 ns/op      303.10 MB/s

IndexBytePortable4K     50000          39978 ns/op      102.46 MB/s
IndexBytePortable4M        50       41038160 ns/op      102.20 MB/s
IndexBytePortable64M        2      656362500 ns/op      102.24 MB/s

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

spec: document that built-ins cannot be used as func values

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

make Native Client support build again,
add README explaining how to try the
web demos.

Fixes #339.

R=r
CC=barry.d.silverman, bss, vadim
https://golang.org/cl/165057

testing: compute MB/s in benchmarks

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

avoid an allocation inside bytes.Buffer by providing a static array.

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

8l: fix print line number format, buffer overflow

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

net: turn off empty packet test by default

Fixes #374.

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

gc: check for assignment to private fields during initialization

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

6g code gen bug

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