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

The o+i*p approach to visiting select cases in random
order stops being fair when there is some case that
is never ready.  If that happens, then the case that follows
it in the order gets more chances than the others.

In general the only way to ensure fairness is to make
all permutations equally likely.  I've done that by computing
one explicitly.

Makes the permutations correct for n >= 4 where
previously they were broken.  For n > 12, there's not
enough randomness to do a perfect job but this should
still be much better than before.

Fixes #1425.

R=r, ken2, ejsherry
CC=golang-dev
https://golang.org/cl/4037043

s2k implements the string-to-key functions for OpenPGP

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

Otherwise syscall.Errstr() returns "" for some (EWOULDBLOCK) errors.

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

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

TBR=adg
CC=golang-dev
https://golang.org/cl/4083042

R=adg
CC=golang-dev
https://golang.org/cl/4047044

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

also:
	cmplx -> complex
	float64(1.0) -> 1.0
	float64(1) -> 1.0

R=gri, r, gri1, r2
CC=golang-dev
https://golang.org/cl/3991043

rename cmplx -> complex

R=ken2
CC=golang-dev
https://golang.org/cl/4071041

R=adg, dsymonds
CC=golang-dev
https://golang.org/cl/4072041

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

The default float type is not very useful but for the most basic applications.
For instance, as it is now, using the math package requires conversions for float
variables (the arguments for math functions are usually float64). Typical real
applications tend to specify the floating point precision required.

This proposal removes the predeclared types float and complex. Variable declarations
without type specification but with constant floating point or complex initializer
expressions will assume the type float64 or complex128 respectively.

The predeclared function cmplx is renamed to complex.

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

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

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

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

R=r, brainman, rsc1
CC=golang-dev
https://golang.org/cl/4023043

        TBR=rsc

R=rsc
CC=berengar.lehr, golang-dev
https://golang.org/cl/4050042

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

hg change fails on Windows with 'No valid patches found in output from hg diff'.

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

- added flag -maxresults (default: 10000) to limit the max.
  number of full text results shown
- removed flag -fulltext; use -maxresults=0 to disable fulltext
  index
- better indication on result page if not all results are shown
  (... after line list)

R=rsc, gri1
CC=golang-dev
https://golang.org/cl/4049042

A query string of the form ident.ident will be used both as a qualified
identifier for identifier search and as a regular expression.
Qualified identifier lookup got broken accidentally when introducing
regexp full text search. Cleaned up surrounding logic a bit.

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

With the current implementation, xml unmarshalling
will silently fail to unmarshal any paths passing
through the same element, such as:

type T struct {
	A string "dummy>a"
	B string "dummy>b"
}

This change tweaks the algorithm so that this works
correctly.

Also, using paths that would cause the same element to
unmarshal twice will error out ahead of time explaining
the problem, rather than silently misbehaving.

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

Why does this happen so often?

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

Fixes #392.

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

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

When data is received for a channel, but that channel
is not ready to receive it, the central run() loop
is currently blocked, but this can lead to deadlock
and interference between independent channels.
This CL adds an explicit buffer size to netchan
channels (an API change) - the sender will not
send values until the buffer is non empty.

The protocol changes to send ids rather than channel names
because acks can still be sent after a channel is hung up,
we we need an identifier that can be ignored.

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

Facilities for printing stack traces from within a running goroutine.

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

TBR=adg
CC=golang-dev
https://golang.org/cl/3992044

R=rsc, adg
CC=golang-dev
https://golang.org/cl/4002041

R=adg, rsc
CC=golang-dev
https://golang.org/cl/3851041

R=r, gri
CC=golang-dev
https://golang.org/cl/4072042

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

Dll names and function names padded to even size.
Refactoring of imports writing code.

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

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

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

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

R=rsc
CC=binet, golang-dev
https://golang.org/cl/3906041

Also:
* document special cases for Frexp and Ldexp
* handle ±Inf in Ldexp
* correctly return -0 on underflow in Ldexp
* test special cases for Ldexp
* test boundary cases for Frexp, Ilogb, Ldexp, and Logb

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

R=golang-dev, rsc, rsc1
CC=golang-dev
https://golang.org/cl/2309043