diff options
139 files changed, 9464 insertions, 9464 deletions
diff --git a/misc/cgo/gmp/fib.go b/misc/cgo/gmp/fib.go index 1ff156ef2..3eda39e17 100644 --- a/misc/cgo/gmp/fib.go +++ b/misc/cgo/gmp/fib.go @@ -10,33 +10,33 @@ package main import ( - big "gmp"; - "runtime"; + big "gmp" + "runtime" ) func fibber(c chan *big.Int, out chan string, n int64) { // Keep the fibbers in dedicated operating system // threads, so that this program tests coordination // between pthreads and not just goroutines. - runtime.LockOSThread(); + runtime.LockOSThread() - i := big.NewInt(n); + i := big.NewInt(n) if n == 0 { c <- i } for { - j := <-c; - out <- j.String(); - i.Add(i, j); - c <- i; + j := <-c + out <- j.String() + i.Add(i, j) + c <- i } } func main() { - c := make(chan *big.Int); - out := make(chan string); - go fibber(c, out, 0); - go fibber(c, out, 1); + c := make(chan *big.Int) + out := make(chan string) + go fibber(c, out, 0) + go fibber(c, out, 1) for i := 0; i < 200; i++ { println(<-out) } diff --git a/misc/cgo/gmp/gmp.go b/misc/cgo/gmp/gmp.go index e199543c7..33c16de77 100644 --- a/misc/cgo/gmp/gmp.go +++ b/misc/cgo/gmp/gmp.go @@ -104,8 +104,8 @@ package gmp import "C" import ( - "os"; - "unsafe"; + "os" + "unsafe" ) /* @@ -115,12 +115,12 @@ import ( // An Int represents a signed multi-precision integer. // The zero value for an Int represents the value 0. type Int struct { - i C.mpz_t; - init bool; + i C.mpz_t + init bool } // NewInt returns a new Int initialized to x. -func NewInt(x int64) *Int { return new(Int).SetInt64(x) } +func NewInt(x int64) *Int { return new(Int).SetInt64(x) } // Int promises that the zero value is a 0, but in gmp // the zero value is a crash. To bridge the gap, the @@ -132,65 +132,65 @@ func (z *Int) doinit() { if z.init { return } - z.init = true; - C.mpz_init(&z.i[0]); + z.init = true + C.mpz_init(&z.i[0]) } // Bytes returns z's representation as a big-endian byte array. func (z *Int) Bytes() []byte { - b := make([]byte, (z.Len()+7)/8); - n := C.size_t(len(b)); - C.mpz_export(unsafe.Pointer(&b[0]), &n, 1, 1, 1, 0, &z.i[0]); - return b[0:n]; + b := make([]byte, (z.Len()+7)/8) + n := C.size_t(len(b)) + C.mpz_export(unsafe.Pointer(&b[0]), &n, 1, 1, 1, 0, &z.i[0]) + return b[0:n] } // Len returns the length of z in bits. 0 is considered to have length 1. func (z *Int) Len() int { - z.doinit(); - return int(C.mpz_sizeinbase(&z.i[0], 2)); + z.doinit() + return int(C.mpz_sizeinbase(&z.i[0], 2)) } // Set sets z = x and returns z. func (z *Int) Set(x *Int) *Int { - z.doinit(); - C.mpz_set(&z.i[0], &x.i[0]); - return z; + z.doinit() + C.mpz_set(&z.i[0], &x.i[0]) + return z } // SetBytes interprets b as the bytes of a big-endian integer // and sets z to that value. func (z *Int) SetBytes(b []byte) *Int { - z.doinit(); + z.doinit() if len(b) == 0 { z.SetInt64(0) } else { C.mpz_import(&z.i[0], C.size_t(len(b)), 1, 1, 1, 0, unsafe.Pointer(&b[0])) } - return z; + return z } // SetInt64 sets z = x and returns z. func (z *Int) SetInt64(x int64) *Int { - z.doinit(); + z.doinit() // TODO(rsc): more work on 32-bit platforms - C.mpz_set_si(&z.i[0], C.long(x)); - return z; + C.mpz_set_si(&z.i[0], C.long(x)) + return z } // SetString interprets s as a number in the given base // and sets z to that value. The base must be in the range [2,36]. // SetString returns an error if s cannot be parsed or the base is invalid. func (z *Int) SetString(s string, base int) os.Error { - z.doinit(); + z.doinit() if base < 2 || base > 36 { return os.EINVAL } - p := C.CString(s); - defer C.free(unsafe.Pointer(p)); + p := C.CString(s) + defer C.free(unsafe.Pointer(p)) if C.mpz_set_str(&z.i[0], p, C.int(base)) < 0 { return os.EINVAL } - return z; + return z } // String returns the decimal representation of z. @@ -198,18 +198,18 @@ func (z *Int) String() string { if z == nil { return "nil" } - z.doinit(); - p := C.mpz_get_str(nil, 10, &z.i[0]); - s := C.GoString(p); - C.free(unsafe.Pointer(p)); - return s; + z.doinit() + p := C.mpz_get_str(nil, 10, &z.i[0]) + s := C.GoString(p) + C.free(unsafe.Pointer(p)) + return s } func (z *Int) destroy() { if z.init { C.mpz_clear(&z.i[0]) } - z.init = false; + z.init = false } @@ -219,103 +219,103 @@ func (z *Int) destroy() { // Add sets z = x + y and returns z. func (z *Int) Add(x, y *Int) *Int { - x.doinit(); - y.doinit(); - z.doinit(); - C.mpz_add(&z.i[0], &x.i[0], &y.i[0]); - return z; + x.doinit() + y.doinit() + z.doinit() + C.mpz_add(&z.i[0], &x.i[0], &y.i[0]) + return z } // Sub sets z = x - y and returns z. func (z *Int) Sub(x, y *Int) *Int { - x.doinit(); - y.doinit(); - z.doinit(); - C.mpz_sub(&z.i[0], &x.i[0], &y.i[0]); - return z; + x.doinit() + y.doinit() + z.doinit() + C.mpz_sub(&z.i[0], &x.i[0], &y.i[0]) + return z } // Mul sets z = x * y and returns z. func (z *Int) Mul(x, y *Int) *Int { - x.doinit(); - y.doinit(); - z.doinit(); - C.mpz_mul(&z.i[0], &x.i[0], &y.i[0]); - return z; + x.doinit() + y.doinit() + z.doinit() + C.mpz_mul(&z.i[0], &x.i[0], &y.i[0]) + return z } // Div sets z = x / y, rounding toward zero, and returns z. func (z *Int) Div(x, y *Int) *Int { - x.doinit(); - y.doinit(); - z.doinit(); - C.mpz_tdiv_q(&z.i[0], &x.i[0], &y.i[0]); - return z; + x.doinit() + y.doinit() + z.doinit() + C.mpz_tdiv_q(&z.i[0], &x.i[0], &y.i[0]) + return z } // Mod sets z = x % y and returns z. // Like the result of the Go % operator, z has the same sign as x. func (z *Int) Mod(x, y *Int) *Int { - x.doinit(); - y.doinit(); - z.doinit(); - C.mpz_tdiv_r(&z.i[0], &x.i[0], &y.i[0]); - return z; + x.doinit() + y.doinit() + z.doinit() + C.mpz_tdiv_r(&z.i[0], &x.i[0], &y.i[0]) + return z } // Lsh sets z = x << s and returns z. func (z *Int) Lsh(x *Int, s uint) *Int { - x.doinit(); - z.doinit(); - C.mpz_mul_2exp(&z.i[0], &x.i[0], C.ulong(s)); - return z; + x.doinit() + z.doinit() + C.mpz_mul_2exp(&z.i[0], &x.i[0], C.ulong(s)) + return z } // Rsh sets z = x >> s and returns z. func (z *Int) Rsh(x *Int, s uint) *Int { - x.doinit(); - z.doinit(); - C.mpz_div_2exp(&z.i[0], &x.i[0], C.ulong(s)); - return z; + x.doinit() + z.doinit() + C.mpz_div_2exp(&z.i[0], &x.i[0], C.ulong(s)) + return z } // Exp sets z = x^y % m and returns z. // If m == nil, Exp sets z = x^y. func (z *Int) Exp(x, y, m *Int) *Int { - m.doinit(); - x.doinit(); - y.doinit(); - z.doinit(); + m.doinit() + x.doinit() + y.doinit() + z.doinit() if m == nil { C.mpz_pow_ui(&z.i[0], &x.i[0], C.mpz_get_ui(&y.i[0])) } else { C.mpz_powm(&z.i[0], &x.i[0], &y.i[0], &m.i[0]) } - return z; + return z } func (z *Int) Int64() int64 { if !z.init { return 0 } - return int64(C.mpz_get_si(&z.i[0])); + return int64(C.mpz_get_si(&z.i[0])) } // Neg sets z = -x and returns z. func (z *Int) Neg(x *Int) *Int { - x.doinit(); - z.doinit(); - C.mpz_neg(&z.i[0], &x.i[0]); - return z; + x.doinit() + z.doinit() + C.mpz_neg(&z.i[0], &x.i[0]) + return z } // Abs sets z to the absolute value of x and returns z. func (z *Int) Abs(x *Int) *Int { - x.doinit(); - z.doinit(); - C.mpz_abs(&z.i[0], &x.i[0]); - return z; + x.doinit() + z.doinit() + C.mpz_abs(&z.i[0], &x.i[0]) + return z } @@ -330,24 +330,24 @@ func (z *Int) Abs(x *Int) *Int { // +1 if x > y // func CmpInt(x, y *Int) int { - x.doinit(); - y.doinit(); + x.doinit() + y.doinit() switch cmp := C.mpz_cmp(&x.i[0], &y.i[0]); { case cmp < 0: return -1 case cmp == 0: return 0 } - return +1; + return +1 } // DivModInt sets q = x / y and r = x % y. func DivModInt(q, r, x, y *Int) { - q.doinit(); - r.doinit(); - x.doinit(); - y.doinit(); - C.mpz_tdiv_qr(&q.i[0], &r.i[0], &x.i[0], &y.i[0]); + q.doinit() + r.doinit() + x.doinit() + y.doinit() + C.mpz_tdiv_qr(&q.i[0], &r.i[0], &x.i[0], &y.i[0]) } // GcdInt sets d to the greatest common divisor of a and b, @@ -355,18 +355,18 @@ func DivModInt(q, r, x, y *Int) { // If x and y are not nil, GcdInt sets x and y such that d = a*x + b*y. // If either a or b is not positive, GcdInt sets d = x = y = 0. func GcdInt(d, x, y, a, b *Int) { - d.doinit(); - x.doinit(); - y.doinit(); - a.doinit(); - b.doinit(); - C.mpz_gcdext(&d.i[0], &x.i[0], &y.i[0], &a.i[0], &b.i[0]); + d.doinit() + x.doinit() + y.doinit() + a.doinit() + b.doinit() + C.mpz_gcdext(&d.i[0], &x.i[0], &y.i[0], &a.i[0], &b.i[0]) } // ProbablyPrime performs n Miller-Rabin tests to check whether z is prime. // If it returns true, z is prime with probability 1 - 1/4^n. // If it returns false, z is not prime. func (z *Int) ProbablyPrime(n int) bool { - z.doinit(); - return int(C.mpz_probab_prime_p(&z.i[0], C.int(n))) > 0; + z.doinit() + return int(C.mpz_probab_prime_p(&z.i[0], C.int(n))) > 0 } diff --git a/misc/cgo/gmp/pi.go b/misc/cgo/gmp/pi.go index 61b88a417..45f61abbd 100644 --- a/misc/cgo/gmp/pi.go +++ b/misc/cgo/gmp/pi.go @@ -38,67 +38,67 @@ POSSIBILITY OF SUCH DAMAGE. package main import ( - big "gmp"; - "fmt"; - "runtime"; + big "gmp" + "fmt" + "runtime" ) var ( - tmp1 = big.NewInt(0); - tmp2 = big.NewInt(0); - numer = big.NewInt(1); - accum = big.NewInt(0); - denom = big.NewInt(1); - ten = big.NewInt(10); + tmp1 = big.NewInt(0) + tmp2 = big.NewInt(0) + numer = big.NewInt(1) + accum = big.NewInt(0) + denom = big.NewInt(1) + ten = big.NewInt(10) ) func extractDigit() int64 { if big.CmpInt(numer, accum) > 0 { return -1 } - tmp1.Lsh(numer, 1).Add(tmp1, numer).Add(tmp1, accum); - big.DivModInt(tmp1, tmp2, tmp1, denom); - tmp2.Add(tmp2, numer); + tmp1.Lsh(numer, 1).Add(tmp1, numer).Add(tmp1, accum) + big.DivModInt(tmp1, tmp2, tmp1, denom) + tmp2.Add(tmp2, numer) if big.CmpInt(tmp2, denom) >= 0 { return -1 } - return tmp1.Int64(); + return tmp1.Int64() } func nextTerm(k int64) { - y2 := k*2 + 1; - accum.Add(accum, tmp1.Lsh(numer, 1)); - accum.Mul(accum, tmp1.SetInt64(y2)); - numer.Mul(numer, tmp1.SetInt64(k)); - denom.Mul(denom, tmp1.SetInt64(y2)); + y2 := k*2 + 1 + accum.Add(accum, tmp1.Lsh(numer, 1)) + accum.Mul(accum, tmp1.SetInt64(y2)) + numer.Mul(numer, tmp1.SetInt64(k)) + denom.Mul(denom, tmp1.SetInt64(y2)) } func eliminateDigit(d int64) { - accum.Sub(accum, tmp1.Mul(denom, tmp1.SetInt64(d))); - accum.Mul(accum, ten); - numer.Mul(numer, ten); + accum.Sub(accum, tmp1.Mul(denom, tmp1.SetInt64(d))) + accum.Mul(accum, ten) + numer.Mul(numer, ten) } func main() { - i := 0; - k := int64(0); + i := 0 + k := int64(0) for { - d := int64(-1); + d := int64(-1) for d < 0 { - k++; - nextTerm(k); - d = extractDigit(); + k++ + nextTerm(k) + d = extractDigit() } - eliminateDigit(d); - fmt.Printf("%c", d+'0'); + eliminateDigit(d) + fmt.Printf("%c", d+'0') if i++; i%50 == 0 { - fmt.Printf("\n"); + fmt.Printf("\n") if i >= 1000 { break } } } - fmt.Printf("\n%d calls; bit sizes: %d %d %d\n", runtime.Cgocalls(), numer.Len(), accum.Len(), denom.Len()); + fmt.Printf("\n%d calls; bit sizes: %d %d %d\n", runtime.Cgocalls(), numer.Len(), accum.Len(), denom.Len()) } diff --git a/misc/cgo/stdio/chain.go b/misc/cgo/stdio/chain.go index 18c598d4d..dd5e01542 100644 --- a/misc/cgo/stdio/chain.go +++ b/misc/cgo/stdio/chain.go @@ -7,9 +7,9 @@ package main import ( - "runtime"; - "stdio"; - "strconv"; + "runtime" + "stdio" + "strconv" ) const N = 10 @@ -19,25 +19,25 @@ func link(left chan<- int, right <-chan int) { // Keep the links in dedicated operating system // threads, so that this program tests coordination // between pthreads and not just goroutines. - runtime.LockOSThread(); + runtime.LockOSThread() for { - v := <-right; - stdio.Puts(strconv.Itoa(v)); - left <- 1+v; + v := <-right + stdio.Puts(strconv.Itoa(v)) + left <- 1+v } } func main() { - leftmost := make(chan int); - var left chan int; - right := leftmost; + leftmost := make(chan int) + var left chan int + right := leftmost for i := 0; i < N; i++ { - left, right = right, make(chan int); - go link(left, right); + left, right = right, make(chan int) + go link(left, right) } for i := 0; i < R; i++ { - right <- 0; - x := <-leftmost; - stdio.Puts(strconv.Itoa(x)); + right <- 0 + x := <-leftmost + stdio.Puts(strconv.Itoa(x)) } } diff --git a/misc/cgo/stdio/fib.go b/misc/cgo/stdio/fib.go index 1e2336d5b..63ae04988 100644 --- a/misc/cgo/stdio/fib.go +++ b/misc/cgo/stdio/fib.go @@ -10,38 +10,38 @@ package main import ( - "runtime"; - "stdio"; - "strconv"; + "runtime" + "stdio" + "strconv" ) func fibber(c, out chan int64, i int64) { // Keep the fibbers in dedicated operating system // threads, so that this program tests coordination // between pthreads and not just goroutines. - runtime.LockOSThread(); + runtime.LockOSThread() if i == 0 { c <- i } for { - j := <-c; - stdio.Puts(strconv.Itoa64(j)); - out <- j; - <-out; - i += j; - c <- i; + j := <-c + stdio.Puts(strconv.Itoa64(j)) + out <- j + <-out + i += j + c <- i } } func main() { - c := make(chan int64); - out := make(chan int64); - go fibber(c, out, 0); - go fibber(c, out, 1); - <-out; + c := make(chan int64) + out := make(chan int64) + go fibber(c, out, 0) + go fibber(c, out, 1) + <-out for i := 0; i < 90; i++ { - out <- 1; - <-out; + out <- 1 + <-out } } diff --git a/misc/cgo/stdio/file.go b/misc/cgo/stdio/file.go index c8493a0e3..7d1f22280 100644 --- a/misc/cgo/stdio/file.go +++ b/misc/cgo/stdio/file.go @@ -35,8 +35,8 @@ func (f *File) WriteString(s string) { */ func Puts(s string) { - p := C.CString(s); - C.puts(p); - C.free(unsafe.Pointer(p)); - C.fflushstdout(); + p := C.CString(s) + C.puts(p) + C.free(unsafe.Pointer(p)) + C.fflushstdout() } diff --git a/src/cmd/cgo/ast.go b/src/cmd/cgo/ast.go index ccaef69d1..b309c33d4 100644 --- a/src/cmd/cgo/ast.go +++ b/src/cmd/cgo/ast.go @@ -7,57 +7,57 @@ package main import ( - "fmt"; - "go/ast"; - "go/doc"; - "go/parser"; - "go/scanner"; - "os"; + "fmt" + "go/ast" + "go/doc" + "go/parser" + "go/scanner" + "os" ) // A Cref refers to an expression of the form C.xxx in the AST. type Cref struct { - Name string; - Expr *ast.Expr; - Context string; // "type", "expr", or "call" - TypeName bool; // whether xxx is a C type name - Type *Type; // the type of xxx - FuncType *FuncType; + Name string + Expr *ast.Expr + Context string // "type", "expr", or "call" + TypeName bool // whether xxx is a C type name + Type *Type // the type of xxx + FuncType *FuncType } // A Prog collects information about a cgo program. type Prog struct { - AST *ast.File; // parsed AST - Preamble string; // C preamble (doc comment on import "C") - PackagePath string; - Package string; - Crefs []*Cref; - Typedef map[string]ast.Expr; - Vardef map[string]*Type; - Funcdef map[string]*FuncType; - PtrSize int64; - GccOptions []string; + AST *ast.File // parsed AST + Preamble string // C preamble (doc comment on import "C") + PackagePath string + Package string + Crefs []*Cref + Typedef map[string]ast.Expr + Vardef map[string]*Type + Funcdef map[string]*FuncType + PtrSize int64 + GccOptions []string } // A Type collects information about a type in both the C and Go worlds. type Type struct { - Size int64; - Align int64; - C string; - Go ast.Expr; + Size int64 + Align int64 + C string + Go ast.Expr } // A FuncType collects information about a function type in both the C and Go worlds. type FuncType struct { - Params []*Type; - Result *Type; - Go *ast.FuncType; + Params []*Type + Result *Type + Go *ast.FuncType } func openProg(name string) *Prog { - p := new(Prog); - var err os.Error; - p.AST, err = parser.ParsePkgFile("", name, parser.ParseComments); + p := new(Prog) + var err os.Error + p.AST, err = parser.ParsePkgFile("", name, parser.ParseComments) if err != nil { if list, ok := err.(scanner.ErrorList); ok { // If err is a scanner.ErrorList, its String will print just @@ -67,32 +67,32 @@ func openProg(name string) *Prog { for _, e := range list { fmt.Fprintln(os.Stderr, e) } - os.Exit(2); + os.Exit(2) } - fatal("parsing %s: %s", name, err); + fatal("parsing %s: %s", name, err) } - p.Package = p.AST.Name.Value; + p.Package = p.AST.Name.Value // Find the import "C" line and get any extra C preamble. // Delete the import "C" line along the way. - sawC := false; - w := 0; + sawC := false + w := 0 for _, decl := range p.AST.Decls { - d, ok := decl.(*ast.GenDecl); + d, ok := decl.(*ast.GenDecl) if !ok { - p.AST.Decls[w] = decl; - w++; - continue; + p.AST.Decls[w] = decl + w++ + continue } - ws := 0; + ws := 0 for _, spec := range d.Specs { - s, ok := spec.(*ast.ImportSpec); + s, ok := spec.(*ast.ImportSpec) if !ok || len(s.Path) != 1 || string(s.Path[0].Value) != `"C"` { - d.Specs[ws] = spec; - ws++; - continue; + d.Specs[ws] = spec + ws++ + continue } - sawC = true; + sawC = true if s.Name != nil { error(s.Path[0].Pos(), `cannot rename import "C"`) } @@ -105,20 +105,20 @@ func openProg(name string) *Prog { if ws == 0 { continue } - d.Specs = d.Specs[0:ws]; - p.AST.Decls[w] = d; - w++; + d.Specs = d.Specs[0:ws] + p.AST.Decls[w] = d + w++ } - p.AST.Decls = p.AST.Decls[0:w]; + p.AST.Decls = p.AST.Decls[0:w] if !sawC { error(noPos, `cannot find import "C"`) } // Accumulate pointers to uses of C.x. - p.Crefs = make([]*Cref, 0, 8); - walk(p.AST, p, "prog"); - return p; + p.Crefs = make([]*Cref, 0, 8) + walk(p.AST, p, "prog") + return p } func walk(x interface{}, p *Prog, context string) { @@ -131,29 +131,29 @@ func walk(x interface{}, p *Prog, context string) { // so that we will be able to distinguish a "top-level C" // from a local C. if l, ok := sel.X.(*ast.Ident); ok && l.Value == "C" { - i := len(p.Crefs); + i := len(p.Crefs) if i >= cap(p.Crefs) { - new := make([]*Cref, 2*i); + new := make([]*Cref, 2*i) for j, v := range p.Crefs { new[j] = v } - p.Crefs = new; + p.Crefs = new } - p.Crefs = p.Crefs[0 : i+1]; + p.Crefs = p.Crefs[0 : i+1] p.Crefs[i] = &Cref{ Name: sel.Sel.Value, Expr: n, Context: context, - }; - break; + } + break } } - walk(*n, p, context); + walk(*n, p, context) // everything else just recurs default: - error(noPos, "unexpected type %T in walk", x); - panic(); + error(noPos, "unexpected type %T in walk", x) + panic() case nil: @@ -166,54 +166,54 @@ func walk(x interface{}, p *Prog, context string) { case *ast.BasicLit: case *ast.StringList: case *ast.FuncLit: - walk(n.Type, p, "type"); - walk(n.Body, p, "stmt"); + walk(n.Type, p, "type") + walk(n.Body, p, "stmt") case *ast.CompositeLit: - walk(&n.Type, p, "type"); - walk(n.Elts, p, "expr"); + walk(&n.Type, p, "type") + walk(n.Elts, p, "expr") case *ast.ParenExpr: walk(&n.X, p, context) case *ast.SelectorExpr: walk(&n.X, p, "selector") case *ast.IndexExpr: - walk(&n.X, p, "expr"); - walk(&n.Index, p, "expr"); + walk(&n.X, p, "expr") + walk(&n.Index, p, "expr") case *ast.SliceExpr: - walk(&n.X, p, "expr"); - walk(&n.Index, p, "expr"); + walk(&n.X, p, "expr") + walk(&n.Index, p, "expr") if n.End != nil { walk(&n.End, p, "expr") } case *ast.TypeAssertExpr: - walk(&n.X, p, "expr"); - walk(&n.Type, p, "type"); + walk(&n.X, p, "expr") + walk(&n.Type, p, "type") case *ast.CallExpr: - walk(&n.Fun, p, "call"); - walk(n.Args, p, "expr"); + walk(&n.Fun, p, "call") + walk(n.Args, p, "expr") case *ast.StarExpr: walk(&n.X, p, context) case *ast.UnaryExpr: walk(&n.X, p, "expr") case *ast.BinaryExpr: - walk(&n.X, p, "expr"); - walk(&n.Y, p, "expr"); + walk(&n.X, p, "expr") + walk(&n.Y, p, "expr") case *ast.KeyValueExpr: - walk(&n.Key, p, "expr"); - walk(&n.Value, p, "expr"); + walk(&n.Key, p, "expr") + walk(&n.Value, p, "expr") case *ast.ArrayType: - walk(&n.Len, p, "expr"); - walk(&n.Elt, p, "type"); + walk(&n.Len, p, "expr") + walk(&n.Elt, p, "type") case *ast.StructType: walk(n.Fields, p, "field") case *ast.FuncType: - walk(n.Params, p, "field"); - walk(n.Results, p, "field"); + walk(n.Params, p, "field") + walk(n.Results, p, "field") case *ast.InterfaceType: walk(n.Methods, p, "field") case *ast.MapType: - walk(&n.Key, p, "type"); - walk(&n.Value, p, "type"); + walk(&n.Key, p, "type") + walk(&n.Value, p, "type") case *ast.ChanType: walk(&n.Value, p, "type") @@ -228,8 +228,8 @@ func walk(x interface{}, p *Prog, context string) { case *ast.IncDecStmt: walk(&n.X, p, "expr") case *ast.AssignStmt: - walk(n.Lhs, p, "expr"); - walk(n.Rhs, p, "expr"); + walk(n.Lhs, p, "expr") + walk(n.Rhs, p, "expr") case *ast.GoStmt: walk(n.Call, p, "expr") case *ast.DeferStmt: @@ -240,45 +240,45 @@ func walk(x interface{}, p *Prog, context string) { case *ast.BlockStmt: walk(n.List, p, "stmt") case *ast.IfStmt: - walk(n.Init, p, "stmt"); - walk(&n.Cond, p, "expr"); - walk(n.Body, p, "stmt"); - walk(n.Else, p, "stmt"); + walk(n.Init, p, "stmt") + walk(&n.Cond, p, "expr") + walk(n.Body, p, "stmt") + walk(n.Else, p, "stmt") case *ast.CaseClause: - walk(n.Values, p, "expr"); - walk(n.Body, p, "stmt"); + walk(n.Values, p, "expr") + walk(n.Body, p, "stmt") case *ast.SwitchStmt: - walk(n.Init, p, "stmt"); - walk(&n.Tag, p, "expr"); - walk(n.Body, p, "stmt"); + walk(n.Init, p, "stmt") + walk(&n.Tag, p, "expr") + walk(n.Body, p, "stmt") case *ast.TypeCaseClause: - walk(n.Types, p, "type"); - walk(n.Body, p, "stmt"); + walk(n.Types, p, "type") + walk(n.Body, p, "stmt") case *ast.TypeSwitchStmt: - walk(n.Init, p, "stmt"); - walk(n.Assign, p, "stmt"); - walk(n.Body, p, "stmt"); + walk(n.Init, p, "stmt") + walk(n.Assign, p, "stmt") + walk(n.Body, p, "stmt") case *ast.CommClause: - walk(n.Lhs, p, "expr"); - walk(n.Rhs, p, "expr"); - walk(n.Body, p, "stmt"); + walk(n.Lhs, p, "expr") + walk(n.Rhs, p, "expr") + walk(n.Body, p, "stmt") case *ast.SelectStmt: walk(n.Body, p, "stmt") case *ast.ForStmt: - walk(n.Init, p, "stmt"); - walk(&n.Cond, p, "expr"); - walk(n.Post, p, "stmt"); - walk(n.Body, p, "stmt"); + walk(n.Init, p, "stmt") + walk(&n.Cond, p, "expr") + walk(n.Post, p, "stmt") + walk(n.Body, p, "stmt") case *ast.RangeStmt: - walk(&n.Key, p, "expr"); - walk(&n.Value, p, "expr"); - walk(&n.X, p, "expr"); - walk(n.Body, p, "stmt"); + walk(&n.Key, p, "expr") + walk(&n.Value, p, "expr") + walk(&n.X, p, "expr") + walk(n.Body, p, "stmt") case *ast.ImportSpec: case *ast.ValueSpec: - walk(&n.Type, p, "type"); - walk(n.Values, p, "expr"); + walk(&n.Type, p, "type") + walk(n.Values, p, "expr") case *ast.TypeSpec: walk(&n.Type, p, "type") @@ -289,7 +289,7 @@ func walk(x interface{}, p *Prog, context string) { if n.Recv != nil { walk(n.Recv, p, "field") } - walk(n.Type, p, "type"); + walk(n.Type, p, "type") if n.Body != nil { walk(n.Body, p, "stmt") } diff --git a/src/cmd/cgo/gcc.go b/src/cmd/cgo/gcc.go index 7d377db54..c42cb7300 100644 --- a/src/cmd/cgo/gcc.go +++ b/src/cmd/cgo/gcc.go @@ -8,30 +8,30 @@ package main import ( - "bytes"; - "debug/dwarf"; - "debug/elf"; - "debug/macho"; - "fmt"; - "go/ast"; - "go/token"; - "os"; - "strconv"; - "strings"; + "bytes" + "debug/dwarf" + "debug/elf" + "debug/macho" + "fmt" + "go/ast" + "go/token" + "os" + "strconv" + "strings" ) func (p *Prog) loadDebugInfo() { // Construct a slice of unique names from p.Crefs. - m := make(map[string]int); + m := make(map[string]int) for _, c := range p.Crefs { m[c.Name] = -1 } - names := make([]string, 0, len(m)); + names := make([]string, 0, len(m)) for name, _ := range m { - i := len(names); - names = names[0 : i+1]; - names[i] = name; - m[name] = i; + i := len(names) + names = names[0 : i+1] + names[i] = name + m[name] = i } // Coerce gcc into telling us whether each name is @@ -46,18 +46,18 @@ func (p *Prog) loadDebugInfo() { // x.c:2: error: 'name' undeclared (first use in this function) // A line number directive causes the line number to // correspond to the index in the names array. - var b bytes.Buffer; - b.WriteString(p.Preamble); - b.WriteString("void f(void) {\n"); - b.WriteString("#line 0 \"cgo-test\"\n"); + var b bytes.Buffer + b.WriteString(p.Preamble) + b.WriteString("void f(void) {\n") + b.WriteString("#line 0 \"cgo-test\"\n") for _, n := range names { - b.WriteString(n); - b.WriteString(";\n"); + b.WriteString(n) + b.WriteString(";\n") } - b.WriteString("}\n"); + b.WriteString("}\n") - kind := make(map[string]string); - _, stderr := p.gccDebug(b.Bytes()); + kind := make(map[string]string) + _, stderr := p.gccDebug(b.Bytes()) if stderr == "" { fatal("gcc produced no output") } @@ -65,16 +65,16 @@ func (p *Prog) loadDebugInfo() { if len(line) < 9 || line[0:9] != "cgo-test:" { continue } - line = line[9:]; - colon := strings.Index(line, ":"); + line = line[9:] + colon := strings.Index(line, ":") if colon < 0 { continue } - i, err := strconv.Atoi(line[0:colon]); + i, err := strconv.Atoi(line[0:colon]) if err != nil { continue } - what := ""; + what := "" switch { default: continue @@ -88,7 +88,7 @@ func (p *Prog) loadDebugInfo() { if old, ok := kind[names[i]]; ok && old != what { error(noPos, "inconsistent gcc output about C.%s", names[i]) } - kind[names[i]] = what; + kind[names[i]] = what } for _, n := range names { if _, ok := kind[n]; !ok { @@ -108,21 +108,21 @@ func (p *Prog) loadDebugInfo() { // typeof(names[i]) *__cgo__i; // for each entry in names and then dereference the type we // learn for __cgo__i. - b.Reset(); - b.WriteString(p.Preamble); + b.Reset() + b.WriteString(p.Preamble) for i, n := range names { fmt.Fprintf(&b, "typeof(%s) *__cgo__%d;\n", n, i) } - d, stderr := p.gccDebug(b.Bytes()); + d, stderr := p.gccDebug(b.Bytes()) if d == nil { fatal("gcc failed:\n%s\non input:\n%s", stderr, b.Bytes()) } // Scan DWARF info for top-level TagVariable entries with AttrName __cgo__i. - types := make([]dwarf.Type, len(names)); - r := d.Reader(); + types := make([]dwarf.Type, len(names)) + r := d.Reader() for { - e, err := r.Next(); + e, err := r.Next() if err != nil { fatal("reading DWARF entry: %s", err) } @@ -132,27 +132,27 @@ func (p *Prog) loadDebugInfo() { if e.Tag != dwarf.TagVariable { goto Continue } - name, _ := e.Val(dwarf.AttrName).(string); - typOff, _ := e.Val(dwarf.AttrType).(dwarf.Offset); + name, _ := e.Val(dwarf.AttrName).(string) + typOff, _ := e.Val(dwarf.AttrType).(dwarf.Offset) if name == "" || typOff == 0 { fatal("malformed DWARF TagVariable entry") } if !strings.HasPrefix(name, "__cgo__") { goto Continue } - typ, err := d.Type(typOff); + typ, err := d.Type(typOff) if err != nil { fatal("loading DWARF type: %s", err) } - t, ok := typ.(*dwarf.PtrType); + t, ok := typ.(*dwarf.PtrType) if !ok || t == nil { fatal("internal error: %s has non-pointer type", name) } - i, err := strconv.Atoi(name[7:]); + i, err := strconv.Atoi(name[7:]) if err != nil { fatal("malformed __cgo__ name: %s", name) } - types[i] = t.Type; + types[i] = t.Type Continue: if e.Tag != dwarf.TagCompileUnit { @@ -161,132 +161,132 @@ func (p *Prog) loadDebugInfo() { } // Record types and typedef information in Crefs. - var conv typeConv; - conv.Init(p.PtrSize); + var conv typeConv + conv.Init(p.PtrSize) for _, c := range p.Crefs { - i := m[c.Name]; - c.TypeName = kind[c.Name] == "type"; - f, fok := types[i].(*dwarf.FuncType); + i := m[c.Name] + c.TypeName = kind[c.Name] == "type" + f, fok := types[i].(*dwarf.FuncType) if c.Context == "call" && !c.TypeName && fok { c.FuncType = conv.FuncType(f) } else { c.Type = conv.Type(types[i]) } } - p.Typedef = conv.typedef; + p.Typedef = conv.typedef } func concat(a, b []string) []string { - c := make([]string, len(a)+len(b)); + c := make([]string, len(a)+len(b)) for i, s := range a { c[i] = s } for i, s := range b { c[i+len(a)] = s } - return c; + return c } // gccDebug runs gcc -gdwarf-2 over the C program stdin and // returns the corresponding DWARF data and any messages // printed to standard error. func (p *Prog) gccDebug(stdin []byte) (*dwarf.Data, string) { - machine := "-m32"; + machine := "-m32" if p.PtrSize == 8 { machine = "-m64" } - tmp := "_cgo_.o"; + tmp := "_cgo_.o" base := []string{ "gcc", machine, - "-Wall", // many warnings - "-Werror", // warnings are errors - "-o" + tmp, // write object to tmp - "-gdwarf-2", // generate DWARF v2 debugging symbols - "-c", // do not link - "-xc", // input language is C - "-", // read input from standard input - }; - _, stderr, ok := run(stdin, concat(base, p.GccOptions)); + "-Wall", // many warnings + "-Werror", // warnings are errors + "-o" + tmp, // write object to tmp + "-gdwarf-2", // generate DWARF v2 debugging symbols + "-c", // do not link + "-xc", // input language is C + "-", // read input from standard input + } + _, stderr, ok := run(stdin, concat(base, p.GccOptions)) if !ok { return nil, string(stderr) } // Try to parse f as ELF and Mach-O and hope one works. var f interface { - DWARF() (*dwarf.Data, os.Error); + DWARF() (*dwarf.Data, os.Error) } - var err os.Error; + var err os.Error if f, err = elf.Open(tmp); err != nil { if f, err = macho.Open(tmp); err != nil { fatal("cannot parse gcc output %s as ELF or Mach-O object", tmp) } } - d, err := f.DWARF(); + d, err := f.DWARF() if err != nil { fatal("cannot load DWARF debug information from %s: %s", tmp, err) } - return d, ""; + return d, "" } // A typeConv is a translator from dwarf types to Go types // with equivalent memory layout. type typeConv struct { // Cache of already-translated or in-progress types. - m map[dwarf.Type]*Type; - typedef map[string]ast.Expr; + m map[dwarf.Type]*Type + typedef map[string]ast.Expr // Predeclared types. - byte ast.Expr; // denotes padding - int8, int16, int32, int64 ast.Expr; - uint8, uint16, uint32, uint64, uintptr ast.Expr; - float32, float64 ast.Expr; - void ast.Expr; - unsafePointer ast.Expr; - string ast.Expr; + byte ast.Expr // denotes padding + int8, int16, int32, int64 ast.Expr + uint8, uint16, uint32, uint64, uintptr ast.Expr + float32, float64 ast.Expr + void ast.Expr + unsafePointer ast.Expr + string ast.Expr - ptrSize int64; + ptrSize int64 - tagGen int; + tagGen int } func (c *typeConv) Init(ptrSize int64) { - c.ptrSize = ptrSize; - c.m = make(map[dwarf.Type]*Type); - c.typedef = make(map[string]ast.Expr); - c.byte = c.Ident("byte"); - c.int8 = c.Ident("int8"); - c.int16 = c.Ident("int16"); - c.int32 = c.Ident("int32"); - c.int64 = c.Ident("int64"); - c.uint8 = c.Ident("uint8"); - c.uint16 = c.Ident("uint16"); - c.uint32 = c.Ident("uint32"); - c.uint64 = c.Ident("uint64"); - c.uintptr = c.Ident("uintptr"); - c.float32 = c.Ident("float32"); - c.float64 = c.Ident("float64"); - c.unsafePointer = c.Ident("unsafe.Pointer"); - c.void = c.Ident("void"); - c.string = c.Ident("string"); + c.ptrSize = ptrSize + c.m = make(map[dwarf.Type]*Type) + c.typedef = make(map[string]ast.Expr) + c.byte = c.Ident("byte") + c.int8 = c.Ident("int8") + c.int16 = c.Ident("int16") + c.int32 = c.Ident("int32") + c.int64 = c.Ident("int64") + c.uint8 = c.Ident("uint8") + c.uint16 = c.Ident("uint16") + c.uint32 = c.Ident("uint32") + c.uint64 = c.Ident("uint64") + c.uintptr = c.Ident("uintptr") + c.float32 = c.Ident("float32") + c.float64 = c.Ident("float64") + c.unsafePointer = c.Ident("unsafe.Pointer") + c.void = c.Ident("void") + c.string = c.Ident("string") } // base strips away qualifiers and typedefs to get the underlying type func base(dt dwarf.Type) dwarf.Type { for { if d, ok := dt.(*dwarf.QualType); ok { - dt = d.Type; - continue; + dt = d.Type + continue } if d, ok := dt.(*dwarf.TypedefType); ok { - dt = d.Type; - continue; + dt = d.Type + continue } - break; + break } - return dt; + return dt } // Map from dwarf text names to aliases we use in package "C". @@ -308,22 +308,22 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { if t.Go == nil { fatal("type conversion loop at %s", dtype) } - return t; + return t } - t := new(Type); - t.Size = dtype.Size(); - t.Align = -1; - t.C = dtype.Common().Name; - c.m[dtype] = t; + t := new(Type) + t.Size = dtype.Size() + t.Align = -1 + t.C = dtype.Common().Name + c.m[dtype] = t if t.Size < 0 { // Unsized types are [0]byte - t.Size = 0; - t.Go = c.Opaque(0); + t.Size = 0 + t.Go = c.Opaque(0) if t.C == "" { t.C = "void" } - return t; + return t } switch dt := dtype.(type) { @@ -334,30 +334,30 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { if t.Size != c.ptrSize { fatal("unexpected: %d-byte address type - %s", t.Size, dtype) } - t.Go = c.uintptr; - t.Align = t.Size; + t.Go = c.uintptr + t.Align = t.Size case *dwarf.ArrayType: if dt.StrideBitSize > 0 { // Cannot represent bit-sized elements in Go. - t.Go = c.Opaque(t.Size); - break; + t.Go = c.Opaque(t.Size) + break } gt := &ast.ArrayType{ Len: c.intExpr(dt.Count), - }; - t.Go = gt; // publish before recursive call - sub := c.Type(dt.Type); - t.Align = sub.Align; - gt.Elt = sub.Go; - t.C = fmt.Sprintf("typeof(%s[%d])", sub.C, dt.Count); + } + t.Go = gt // publish before recursive call + sub := c.Type(dt.Type) + t.Align = sub.Align + gt.Elt = sub.Go + t.C = fmt.Sprintf("typeof(%s[%d])", sub.C, dt.Count) case *dwarf.CharType: if t.Size != 1 { fatal("unexpected: %d-byte char type - %s", t.Size, dtype) } - t.Go = c.int8; - t.Align = 1; + t.Go = c.int8 + t.Align = 1 case *dwarf.EnumType: switch t.Size { @@ -375,7 +375,7 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { if t.Align = t.Size; t.Align >= c.ptrSize { t.Align = c.ptrSize } - t.C = "enum " + dt.EnumName; + t.C = "enum " + dt.EnumName case *dwarf.FloatType: switch t.Size { @@ -393,8 +393,8 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { case *dwarf.FuncType: // No attempt at translation: would enable calls // directly between worlds, but we need to moderate those. - t.Go = c.uintptr; - t.Align = c.ptrSize; + t.Go = c.uintptr + t.Align = c.ptrSize case *dwarf.IntType: if dt.BitSize > 0 { @@ -417,52 +417,52 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { } case *dwarf.PtrType: - t.Align = c.ptrSize; + t.Align = c.ptrSize // Translate void* as unsafe.Pointer if _, ok := base(dt.Type).(*dwarf.VoidType); ok { - t.Go = c.unsafePointer; - t.C = "void*"; - break; + t.Go = c.unsafePointer + t.C = "void*" + break } - gt := &ast.StarExpr{}; - t.Go = gt; // publish before recursive call - sub := c.Type(dt.Type); - gt.X = sub.Go; - t.C = sub.C + "*"; + gt := &ast.StarExpr{} + t.Go = gt // publish before recursive call + sub := c.Type(dt.Type) + gt.X = sub.Go + t.C = sub.C + "*" case *dwarf.QualType: // Ignore qualifier. - t = c.Type(dt.Type); - c.m[dtype] = t; - return t; + t = c.Type(dt.Type) + c.m[dtype] = t + return t case *dwarf.StructType: // Convert to Go struct, being careful about alignment. // Have to give it a name to simulate C "struct foo" references. - tag := dt.StructName; + tag := dt.StructName if tag == "" { - tag = "__" + strconv.Itoa(c.tagGen); - c.tagGen++; + tag = "__" + strconv.Itoa(c.tagGen) + c.tagGen++ } else if t.C == "" { t.C = dt.Kind + " " + tag } - name := c.Ident("_C" + dt.Kind + "_" + tag); - t.Go = name; // publish before recursive calls + name := c.Ident("_C" + dt.Kind + "_" + tag) + t.Go = name // publish before recursive calls switch dt.Kind { case "union", "class": - c.typedef[name.Value] = c.Opaque(t.Size); + c.typedef[name.Value] = c.Opaque(t.Size) if t.C == "" { t.C = fmt.Sprintf("typeof(unsigned char[%d])", t.Size) } case "struct": - g, csyntax, align := c.Struct(dt); + g, csyntax, align := c.Struct(dt) if t.C == "" { t.C = csyntax } - t.Align = align; - c.typedef[name.Value] = g; + t.Align = align + c.typedef[name.Value] = g } case *dwarf.TypedefType: @@ -471,16 +471,16 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { // Special C name for Go string type. // Knows string layout used by compilers: pointer plus length, // which rounds up to 2 pointers after alignment. - t.Go = c.string; - t.Size = c.ptrSize * 2; - t.Align = c.ptrSize; - break; - } - name := c.Ident("_C_" + dt.Name); - t.Go = name; // publish before recursive call - sub := c.Type(dt.Type); - t.Size = sub.Size; - t.Align = sub.Align; + t.Go = c.string + t.Size = c.ptrSize * 2 + t.Align = c.ptrSize + break + } + name := c.Ident("_C_" + dt.Name) + t.Go = name // publish before recursive call + sub := c.Type(dt.Type) + t.Size = sub.Size + t.Align = sub.Align if _, ok := c.typedef[name.Value]; !ok { c.typedef[name.Value] = sub.Go } @@ -489,8 +489,8 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { if t.Size != 1 { fatal("unexpected: %d-byte uchar type - %s", t.Size, dtype) } - t.Go = c.uint8; - t.Align = 1; + t.Go = c.uint8 + t.Align = 1 case *dwarf.UintType: if dt.BitSize > 0 { @@ -513,21 +513,21 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { } case *dwarf.VoidType: - t.Go = c.void; - t.C = "void"; + t.Go = c.void + t.C = "void" } switch dtype.(type) { case *dwarf.AddrType, *dwarf.CharType, *dwarf.IntType, *dwarf.FloatType, *dwarf.UcharType, *dwarf.UintType: - s := dtype.Common().Name; + s := dtype.Common().Name if s != "" { if ss, ok := cnameMap[s]; ok { s = ss } - s = strings.Join(strings.Split(s, " ", 0), ""); // strip spaces - name := c.Ident("_C_" + s); - c.typedef[name.Value] = t.Go; - t.Go = name; + s = strings.Join(strings.Split(s, " ", 0), "") // strip spaces + name := c.Ident("_C_" + s) + c.typedef[name.Value] = t.Go + t.Go = name } } @@ -535,13 +535,13 @@ func (c *typeConv) Type(dtype dwarf.Type) *Type { fatal("internal error: did not create C name for %s", dtype) } - return t; + return t } // FuncArg returns a Go type with the same memory layout as // dtype when used as the type of a C function argument. func (c *typeConv) FuncArg(dtype dwarf.Type) *Type { - t := c.Type(dtype); + t := c.Type(dtype) switch dt := dtype.(type) { case *dwarf.ArrayType: // Arrays are passed implicitly as pointers in C. @@ -565,14 +565,14 @@ func (c *typeConv) FuncArg(dtype dwarf.Type) *Type { } } } - return t; + return t } // FuncType returns the Go type analogous to dtype. // There is no guarantee about matching memory layout. func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType { - p := make([]*Type, len(dtype.ParamType)); - gp := make([]*ast.Field, len(dtype.ParamType)); + p := make([]*Type, len(dtype.ParamType)) + gp := make([]*ast.Field, len(dtype.ParamType)) for i, f := range dtype.ParamType { // gcc's DWARF generator outputs a single DotDotDotType parameter for // function pointers that specify no parameters (e.g. void @@ -580,17 +580,17 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType { // invalid according to ISO C anyway (i.e. void (*__cgo_1)(...) is not // legal). if _, ok := f.(*dwarf.DotDotDotType); ok && i == 0 { - p, gp = nil, nil; - break; + p, gp = nil, nil + break } - p[i] = c.FuncArg(f); - gp[i] = &ast.Field{Type: p[i].Go}; + p[i] = c.FuncArg(f) + gp[i] = &ast.Field{Type: p[i].Go} } - var r *Type; - var gr []*ast.Field; + var r *Type + var gr []*ast.Field if _, ok := dtype.ReturnType.(*dwarf.VoidType); !ok && dtype.ReturnType != nil { - r = c.Type(dtype.ReturnType); - gr = []*ast.Field{&ast.Field{Type: r.Go}}; + r = c.Type(dtype.ReturnType) + gr = []*ast.Field{&ast.Field{Type: r.Go}} } return &FuncType{ Params: p, @@ -599,11 +599,11 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType) *FuncType { Params: gp, Results: gr, }, - }; + } } // Identifier -func (c *typeConv) Ident(s string) *ast.Ident { return &ast.Ident{Value: s} } +func (c *typeConv) Ident(s string) *ast.Ident { return &ast.Ident{Value: s} } // Opaque type of n bytes. func (c *typeConv) Opaque(n int64) ast.Expr { @@ -623,17 +623,17 @@ func (c *typeConv) intExpr(n int64) ast.Expr { // Add padding of given size to fld. func (c *typeConv) pad(fld []*ast.Field, size int64) []*ast.Field { - n := len(fld); - fld = fld[0 : n+1]; - fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident("_")}, Type: c.Opaque(size)}; - return fld; + n := len(fld) + fld = fld[0 : n+1] + fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident("_")}, Type: c.Opaque(size)} + return fld } // Struct conversion func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax string, align int64) { - csyntax = "struct { "; - fld := make([]*ast.Field, 0, 2*len(dt.Field)+1); // enough for padding around every field - off := int64(0); + csyntax = "struct { " + fld := make([]*ast.Field, 0, 2*len(dt.Field)+1) // enough for padding around every field + off := int64(0) // Mangle struct fields that happen to be named Go keywords into // _{keyword}. Create a map from C ident -> Go ident. The Go ident will @@ -641,51 +641,51 @@ func (c *typeConv) Struct(dt *dwarf.StructType) (expr *ast.StructType, csyntax s // the C-side will cause the Go-mangled version to be prefixed with _. // (e.g. in a struct with fields '_type' and 'type', the latter would be // rendered as '__type' in Go). - ident := make(map[string]string); - used := make(map[string]bool); + ident := make(map[string]string) + used := make(map[string]bool) for _, f := range dt.Field { - ident[f.Name] = f.Name; - used[f.Name] = true; + ident[f.Name] = f.Name + used[f.Name] = true } for cid, goid := range ident { if token.Lookup(strings.Bytes(goid)).IsKeyword() { // Avoid keyword - goid = "_" + goid; + goid = "_" + goid // Also avoid existing fields for _, exist := used[goid]; exist; _, exist = used[goid] { goid = "_" + goid } - used[goid] = true; - ident[cid] = goid; + used[goid] = true + ident[cid] = goid } } for _, f := range dt.Field { if f.ByteOffset > off { - fld = c.pad(fld, f.ByteOffset-off); - off = f.ByteOffset; + fld = c.pad(fld, f.ByteOffset-off) + off = f.ByteOffset } - t := c.Type(f.Type); - n := len(fld); - fld = fld[0 : n+1]; + t := c.Type(f.Type) + n := len(fld) + fld = fld[0 : n+1] - fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go}; - off += t.Size; - csyntax += t.C + " " + f.Name + "; "; + fld[n] = &ast.Field{Names: []*ast.Ident{c.Ident(ident[f.Name])}, Type: t.Go} + off += t.Size + csyntax += t.C + " " + f.Name + "; " if t.Align > align { align = t.Align } } if off < dt.ByteSize { - fld = c.pad(fld, dt.ByteSize-off); - off = dt.ByteSize; + fld = c.pad(fld, dt.ByteSize-off) + off = dt.ByteSize } if off != dt.ByteSize { fatal("struct size calculation error") } - csyntax += "}"; - expr = &ast.StructType{Fields: fld}; - return; + csyntax += "}" + expr = &ast.StructType{Fields: fld} + return } diff --git a/src/cmd/cgo/main.go b/src/cmd/cgo/main.go index 8202b8e2b..373df3ba2 100644 --- a/src/cmd/cgo/main.go +++ b/src/cmd/cgo/main.go @@ -11,12 +11,12 @@ package main import ( - "fmt"; - "go/ast"; - "os"; + "fmt" + "go/ast" + "os" ) -func usage() { fmt.Fprint(os.Stderr, "usage: cgo [compiler options] file.go\n") } +func usage() { fmt.Fprint(os.Stderr, "usage: cgo [compiler options] file.go\n") } var ptrSizeMap = map[string]int64{ "386": 4, @@ -35,29 +35,29 @@ var expandName = map[string]string{ } func main() { - args := os.Args; + args := os.Args if len(args) < 2 { - usage(); - os.Exit(2); + usage() + os.Exit(2) } - gccOptions := args[1 : len(args)-1]; - input := args[len(args)-1]; + gccOptions := args[1 : len(args)-1] + input := args[len(args)-1] - arch := os.Getenv("GOARCH"); + arch := os.Getenv("GOARCH") if arch == "" { fatal("$GOARCH is not set") } - ptrSize, ok := ptrSizeMap[arch]; + ptrSize, ok := ptrSizeMap[arch] if !ok { fatal("unknown architecture %s", arch) } // Clear locale variables so gcc emits English errors [sic]. - os.Setenv("LANG", "en_US.UTF-8"); - os.Setenv("LC_ALL", "C"); - os.Setenv("LC_CTYPE", "C"); + os.Setenv("LANG", "en_US.UTF-8") + os.Setenv("LC_ALL", "C") + os.Setenv("LC_CTYPE", "C") - p := openProg(input); + p := openProg(input) for _, cref := range p.Crefs { // Convert C.ulong to C.unsigned long, etc. if expand, ok := expandName[cref.Name]; ok { @@ -65,42 +65,42 @@ func main() { } } - p.PtrSize = ptrSize; - p.Preamble = p.Preamble + "\n" + builtinProlog; - p.GccOptions = gccOptions; - p.loadDebugInfo(); - p.Vardef = make(map[string]*Type); - p.Funcdef = make(map[string]*FuncType); + p.PtrSize = ptrSize + p.Preamble = p.Preamble + "\n" + builtinProlog + p.GccOptions = gccOptions + p.loadDebugInfo() + p.Vardef = make(map[string]*Type) + p.Funcdef = make(map[string]*FuncType) for _, cref := range p.Crefs { switch cref.Context { case "call": if !cref.TypeName { // Is an actual function call. - *cref.Expr = &ast.Ident{Value: "_C_" + cref.Name}; - p.Funcdef[cref.Name] = cref.FuncType; - break; + *cref.Expr = &ast.Ident{Value: "_C_" + cref.Name} + p.Funcdef[cref.Name] = cref.FuncType + break } - *cref.Expr = cref.Type.Go; + *cref.Expr = cref.Type.Go case "expr": if cref.TypeName { error((*cref.Expr).Pos(), "type C.%s used as expression", cref.Name) } // Reference to C variable. // We declare a pointer and arrange to have it filled in. - *cref.Expr = &ast.StarExpr{X: &ast.Ident{Value: "_C_" + cref.Name}}; - p.Vardef[cref.Name] = cref.Type; + *cref.Expr = &ast.StarExpr{X: &ast.Ident{Value: "_C_" + cref.Name}} + p.Vardef[cref.Name] = cref.Type case "type": if !cref.TypeName { error((*cref.Expr).Pos(), "expression C.%s used as type", cref.Name) } - *cref.Expr = cref.Type.Go; + *cref.Expr = cref.Type.Go } } if nerrors > 0 { os.Exit(2) } - p.PackagePath = os.Getenv("CGOPKGPATH") + "/" + p.Package; - p.writeOutput(input); + p.PackagePath = os.Getenv("CGOPKGPATH") + "/" + p.Package + p.writeOutput(input) } diff --git a/src/cmd/cgo/out.go b/src/cmd/cgo/out.go index 297ffe40a..9c85bc598 100644 --- a/src/cmd/cgo/out.go +++ b/src/cmd/cgo/out.go @@ -5,78 +5,78 @@ package main import ( - "fmt"; - "go/ast"; - "go/printer"; - "os"; - "strings"; + "fmt" + "go/ast" + "go/printer" + "os" + "strings" ) func creat(name string) *os.File { - f, err := os.Open(name, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, 0666); + f, err := os.Open(name, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, 0666) if err != nil { fatal("%s", err) } - return f; + return f } // writeOutput creates output files to be compiled by 6g, 6c, and gcc. // (The comments here say 6g and 6c but the code applies to the 8 and 5 tools too.) func (p *Prog) writeOutput(srcfile string) { - pkgroot := os.Getenv("GOROOT") + "/pkg/" + os.Getenv("GOOS") + "_" + os.Getenv("GOARCH"); + pkgroot := os.Getenv("GOROOT") + "/pkg/" + os.Getenv("GOOS") + "_" + os.Getenv("GOARCH") - base := srcfile; + base := srcfile if strings.HasSuffix(base, ".go") { base = base[0 : len(base)-3] } - fgo1 := creat(base + ".cgo1.go"); - fgo2 := creat(base + ".cgo2.go"); - fc := creat(base + ".cgo3.c"); - fgcc := creat(base + ".cgo4.c"); + fgo1 := creat(base + ".cgo1.go") + fgo2 := creat(base + ".cgo2.go") + fc := creat(base + ".cgo3.c") + fgcc := creat(base + ".cgo4.c") // Write Go output: Go input with rewrites of C.xxx to _C_xxx. - fmt.Fprintf(fgo1, "// Created by cgo - DO NOT EDIT\n"); - fmt.Fprintf(fgo1, "//line %s:1\n", srcfile); - printer.Fprint(fgo1, p.AST); + fmt.Fprintf(fgo1, "// Created by cgo - DO NOT EDIT\n") + fmt.Fprintf(fgo1, "//line %s:1\n", srcfile) + printer.Fprint(fgo1, p.AST) // Write second Go output: definitions of _C_xxx. // In a separate file so that the import of "unsafe" does not // pollute the original file. - fmt.Fprintf(fgo2, "// Created by cgo - DO NOT EDIT\n"); - fmt.Fprintf(fgo2, "package %s\n\n", p.Package); - fmt.Fprintf(fgo2, "import \"unsafe\"\n\n"); - fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n"); + fmt.Fprintf(fgo2, "// Created by cgo - DO NOT EDIT\n") + fmt.Fprintf(fgo2, "package %s\n\n", p.Package) + fmt.Fprintf(fgo2, "import \"unsafe\"\n\n") + fmt.Fprintf(fgo2, "type _ unsafe.Pointer\n\n") for name, def := range p.Typedef { - fmt.Fprintf(fgo2, "type %s ", name); - printer.Fprint(fgo2, def); - fmt.Fprintf(fgo2, "\n"); + fmt.Fprintf(fgo2, "type %s ", name) + printer.Fprint(fgo2, def) + fmt.Fprintf(fgo2, "\n") } - fmt.Fprintf(fgo2, "type _C_void [0]byte\n"); + fmt.Fprintf(fgo2, "type _C_void [0]byte\n") // While we process the vars and funcs, also write 6c and gcc output. // Gcc output starts with the preamble. - fmt.Fprintf(fgcc, "%s\n", p.Preamble); - fmt.Fprintf(fgcc, "%s\n", gccProlog); + fmt.Fprintf(fgcc, "%s\n", p.Preamble) + fmt.Fprintf(fgcc, "%s\n", gccProlog) - fmt.Fprintf(fc, cProlog, pkgroot, pkgroot, pkgroot, pkgroot, p.Package, p.Package); + fmt.Fprintf(fc, cProlog, pkgroot, pkgroot, pkgroot, pkgroot, p.Package, p.Package) for name, def := range p.Vardef { - fmt.Fprintf(fc, "#pragma dynld %s·_C_%s %s \"%s/%s_%s.so\"\n", p.Package, name, name, pkgroot, p.PackagePath, base); - fmt.Fprintf(fgo2, "var _C_%s ", name); - printer.Fprint(fgo2, &ast.StarExpr{X: def.Go}); - fmt.Fprintf(fgo2, "\n"); + fmt.Fprintf(fc, "#pragma dynld %s·_C_%s %s \"%s/%s_%s.so\"\n", p.Package, name, name, pkgroot, p.PackagePath, base) + fmt.Fprintf(fgo2, "var _C_%s ", name) + printer.Fprint(fgo2, &ast.StarExpr{X: def.Go}) + fmt.Fprintf(fgo2, "\n") } - fmt.Fprintf(fc, "\n"); + fmt.Fprintf(fc, "\n") for name, def := range p.Funcdef { // Go func declaration. d := &ast.FuncDecl{ Name: &ast.Ident{Value: "_C_" + name}, Type: def.Go, - }; - printer.Fprint(fgo2, d); - fmt.Fprintf(fgo2, "\n"); + } + printer.Fprint(fgo2, d) + fmt.Fprintf(fgo2, "\n") if name == "CString" || name == "GoString" { // The builtins are already defined in the C prolog. @@ -88,86 +88,86 @@ func (p *Prog) writeOutput(srcfile string) { // These assumptions are checked by the gccProlog. // Also assumes that 6c convention is to word-align the // input and output parameters. - structType := "struct {\n"; - off := int64(0); - npad := 0; + structType := "struct {\n" + off := int64(0) + npad := 0 for i, t := range def.Params { if off%t.Align != 0 { - pad := t.Align - off%t.Align; - structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad); - off += pad; - npad++; + pad := t.Align - off%t.Align + structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad) + off += pad + npad++ } - structType += fmt.Sprintf("\t\t%s p%d;\n", t.C, i); - off += t.Size; + structType += fmt.Sprintf("\t\t%s p%d;\n", t.C, i) + off += t.Size } if off%p.PtrSize != 0 { - pad := p.PtrSize - off%p.PtrSize; - structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad); - off += pad; - npad++; + pad := p.PtrSize - off%p.PtrSize + structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad) + off += pad + npad++ } if t := def.Result; t != nil { if off%t.Align != 0 { - pad := t.Align - off%t.Align; - structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad); - off += pad; - npad++; + pad := t.Align - off%t.Align + structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad) + off += pad + npad++ } - structType += fmt.Sprintf("\t\t%s r;\n", t.C); - off += t.Size; + structType += fmt.Sprintf("\t\t%s r;\n", t.C) + off += t.Size } if off%p.PtrSize != 0 { - pad := p.PtrSize - off%p.PtrSize; - structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad); - off += pad; - npad++; + pad := p.PtrSize - off%p.PtrSize + structType += fmt.Sprintf("\t\tchar __pad%d[%d];\n", npad, pad) + off += pad + npad++ } if len(def.Params) == 0 && def.Result == nil { - structType += "\t\tchar unused;\n"; // avoid empty struct - off++; + structType += "\t\tchar unused;\n" // avoid empty struct + off++ } - structType += "\t}"; - argSize := off; + structType += "\t}" + argSize := off // C wrapper calls into gcc, passing a pointer to the argument frame. // Also emit #pragma to get a pointer to the gcc wrapper. - fmt.Fprintf(fc, "#pragma dynld _cgo_%s _cgo_%s \"%s/%s_%s.so\"\n", name, name, pkgroot, p.PackagePath, base); - fmt.Fprintf(fc, "void (*_cgo_%s)(void*);\n", name); - fmt.Fprintf(fc, "\n"); - fmt.Fprintf(fc, "void\n"); - fmt.Fprintf(fc, "%s·_C_%s(struct{uint8 x[%d];}p)\n", p.Package, name, argSize); - fmt.Fprintf(fc, "{\n"); - fmt.Fprintf(fc, "\tcgocall(_cgo_%s, &p);\n", name); - fmt.Fprintf(fc, "}\n"); - fmt.Fprintf(fc, "\n"); + fmt.Fprintf(fc, "#pragma dynld _cgo_%s _cgo_%s \"%s/%s_%s.so\"\n", name, name, pkgroot, p.PackagePath, base) + fmt.Fprintf(fc, "void (*_cgo_%s)(void*);\n", name) + fmt.Fprintf(fc, "\n") + fmt.Fprintf(fc, "void\n") + fmt.Fprintf(fc, "%s·_C_%s(struct{uint8 x[%d];}p)\n", p.Package, name, argSize) + fmt.Fprintf(fc, "{\n") + fmt.Fprintf(fc, "\tcgocall(_cgo_%s, &p);\n", name) + fmt.Fprintf(fc, "}\n") + fmt.Fprintf(fc, "\n") // Gcc wrapper unpacks the C argument struct // and calls the actual C function. - fmt.Fprintf(fgcc, "void\n"); - fmt.Fprintf(fgcc, "_cgo_%s(void *v)\n", name); - fmt.Fprintf(fgcc, "{\n"); - fmt.Fprintf(fgcc, "\t%s *a = v;\n", structType); - fmt.Fprintf(fgcc, "\t"); + fmt.Fprintf(fgcc, "void\n") + fmt.Fprintf(fgcc, "_cgo_%s(void *v)\n", name) + fmt.Fprintf(fgcc, "{\n") + fmt.Fprintf(fgcc, "\t%s *a = v;\n", structType) + fmt.Fprintf(fgcc, "\t") if def.Result != nil { fmt.Fprintf(fgcc, "a->r = ") } - fmt.Fprintf(fgcc, "%s(", name); + fmt.Fprintf(fgcc, "%s(", name) for i := range def.Params { if i > 0 { fmt.Fprintf(fgcc, ", ") } - fmt.Fprintf(fgcc, "a->p%d", i); + fmt.Fprintf(fgcc, "a->p%d", i) } - fmt.Fprintf(fgcc, ");\n"); - fmt.Fprintf(fgcc, "}\n"); - fmt.Fprintf(fgcc, "\n"); + fmt.Fprintf(fgcc, ");\n") + fmt.Fprintf(fgcc, "}\n") + fmt.Fprintf(fgcc, "\n") } - fgo1.Close(); - fgo2.Close(); - fc.Close(); - fgcc.Close(); + fgo1.Close() + fgo2.Close() + fc.Close() + fgcc.Close() } const gccProlog = ` diff --git a/src/cmd/cgo/util.go b/src/cmd/cgo/util.go index 176e9528e..782efddf4 100644 --- a/src/cmd/cgo/util.go +++ b/src/cmd/cgo/util.go @@ -5,11 +5,11 @@ package main import ( - "exec"; - "fmt"; - "go/token"; - "io/ioutil"; - "os"; + "exec" + "fmt" + "go/token" + "io/ioutil" + "os" ) // A ByteReaderAt implements io.ReadAt using a slice of bytes. @@ -19,76 +19,76 @@ func (r ByteReaderAt) ReadAt(p []byte, off int64) (n int, err os.Error) { if off >= int64(len(r)) || off < 0 { return 0, os.EOF } - return copy(p, r[off:]), nil; + return copy(p, r[off:]), nil } // run runs the command argv, feeding in stdin on standard input. // It returns the output to standard output and standard error. // ok indicates whether the command exited successfully. func run(stdin []byte, argv []string) (stdout, stderr []byte, ok bool) { - cmd, err := exec.LookPath(argv[0]); + cmd, err := exec.LookPath(argv[0]) if err != nil { fatal("exec %s: %s", argv[0], err) } - r0, w0, err := os.Pipe(); + r0, w0, err := os.Pipe() if err != nil { fatal("%s", err) } - r1, w1, err := os.Pipe(); + r1, w1, err := os.Pipe() if err != nil { fatal("%s", err) } - r2, w2, err := os.Pipe(); + r2, w2, err := os.Pipe() if err != nil { fatal("%s", err) } - pid, err := os.ForkExec(cmd, argv, os.Environ(), "", []*os.File{r0, w1, w2}); + pid, err := os.ForkExec(cmd, argv, os.Environ(), "", []*os.File{r0, w1, w2}) if err != nil { fatal("%s", err) } - r0.Close(); - w1.Close(); - w2.Close(); - c := make(chan bool); + r0.Close() + w1.Close() + w2.Close() + c := make(chan bool) go func() { - w0.Write(stdin); - w0.Close(); - c <- true; - }(); - var xstdout []byte; // TODO(rsc): delete after 6g can take address of out parameter + w0.Write(stdin) + w0.Close() + c <- true + }() + var xstdout []byte // TODO(rsc): delete after 6g can take address of out parameter go func() { - xstdout, _ = ioutil.ReadAll(r1); - r1.Close(); - c <- true; - }(); - stderr, _ = ioutil.ReadAll(r2); - r2.Close(); - <-c; - <-c; - stdout = xstdout; + xstdout, _ = ioutil.ReadAll(r1) + r1.Close() + c <- true + }() + stderr, _ = ioutil.ReadAll(r2) + r2.Close() + <-c + <-c + stdout = xstdout - w, err := os.Wait(pid, 0); + w, err := os.Wait(pid, 0) if err != nil { fatal("%s", err) } - ok = w.Exited() && w.ExitStatus() == 0; - return; + ok = w.Exited() && w.ExitStatus() == 0 + return } // Die with an error message. func fatal(msg string, args ...) { - fmt.Fprintf(os.Stderr, msg+"\n", args); - os.Exit(2); + fmt.Fprintf(os.Stderr, msg+"\n", args) + os.Exit(2) } var nerrors int var noPos token.Position func error(pos token.Position, msg string, args ...) { - nerrors++; + nerrors++ if pos.IsValid() { fmt.Fprintf(os.Stderr, "%s: ", pos) } - fmt.Fprintf(os.Stderr, msg, args); - fmt.Fprintf(os.Stderr, "\n"); + fmt.Fprintf(os.Stderr, msg, args) + fmt.Fprintf(os.Stderr, "\n") } diff --git a/src/cmd/ebnflint/ebnflint.go b/src/cmd/ebnflint/ebnflint.go index 4904780a3..9d391249d 100644 --- a/src/cmd/ebnflint/ebnflint.go +++ b/src/cmd/ebnflint/ebnflint.go @@ -5,15 +5,15 @@ package main import ( - "bytes"; - "ebnf"; - "flag"; - "fmt"; - "go/scanner"; - "io/ioutil"; - "os"; - "path"; - "strings"; + "bytes" + "ebnf" + "flag" + "fmt" + "go/scanner" + "io/ioutil" + "os" + "path" + "strings" ) @@ -21,29 +21,29 @@ var start = flag.String("start", "Start", "name of start production") func usage() { - fmt.Fprintf(os.Stderr, "usage: ebnflint [flags] [filename]\n"); - flag.PrintDefaults(); - os.Exit(1); + fmt.Fprintf(os.Stderr, "usage: ebnflint [flags] [filename]\n") + flag.PrintDefaults() + os.Exit(1) } // Markers around EBNF sections in .html files var ( - open = strings.Bytes(`<pre class="ebnf">`); - close = strings.Bytes(`</pre>`); + open = strings.Bytes(`<pre class="ebnf">`) + close = strings.Bytes(`</pre>`) ) func extractEBNF(src []byte) []byte { - var buf bytes.Buffer; + var buf bytes.Buffer for { // i = beginning of EBNF text - i := bytes.Index(src, open); + i := bytes.Index(src, open) if i < 0 { - break // no EBNF found - we are done + break // no EBNF found - we are done } - i += len(open); + i += len(open) // write as many newlines as found in the excluded text // to maintain correct line numbers in error messages @@ -54,27 +54,27 @@ func extractEBNF(src []byte) []byte { } // j = end of EBNF text (or end of source) - j := bytes.Index(src[i:], close); // close marker + j := bytes.Index(src[i:], close) // close marker if j < 0 { j = len(src) - i } - j += i; + j += i // copy EBNF text - buf.Write(src[i:j]); + buf.Write(src[i:j]) // advance - src = src[j:]; + src = src[j:] } - return buf.Bytes(); + return buf.Bytes() } func main() { - flag.Parse(); + flag.Parse() - var filename string; + var filename string switch flag.NArg() { case 0: filename = "/dev/stdin" @@ -84,7 +84,7 @@ func main() { usage() } - src, err := ioutil.ReadFile(filename); + src, err := ioutil.ReadFile(filename) if err != nil { scanner.PrintError(os.Stderr, err) } @@ -93,7 +93,7 @@ func main() { src = extractEBNF(src) } - grammar, err := ebnf.Parse(filename, src); + grammar, err := ebnf.Parse(filename, src) if err != nil { scanner.PrintError(os.Stderr, err) } diff --git a/src/cmd/gc/runtime.go b/src/cmd/gc/runtime.go index baca93c8c..2e21d2511 100644 --- a/src/cmd/gc/runtime.go +++ b/src/cmd/gc/runtime.go @@ -84,7 +84,7 @@ func sliceslice1(old []any, lb int, width int) (ary []any) func sliceslice(old []any, lb int, hb int, width int) (ary []any) func slicearray(old *any, nel int, lb int, hb int, width int) (ary []any) -func closure() // has args, but compiler fills in +func closure() // has args, but compiler fills in // only used on 32-bit func int64div(int64, int64) int64 diff --git a/src/cmd/godoc/godoc.go b/src/cmd/godoc/godoc.go index 62258ba65..1e4eb1625 100644 --- a/src/cmd/godoc/godoc.go +++ b/src/cmd/godoc/godoc.go @@ -5,26 +5,26 @@ package main import ( - "bytes"; - "flag"; - "fmt"; - "go/ast"; - "go/doc"; - "go/parser"; - "go/printer"; - "go/token"; - "http"; - "io"; - "io/ioutil"; - "log"; - "os"; - pathutil "path"; - "strings"; - "sync"; - "template"; - "time"; - "unicode"; - "utf8"; + "bytes" + "flag" + "fmt" + "go/ast" + "go/doc" + "go/parser" + "go/printer" + "go/token" + "http" + "io" + "io/ioutil" + "log" + "os" + pathutil "path" + "strings" + "sync" + "template" + "time" + "unicode" + "utf8" ) @@ -34,24 +34,24 @@ import ( // An RWValue wraps a value and permits mutually exclusive // access to it and records the time the value was last set. type RWValue struct { - mutex sync.RWMutex; - value interface{}; - timestamp int64; // time of last set(), in seconds since epoch + mutex sync.RWMutex + value interface{} + timestamp int64 // time of last set(), in seconds since epoch } func (v *RWValue) set(value interface{}) { - v.mutex.Lock(); - v.value = value; - v.timestamp = time.Seconds(); - v.mutex.Unlock(); + v.mutex.Lock() + v.value = value + v.timestamp = time.Seconds() + v.mutex.Unlock() } func (v *RWValue) get() (interface{}, int64) { - v.mutex.RLock(); - defer v.mutex.RUnlock(); - return v.value, v.timestamp; + v.mutex.RLock() + defer v.mutex.RUnlock() + return v.value, v.timestamp } @@ -59,44 +59,44 @@ func (v *RWValue) get() (interface{}, int64) { // Globals type delayTime struct { - RWValue; + RWValue } func (dt *delayTime) backoff(max int) { - dt.mutex.Lock(); - v := dt.value.(int) * 2; + dt.mutex.Lock() + v := dt.value.(int) * 2 if v > max { v = max } - dt.value = v; - dt.mutex.Unlock(); + dt.value = v + dt.mutex.Unlock() } var ( - verbose = flag.Bool("v", false, "verbose mode"); + verbose = flag.Bool("v", false, "verbose mode") // file system roots - goroot string; - cmdroot = flag.String("cmdroot", "src/cmd", "root command source directory (if unrooted, relative to goroot)"); - pkgroot = flag.String("pkgroot", "src/pkg", "root package source directory (if unrooted, relative to goroot)"); - tmplroot = flag.String("tmplroot", "lib/godoc", "root template directory (if unrooted, relative to goroot)"); + goroot string + cmdroot = flag.String("cmdroot", "src/cmd", "root command source directory (if unrooted, relative to goroot)") + pkgroot = flag.String("pkgroot", "src/pkg", "root package source directory (if unrooted, relative to goroot)") + tmplroot = flag.String("tmplroot", "lib/godoc", "root template directory (if unrooted, relative to goroot)") // layout control - tabwidth = flag.Int("tabwidth", 4, "tab width"); + tabwidth = flag.Int("tabwidth", 4, "tab width") ) -var fsTree RWValue // *Directory tree of packages, updated with each sync +var fsTree RWValue // *Directory tree of packages, updated with each sync func init() { - goroot = os.Getenv("GOROOT"); + goroot = os.Getenv("GOROOT") if goroot == "" { goroot = pathutil.Join(os.Getenv("HOME"), "go") } - flag.StringVar(&goroot, "goroot", goroot, "Go root directory"); + flag.StringVar(&goroot, "goroot", goroot, "Go root directory") } @@ -105,14 +105,14 @@ func init() { func isGoFile(dir *os.Dir) bool { return dir.IsRegular() && - !strings.HasPrefix(dir.Name, ".") && // ignore .files + !strings.HasPrefix(dir.Name, ".") && // ignore .files pathutil.Ext(dir.Name) == ".go" } func isPkgFile(dir *os.Dir) bool { return isGoFile(dir) && - !strings.HasSuffix(dir.Name, "_test.go") // ignore test files + !strings.HasSuffix(dir.Name, "_test.go") // ignore test files } @@ -122,54 +122,54 @@ func isPkgDir(dir *os.Dir) bool { func pkgName(filename string) string { - file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly); + file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly) if err != nil || file == nil { return "" } - return file.Name.Value; + return file.Name.Value } func htmlEscape(s string) string { - var buf bytes.Buffer; - template.HTMLEscape(&buf, strings.Bytes(s)); - return buf.String(); + var buf bytes.Buffer + template.HTMLEscape(&buf, strings.Bytes(s)) + return buf.String() } func firstSentence(s string) string { - i := -1; // index+1 of first period - j := -1; // index+1 of first period that is followed by white space - prev := 'A'; + i := -1 // index+1 of first period + j := -1 // index+1 of first period that is followed by white space + prev := 'A' for k, ch := range s { - k1 := k + 1; + k1 := k + 1 if ch == '.' { if i < 0 { - i = k1 // first period + i = k1 // first period } if k1 < len(s) && s[k1] <= ' ' { if j < 0 { - j = k1 // first period followed by white space + j = k1 // first period followed by white space } if !unicode.IsUpper(prev) { - j = k1; - break; + j = k1 + break } } } - prev = ch; + prev = ch } if j < 0 { // use the next best period - j = i; + j = i if j < 0 { // no period at all, use the entire string j = len(s) } } - return s[0:j]; + return s[0:j] } @@ -177,11 +177,11 @@ func firstSentence(s string) string { // Package directories type Directory struct { - Depth int; - Path string; // includes Name - Name string; - Text string; // package documentation, if any - Dirs []*Directory; // subdirectories + Depth int + Path string // includes Name + Name string + Text string // package documentation, if any + Dirs []*Directory // subdirectories } @@ -193,22 +193,22 @@ func newDirTree(path, name string, depth, maxDepth int) *Directory { return &Directory{depth, path, name, "", nil} } - list, _ := ioutil.ReadDir(path); // ignore errors + list, _ := ioutil.ReadDir(path) // ignore errors // determine number of subdirectories and package files - ndirs := 0; - nfiles := 0; - text := ""; + ndirs := 0 + nfiles := 0 + text := "" for _, d := range list { switch { case isPkgDir(d): ndirs++ case isPkgFile(d): - nfiles++; + nfiles++ if text == "" { // no package documentation yet; take the first found file, err := parser.ParseFile(pathutil.Join(path, d.Name), nil, - parser.ParseComments|parser.PackageClauseOnly); + parser.ParseComments|parser.PackageClauseOnly) if err == nil && // Also accept fakePkgName, so we get synopses for commmands. // Note: This may lead to incorrect results if there is a @@ -225,20 +225,20 @@ func newDirTree(path, name string, depth, maxDepth int) *Directory { } // create subdirectory tree - var dirs []*Directory; + var dirs []*Directory if ndirs > 0 { - dirs = make([]*Directory, ndirs); - i := 0; + dirs = make([]*Directory, ndirs) + i := 0 for _, d := range list { if isPkgDir(d) { - dd := newDirTree(pathutil.Join(path, d.Name), d.Name, depth+1, maxDepth); + dd := newDirTree(pathutil.Join(path, d.Name), d.Name, depth+1, maxDepth) if dd != nil { - dirs[i] = dd; - i++; + dirs[i] = dd + i++ } } } - dirs = dirs[0:i]; + dirs = dirs[0:i] } // if there are no package files and no subdirectories @@ -247,7 +247,7 @@ func newDirTree(path, name string, depth, maxDepth int) *Directory { return nil } - return &Directory{depth, path, name, text, dirs}; + return &Directory{depth, path, name, text, dirs} } @@ -257,11 +257,11 @@ func newDirTree(path, name string, depth, maxDepth int) *Directory { // subdirectories containing package files (transitively). // func newDirectory(root string, maxDepth int) *Directory { - d, err := os.Lstat(root); + d, err := os.Lstat(root) if err != nil || !isPkgDir(d) { return nil } - return newDirTree(root, d.Name, 0, maxDepth); + return newDirTree(root, d.Name, 0, maxDepth) } @@ -278,24 +278,24 @@ func (dir *Directory) walk(c chan<- *Directory, skipRoot bool) { func (dir *Directory) iter(skipRoot bool) <-chan *Directory { - c := make(chan *Directory); + c := make(chan *Directory) go func() { - dir.walk(c, skipRoot); - close(c); - }(); - return c; + dir.walk(c, skipRoot) + close(c) + }() + return c } // lookup looks for the *Directory for a given path, relative to dir. func (dir *Directory) lookup(path string) *Directory { - path = pathutil.Clean(path); // no trailing '/' + path = pathutil.Clean(path) // no trailing '/' if dir == nil || path == "" || path == "." { return dir } - dpath, dname := pathutil.Split(path); + dpath, dname := pathutil.Split(path) if dpath == "" { // directory-local name for _, d := range dir.Dirs { @@ -303,10 +303,10 @@ func (dir *Directory) lookup(path string) *Directory { return d } } - return nil; + return nil } - return dir.lookup(dpath).lookup(dname); + return dir.lookup(dpath).lookup(dname) } @@ -314,17 +314,17 @@ func (dir *Directory) lookup(path string) *Directory { // are useful for presenting an entry in an indented fashion. // type DirEntry struct { - Depth int; // >= 0 - Height int; // = DirList.MaxHeight - Depth, > 0 - Path string; // includes Name, relative to DirList root - Name string; - Synopsis string; + Depth int // >= 0 + Height int // = DirList.MaxHeight - Depth, > 0 + Path string // includes Name, relative to DirList root + Name string + Synopsis string } type DirList struct { - MaxHeight int; // directory tree height, > 0 - List []DirEntry; + MaxHeight int // directory tree height, > 0 + List []DirEntry } @@ -337,11 +337,11 @@ func (root *Directory) listing(skipRoot bool) *DirList { } // determine number of entries n and maximum height - n := 0; - minDepth := 1 << 30; // infinity - maxDepth := 0; + n := 0 + minDepth := 1 << 30 // infinity + maxDepth := 0 for d := range root.iter(skipRoot) { - n++; + n++ if minDepth > d.Depth { minDepth = d.Depth } @@ -349,23 +349,23 @@ func (root *Directory) listing(skipRoot bool) *DirList { maxDepth = d.Depth } } - maxHeight := maxDepth - minDepth + 1; + maxHeight := maxDepth - minDepth + 1 if n == 0 { return nil } // create list - list := make([]DirEntry, n); - i := 0; + list := make([]DirEntry, n) + i := 0 for d := range root.iter(skipRoot) { - p := &list[i]; - p.Depth = d.Depth - minDepth; - p.Height = maxHeight - p.Depth; + p := &list[i] + p.Depth = d.Depth - minDepth + p.Height = maxHeight - p.Depth // the path is relative to root.Path - remove the root.Path // prefix (the prefix should always be present but avoid // crashes and check) - path := d.Path; + path := d.Path if strings.HasPrefix(d.Path, root.Path) { path = d.Path[len(root.Path):] } @@ -373,27 +373,27 @@ func (root *Directory) listing(skipRoot bool) *DirList { if len(path) > 0 && path[0] == '/' { path = path[1:] } - p.Path = path; - p.Name = d.Name; - p.Synopsis = d.Text; - i++; + p.Path = path + p.Name = d.Name + p.Synopsis = d.Text + i++ } - return &DirList{maxHeight, list}; + return &DirList{maxHeight, list} } func listing(dirs []*os.Dir) *DirList { - list := make([]DirEntry, len(dirs)+1); - list[0] = DirEntry{0, 1, "..", "..", ""}; + list := make([]DirEntry, len(dirs)+1) + list[0] = DirEntry{0, 1, "..", "..", ""} for i, d := range dirs { - p := &list[i+1]; - p.Depth = 0; - p.Height = 1; - p.Path = d.Name; - p.Name = d.Name; + p := &list[i+1] + p.Depth = 0 + p.Height = 1 + p.Path = d.Name + p.Name = d.Name } - return &DirList{1, list}; + return &DirList{1, list} } @@ -402,8 +402,8 @@ func listing(dirs []*os.Dir) *DirList { // Styler implements a printer.Styler. type Styler struct { - linetags bool; - highlight string; + linetags bool + highlight string } @@ -419,37 +419,37 @@ func (s *Styler) LineTag(line int) (text []byte, tag printer.HTMLTag) { if s.linetags { tag = printer.HTMLTag{fmt.Sprintf(`<a id="L%d">`, line), "</a>"} } - return; + return } func (s *Styler) Comment(c *ast.Comment, line []byte) (text []byte, tag printer.HTMLTag) { - text = line; + text = line // minimal syntax-coloring of comments for now - people will want more // (don't do anything more until there's a button to turn it on/off) - tag = printer.HTMLTag{`<span class="comment">`, "</span>"}; - return; + tag = printer.HTMLTag{`<span class="comment">`, "</span>"} + return } func (s *Styler) BasicLit(x *ast.BasicLit) (text []byte, tag printer.HTMLTag) { - text = x.Value; - return; + text = x.Value + return } func (s *Styler) Ident(id *ast.Ident) (text []byte, tag printer.HTMLTag) { - text = strings.Bytes(id.Value); + text = strings.Bytes(id.Value) if s.highlight == id.Value { tag = printer.HTMLTag{"<span class=highlight>", "</span>"} } - return; + return } func (s *Styler) Token(tok token.Token) (text []byte, tag printer.HTMLTag) { - text = strings.Bytes(tok.String()); - return; + text = strings.Bytes(tok.String()) + return } @@ -458,27 +458,27 @@ func (s *Styler) Token(tok token.Token) (text []byte, tag printer.HTMLTag) { // Write an AST-node to w; optionally html-escaped. func writeNode(w io.Writer, node interface{}, html bool, styler printer.Styler) { - mode := printer.UseSpaces | printer.NoSemis; + mode := printer.UseSpaces | printer.NoSemis if html { mode |= printer.GenHTML } - (&printer.Config{mode, *tabwidth, styler}).Fprint(w, node); + (&printer.Config{mode, *tabwidth, styler}).Fprint(w, node) } // Write text to w; optionally html-escaped. func writeText(w io.Writer, text []byte, html bool) { if html { - template.HTMLEscape(w, text); - return; + template.HTMLEscape(w, text) + return } - w.Write(text); + w.Write(text) } type StyledNode struct { - node interface{}; - styler printer.Styler; + node interface{} + styler printer.Styler } @@ -495,9 +495,9 @@ func writeAny(w io.Writer, x interface{}, html bool) { writeNode(w, v.node, html, v.styler) default: if html { - var buf bytes.Buffer; - fmt.Fprint(&buf, x); - writeText(w, buf.Bytes(), true); + var buf bytes.Buffer + fmt.Fprint(&buf, x) + writeText(w, buf.Bytes(), true) } else { fmt.Fprint(w, x) } @@ -513,9 +513,9 @@ func htmlFmt(w io.Writer, x interface{}, format string) { // Template formatter for "html-comment" format. func htmlCommentFmt(w io.Writer, x interface{}, format string) { - var buf bytes.Buffer; - writeAny(&buf, x, false); - doc.ToHTML(w, buf.Bytes()); // does html-escaping + var buf bytes.Buffer + writeAny(&buf, x, false) + doc.ToHTML(w, buf.Bytes()) // does html-escaping } @@ -529,7 +529,7 @@ func removePrefix(s, prefix string) string { if strings.HasPrefix(s, prefix) { return s[len(prefix):] } - return s; + return s } @@ -545,10 +545,10 @@ func pathFmt(w io.Writer, x interface{}, format string) { // Template formatter for "link" format. func linkFmt(w io.Writer, x interface{}, format string) { type Positioner interface { - Pos() token.Position; + Pos() token.Position } if node, ok := x.(Positioner); ok { - pos := node.Pos(); + pos := node.Pos() if pos.IsValid() { // line id's in html-printed source are of the // form "L%d" where %d stands for the line number @@ -573,33 +573,33 @@ var infoKinds = [nKinds]string{ // Template formatter for "infoKind" format. func infoKindFmt(w io.Writer, x interface{}, format string) { - fmt.Fprintf(w, infoKinds[x.(SpotKind)]) // infoKind entries are html-escaped + fmt.Fprintf(w, infoKinds[x.(SpotKind)]) // infoKind entries are html-escaped } // Template formatter for "infoLine" format. func infoLineFmt(w io.Writer, x interface{}, format string) { - info := x.(SpotInfo); - line := info.Lori(); + info := x.(SpotInfo) + line := info.Lori() if info.IsIndex() { - index, _ := searchIndex.get(); - line = index.(*Index).Snippet(line).Line; + index, _ := searchIndex.get() + line = index.(*Index).Snippet(line).Line } - fmt.Fprintf(w, "%d", line); + fmt.Fprintf(w, "%d", line) } // Template formatter for "infoSnippet" format. func infoSnippetFmt(w io.Writer, x interface{}, format string) { - info := x.(SpotInfo); - text := `<span class="alert">no snippet text available</span>`; + info := x.(SpotInfo) + text := `<span class="alert">no snippet text available</span>` if info.IsIndex() { - index, _ := searchIndex.get(); + index, _ := searchIndex.get() // no escaping of snippet text needed; // snippet text is escaped when generated - text = index.(*Index).Snippet(info.Lori()).Text; + text = index.(*Index).Snippet(info.Lori()).Text } - fmt.Fprint(w, text); + fmt.Fprint(w, text) } @@ -633,16 +633,16 @@ var fmap = template.FormatterMap{ func readTemplate(name string) *template.Template { - path := pathutil.Join(*tmplroot, name); - data, err := ioutil.ReadFile(path); + path := pathutil.Join(*tmplroot, name) + data, err := ioutil.ReadFile(path) if err != nil { log.Exitf("ReadFile %s: %v", path, err) } - t, err := template.Parse(string(data), fmap); + t, err := template.Parse(string(data), fmap) if err != nil { log.Exitf("%s: %v", name, err) } - return t; + return t } @@ -652,18 +652,18 @@ var ( packageHTML, packageText, searchHTML, - sourceHTML *template.Template; + sourceHTML *template.Template ) func readTemplates() { // have to delay until after flags processing, // so that main has chdir'ed to goroot. - dirlistHTML = readTemplate("dirlist.html"); - godocHTML = readTemplate("godoc.html"); - packageHTML = readTemplate("package.html"); - packageText = readTemplate("package.txt"); - searchHTML = readTemplate("search.html"); - sourceHTML = readTemplate("source.html"); + dirlistHTML = readTemplate("dirlist.html") + godocHTML = readTemplate("godoc.html") + packageHTML = readTemplate("package.html") + packageText = readTemplate("package.txt") + searchHTML = readTemplate("search.html") + sourceHTML = readTemplate("source.html") } @@ -672,19 +672,19 @@ func readTemplates() { func servePage(c *http.Conn, title, query string, content []byte) { type Data struct { - Title string; - Timestamp uint64; // int64 to be compatible with os.Dir.Mtime_ns - Query string; - Content []byte; + Title string + Timestamp uint64 // int64 to be compatible with os.Dir.Mtime_ns + Query string + Content []byte } - _, ts := fsTree.get(); + _, ts := fsTree.get() d := Data{ Title: title, - Timestamp: uint64(ts) * 1e9, // timestamp in ns + Timestamp: uint64(ts) * 1e9, // timestamp in ns Query: query, Content: content, - }; + } if err := godocHTML.Execute(&d, c); err != nil { log.Stderrf("godocHTML.Execute: %s", err) @@ -693,8 +693,8 @@ func servePage(c *http.Conn, title, query string, content []byte) { func serveText(c *http.Conn, text []byte) { - c.SetHeader("content-type", "text/plain; charset=utf-8"); - c.Write(text); + c.SetHeader("content-type", "text/plain; charset=utf-8") + c.Write(text) } @@ -702,69 +702,69 @@ func serveText(c *http.Conn, text []byte) { // Files var ( - tagBegin = strings.Bytes("<!--"); - tagEnd = strings.Bytes("-->"); + tagBegin = strings.Bytes("<!--") + tagEnd = strings.Bytes("-->") ) // commentText returns the text of the first HTML comment in src. func commentText(src []byte) (text string) { - i := bytes.Index(src, tagBegin); - j := bytes.Index(src, tagEnd); + i := bytes.Index(src, tagBegin) + j := bytes.Index(src, tagEnd) if i >= 0 && j >= i+len(tagBegin) { text = string(bytes.TrimSpace(src[i+len(tagBegin) : j])) } - return; + return } func serveHTMLDoc(c *http.Conn, r *http.Request, path string) { // get HTML body contents - src, err := ioutil.ReadFile(path); + src, err := ioutil.ReadFile(path) if err != nil { - log.Stderrf("%v", err); - http.NotFound(c, r); - return; + log.Stderrf("%v", err) + http.NotFound(c, r) + return } // if it's the language spec, add tags to EBNF productions if strings.HasSuffix(path, "go_spec.html") { - var buf bytes.Buffer; - linkify(&buf, src); - src = buf.Bytes(); + var buf bytes.Buffer + linkify(&buf, src) + src = buf.Bytes() } - title := commentText(src); - servePage(c, title, "", src); + title := commentText(src) + servePage(c, title, "", src) } func serveGoSource(c *http.Conn, r *http.Request, path string) { var info struct { - Source StyledNode; - Error string; + Source StyledNode + Error string } - file, err := parser.ParseFile(path, nil, parser.ParseComments); - info.Source = StyledNode{file, &Styler{linetags: true, highlight: r.FormValue("h")}}; + file, err := parser.ParseFile(path, nil, parser.ParseComments) + info.Source = StyledNode{file, &Styler{linetags: true, highlight: r.FormValue("h")}} if err != nil { info.Error = err.String() } - var buf bytes.Buffer; + var buf bytes.Buffer if err := sourceHTML.Execute(info, &buf); err != nil { log.Stderrf("sourceHTML.Execute: %s", err) } - servePage(c, "Source file "+path, "", buf.Bytes()); + servePage(c, "Source file "+path, "", buf.Bytes()) } func redirect(c *http.Conn, r *http.Request) (redirected bool) { if canonical := pathutil.Clean(r.URL.Path) + "/"; r.URL.Path != canonical { - http.Redirect(c, canonical, http.StatusMovedPermanently); - redirected = true; + http.Redirect(c, canonical, http.StatusMovedPermanently) + redirected = true } - return; + return } @@ -772,8 +772,8 @@ func redirect(c *http.Conn, r *http.Request) (redirected bool) { // textExt[x] is true if the extension x indicates a text file, and false otherwise. var textExt = map[string]bool{ - ".css": false, // must be served raw - ".js": false, // must be served raw + ".css": false, // must be served raw + ".js": false, // must be served raw } @@ -786,20 +786,20 @@ func isTextFile(path string) bool { // the extension is not known; read an initial chunk of // file and check if it looks like correct UTF-8; if it // does, it's probably a text file - f, err := os.Open(path, os.O_RDONLY, 0); + f, err := os.Open(path, os.O_RDONLY, 0) if err != nil { return false } - defer f.Close(); + defer f.Close() - var buf [1024]byte; - n, err := f.Read(&buf); + var buf [1024]byte + n, err := f.Read(&buf) if err != nil { return false } - s := string(buf[0:n]); - n -= utf8.UTFMax; // make sure there's enough bytes for a complete unicode char + s := string(buf[0:n]) + n -= utf8.UTFMax // make sure there's enough bytes for a complete unicode char for i, c := range s { if i > n { break @@ -811,22 +811,22 @@ func isTextFile(path string) bool { } // likely a text file - return true; + return true } func serveTextFile(c *http.Conn, r *http.Request, path string) { - src, err := ioutil.ReadFile(path); + src, err := ioutil.ReadFile(path) if err != nil { log.Stderrf("serveTextFile: %s", err) } - var buf bytes.Buffer; - fmt.Fprintln(&buf, "<pre>"); - template.HTMLEscape(&buf, src); - fmt.Fprintln(&buf, "</pre>"); + var buf bytes.Buffer + fmt.Fprintln(&buf, "<pre>") + template.HTMLEscape(&buf, src) + fmt.Fprintln(&buf, "</pre>") - servePage(c, "Text file "+path, "", buf.Bytes()); + servePage(c, "Text file "+path, "", buf.Bytes()) } @@ -835,63 +835,63 @@ func serveDirectory(c *http.Conn, r *http.Request, path string) { return } - list, err := ioutil.ReadDir(path); + list, err := ioutil.ReadDir(path) if err != nil { - http.NotFound(c, r); - return; + http.NotFound(c, r) + return } - var buf bytes.Buffer; + var buf bytes.Buffer if err := dirlistHTML.Execute(list, &buf); err != nil { log.Stderrf("dirlistHTML.Execute: %s", err) } - servePage(c, "Directory "+path, "", buf.Bytes()); + servePage(c, "Directory "+path, "", buf.Bytes()) } var fileServer = http.FileServer(".", "") func serveFile(c *http.Conn, r *http.Request) { - path := pathutil.Join(".", r.URL.Path); + path := pathutil.Join(".", r.URL.Path) // pick off special cases and hand the rest to the standard file server switch ext := pathutil.Ext(path); { case r.URL.Path == "/": - serveHTMLDoc(c, r, "doc/root.html"); - return; + serveHTMLDoc(c, r, "doc/root.html") + return case r.URL.Path == "/doc/root.html": // hide landing page from its real name - http.NotFound(c, r); - return; + http.NotFound(c, r) + return case ext == ".html": - serveHTMLDoc(c, r, path); - return; + serveHTMLDoc(c, r, path) + return case ext == ".go": - serveGoSource(c, r, path); - return; + serveGoSource(c, r, path) + return } - dir, err := os.Lstat(path); + dir, err := os.Lstat(path) if err != nil { - http.NotFound(c, r); - return; + http.NotFound(c, r) + return } if dir != nil && dir.IsDirectory() { - serveDirectory(c, r, path); - return; + serveDirectory(c, r, path) + return } if isTextFile(path) { - serveTextFile(c, r, path); - return; + serveTextFile(c, r, path) + return } - fileServer.ServeHTTP(c, r); + fileServer.ServeHTTP(c, r) } @@ -903,16 +903,16 @@ const fakePkgName = "documentation" type PageInfo struct { - PDoc *doc.PackageDoc; // nil if no package found - Dirs *DirList; // nil if no directory information found - IsPkg bool; // false if this is not documenting a real package + PDoc *doc.PackageDoc // nil if no package found + Dirs *DirList // nil if no directory information found + IsPkg bool // false if this is not documenting a real package } type httpHandler struct { - pattern string; // url pattern; e.g. "/pkg/" - fsRoot string; // file system root to which the pattern is mapped - isPkg bool; // true if this handler serves real package documentation (as opposed to command documentation) + pattern string // url pattern; e.g. "/pkg/" + fsRoot string // file system root to which the pattern is mapped + isPkg bool // true if this handler serves real package documentation (as opposed to command documentation) } @@ -923,11 +923,11 @@ type httpHandler struct { // func (h *httpHandler) getPageInfo(path string) PageInfo { // the path is relative to h.fsroot - dirname := pathutil.Join(h.fsRoot, path); + dirname := pathutil.Join(h.fsRoot, path) // the package name is the directory name within its parent // (use dirname instead of path because dirname is clean; i.e. has no trailing '/') - _, pkgname := pathutil.Split(dirname); + _, pkgname := pathutil.Split(dirname) // filter function to select the desired .go files filter := func(d *os.Dir) bool { @@ -938,28 +938,28 @@ func (h *httpHandler) getPageInfo(path string) PageInfo { // found" errors. // Additionally, accept the special package name // fakePkgName if we are looking at cmd documentation. - name := pkgName(dirname + "/" + d.Name); - return name == pkgname || h.fsRoot == *cmdroot && name == fakePkgName; + name := pkgName(dirname + "/" + d.Name) + return name == pkgname || h.fsRoot == *cmdroot && name == fakePkgName } - return false; - }; + return false + } // get package AST - pkg, err := parser.ParsePackage(dirname, filter, parser.ParseComments); + pkg, err := parser.ParsePackage(dirname, filter, parser.ParseComments) if err != nil { // TODO: parse errors should be shown instead of an empty directory log.Stderrf("parser.parsePackage: %s", err) } // compute package documentation - var pdoc *doc.PackageDoc; + var pdoc *doc.PackageDoc if pkg != nil { - ast.PackageExports(pkg); - pdoc = doc.NewPackageDoc(pkg, pathutil.Clean(path)); // no trailing '/' in importpath + ast.PackageExports(pkg) + pdoc = doc.NewPackageDoc(pkg, pathutil.Clean(path)) // no trailing '/' in importpath } // get directory information - var dir *Directory; + var dir *Directory if tree, _ := fsTree.get(); tree != nil { // directory tree is present; lookup respective directory // (may still fail if the file system was updated and the @@ -971,7 +971,7 @@ func (h *httpHandler) getPageInfo(path string) PageInfo { dir = newDirectory(dirname, 1) } - return PageInfo{pdoc, dir.listing(true), h.isPkg}; + return PageInfo{pdoc, dir.listing(true), h.isPkg} } @@ -980,17 +980,17 @@ func (h *httpHandler) ServeHTTP(c *http.Conn, r *http.Request) { return } - path := r.URL.Path; - path = path[len(h.pattern):]; - info := h.getPageInfo(path); + path := r.URL.Path + path = path[len(h.pattern):] + info := h.getPageInfo(path) - var buf bytes.Buffer; + var buf bytes.Buffer if r.FormValue("f") == "text" { if err := packageText.Execute(info, &buf); err != nil { log.Stderrf("packageText.Execute: %s", err) } - serveText(c, buf.Bytes()); - return; + serveText(c, buf.Bytes()) + return } if err := packageHTML.Execute(info, &buf); err != nil { @@ -998,23 +998,23 @@ func (h *httpHandler) ServeHTTP(c *http.Conn, r *http.Request) { } if path == "" { - path = "." // don't display an empty path + path = "." // don't display an empty path } - title := "Directory " + path; + title := "Directory " + path if info.PDoc != nil { switch { case h.isPkg: title = "Package " + info.PDoc.PackageName case info.PDoc.PackageName == fakePkgName: // assume that the directory name is the command name - _, pkgname := pathutil.Split(pathutil.Clean(path)); - title = "Command " + pkgname; + _, pkgname := pathutil.Split(pathutil.Clean(path)) + title = "Command " + pkgname default: title = "Command " + info.PDoc.PackageName } } - servePage(c, title, "", buf.Bytes()); + servePage(c, title, "", buf.Bytes()) } @@ -1024,37 +1024,37 @@ func (h *httpHandler) ServeHTTP(c *http.Conn, r *http.Request) { var searchIndex RWValue type SearchResult struct { - Query string; - Hit *LookupResult; - Alt *AltWords; - Illegal bool; - Accurate bool; + Query string + Hit *LookupResult + Alt *AltWords + Illegal bool + Accurate bool } func search(c *http.Conn, r *http.Request) { - query := r.FormValue("q"); - var result SearchResult; + query := r.FormValue("q") + var result SearchResult if index, timestamp := searchIndex.get(); index != nil { - result.Query = query; - result.Hit, result.Alt, result.Illegal = index.(*Index).Lookup(query); - _, ts := fsTree.get(); - result.Accurate = timestamp >= ts; + result.Query = query + result.Hit, result.Alt, result.Illegal = index.(*Index).Lookup(query) + _, ts := fsTree.get() + result.Accurate = timestamp >= ts } - var buf bytes.Buffer; + var buf bytes.Buffer if err := searchHTML.Execute(result, &buf); err != nil { log.Stderrf("searchHTML.Execute: %s", err) } - var title string; + var title string if result.Hit != nil { title = fmt.Sprintf(`Results for query %q`, query) } else { title = fmt.Sprintf(`No results found for query %q`, query) } - servePage(c, title, query, buf.Bytes()); + servePage(c, title, query, buf.Bytes()) } @@ -1062,38 +1062,38 @@ func search(c *http.Conn, r *http.Request) { // Server var ( - cmdHandler = httpHandler{"/cmd/", *cmdroot, false}; - pkgHandler = httpHandler{"/pkg/", *pkgroot, true}; + cmdHandler = httpHandler{"/cmd/", *cmdroot, false} + pkgHandler = httpHandler{"/pkg/", *pkgroot, true} ) func registerPublicHandlers(mux *http.ServeMux) { - mux.Handle(cmdHandler.pattern, &cmdHandler); - mux.Handle(pkgHandler.pattern, &pkgHandler); - mux.Handle("/search", http.HandlerFunc(search)); - mux.Handle("/", http.HandlerFunc(serveFile)); + mux.Handle(cmdHandler.pattern, &cmdHandler) + mux.Handle(pkgHandler.pattern, &pkgHandler) + mux.Handle("/search", http.HandlerFunc(search)) + mux.Handle("/", http.HandlerFunc(serveFile)) } // Indexing goroutine. func indexer() { for { - _, ts := fsTree.get(); + _, ts := fsTree.get() if _, timestamp := searchIndex.get(); timestamp < ts { // index possibly out of date - make a new one // (could use a channel to send an explicit signal // from the sync goroutine, but this solution is // more decoupled, trivial, and works well enough) - start := time.Nanoseconds(); - index := NewIndex("."); - stop := time.Nanoseconds(); - searchIndex.set(index); + start := time.Nanoseconds() + index := NewIndex(".") + stop := time.Nanoseconds() + searchIndex.set(index) if *verbose { - secs := float64((stop-start)/1e6) / 1e3; - nwords, nspots := index.Size(); - log.Stderrf("index updated (%gs, %d unique words, %d spots)", secs, nwords, nspots); + secs := float64((stop-start)/1e6) / 1e3 + nwords, nspots := index.Size() + log.Stderrf("index updated (%gs, %d unique words, %d spots)", secs, nwords, nspots) } } - time.Sleep(1 * 60e9); // try once a minute + time.Sleep(1 * 60e9) // try once a minute } } diff --git a/src/cmd/godoc/index.go b/src/cmd/godoc/index.go index b0c331746..218633b2b 100644 --- a/src/cmd/godoc/index.go +++ b/src/cmd/godoc/index.go @@ -25,15 +25,15 @@ package main import ( - "container/vector"; - "go/ast"; - "go/parser"; - "go/token"; - "go/scanner"; - "os"; - pathutil "path"; - "sort"; - "strings"; + "container/vector" + "go/ast" + "go/parser" + "go/token" + "go/scanner" + "os" + pathutil "path" + "sort" + "strings" ) @@ -47,16 +47,16 @@ import ( // into a RunList containing pair runs (x, {y}) where each run consists of // a list of y's with the same x. type RunList struct { - vector.Vector; - less func(x, y interface{}) bool; + vector.Vector + less func(x, y interface{}) bool } -func (h *RunList) Less(i, j int) bool { return h.less(h.At(i), h.At(j)) } +func (h *RunList) Less(i, j int) bool { return h.less(h.At(i), h.At(j)) } func (h *RunList) sort(less func(x, y interface{}) bool) { - h.less = less; - sort.Sort(h); + h.less = less + sort.Sort(h) } @@ -64,15 +64,15 @@ func (h *RunList) sort(less func(x, y interface{}) bool) { // (specified by less) into "runs". func (h *RunList) reduce(less func(x, y interface{}) bool, newRun func(h *RunList, i, j int) interface{}) *RunList { // create runs of entries with equal values - h.sort(less); + h.sort(less) // for each run, make a new run object and collect them in a new RunList - var hh RunList; - i := 0; + var hh RunList + i := 0 for j := 0; j < h.Len(); j++ { if less(h.At(i), h.At(j)) { - hh.Push(newRun(h, i, j)); - i = j; // start a new run + hh.Push(newRun(h, i, j)) + i = j // start a new run } } // add final run, if any @@ -80,7 +80,7 @@ func (h *RunList) reduce(less func(x, y interface{}) bool, newRun func(h *RunLis hh.Push(newRun(h, i, h.Len())) } - return &hh; + return &hh } @@ -103,15 +103,15 @@ type SpotInfo uint32 type SpotKind uint32 const ( - PackageClause SpotKind = iota; - ImportDecl; - ConstDecl; - TypeDecl; - VarDecl; - FuncDecl; - MethodDecl; - Use; - nKinds; + PackageClause SpotKind = iota + ImportDecl + ConstDecl + TypeDecl + VarDecl + FuncDecl + MethodDecl + Use + nKinds ) @@ -127,7 +127,7 @@ func init() { // makeSpotInfo makes a SpotInfo. func makeSpotInfo(kind SpotKind, lori int, isIndex bool) SpotInfo { // encode lori: bits [4..32) - x := SpotInfo(lori) << 4; + x := SpotInfo(lori) << 4 if int(x>>4) != lori { // lori value doesn't fit - since snippet indices are // most certainly always smaller then 1<<28, this can @@ -135,18 +135,18 @@ func makeSpotInfo(kind SpotKind, lori int, isIndex bool) SpotInfo { x = 0 } // encode kind: bits [1..4) - x |= SpotInfo(kind) << 1; + x |= SpotInfo(kind) << 1 // encode isIndex: bit 0 if isIndex { x |= 1 } - return x; + return x } -func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) } -func (x SpotInfo) Lori() int { return int(x >> 4) } -func (x SpotInfo) IsIndex() bool { return x&1 != 0 } +func (x SpotInfo) Kind() SpotKind { return SpotKind(x >> 1 & 7) } +func (x SpotInfo) Lori() int { return int(x >> 4) } +func (x SpotInfo) IsIndex() bool { return x&1 != 0 } // ---------------------------------------------------------------------------- @@ -157,55 +157,55 @@ const removeDuplicates = true // A KindRun is a run of SpotInfos of the same kind in a given file. type KindRun struct { - Kind SpotKind; - Infos []SpotInfo; + Kind SpotKind + Infos []SpotInfo } // KindRuns are sorted by line number or index. Since the isIndex bit // is always the same for all infos in one list we can compare lori's. -func (f *KindRun) Len() int { return len(f.Infos) } -func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() } -func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] } +func (f *KindRun) Len() int { return len(f.Infos) } +func (f *KindRun) Less(i, j int) bool { return f.Infos[i].Lori() < f.Infos[j].Lori() } +func (f *KindRun) Swap(i, j int) { f.Infos[i], f.Infos[j] = f.Infos[j], f.Infos[i] } // FileRun contents are sorted by Kind for the reduction into KindRuns. -func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() } +func lessKind(x, y interface{}) bool { return x.(SpotInfo).Kind() < y.(SpotInfo).Kind() } // newKindRun allocates a new KindRun from the SpotInfo run [i, j) in h. func newKindRun(h *RunList, i, j int) interface{} { - kind := h.At(i).(SpotInfo).Kind(); - infos := make([]SpotInfo, j-i); - k := 0; + kind := h.At(i).(SpotInfo).Kind() + infos := make([]SpotInfo, j-i) + k := 0 for ; i < j; i++ { - infos[k] = h.At(i).(SpotInfo); - k++; + infos[k] = h.At(i).(SpotInfo) + k++ } - run := &KindRun{kind, infos}; + run := &KindRun{kind, infos} // Spots were sorted by file and kind to create this run. // Within this run, sort them by line number or index. - sort.Sort(run); + sort.Sort(run) if removeDuplicates { // Since both the lori and kind field must be // same for duplicates, and since the isIndex // bit is always the same for all infos in one // list we can simply compare the entire info. - k := 0; - var prev SpotInfo; + k := 0 + var prev SpotInfo for i, x := range infos { if x != prev || i == 0 { - infos[k] = x; - k++; - prev = x; + infos[k] = x + k++ + prev = x } } - run.Infos = infos[0:k]; + run.Infos = infos[0:k] } - return run; + return run } @@ -214,8 +214,8 @@ func newKindRun(h *RunList, i, j int) interface{} { // A Pak describes a Go package. type Pak struct { - Path string; // path of directory containing the package - Name string; // package name as declared by package clause + Path string // path of directory containing the package + Name string // package name as declared by package clause } // Paks are sorted by name (primary key) and by import path (secondary key). @@ -226,49 +226,49 @@ func (p *Pak) less(q *Pak) bool { // A File describes a Go file. type File struct { - Path string; // complete file name - Pak Pak; // the package to which the file belongs + Path string // complete file name + Pak Pak // the package to which the file belongs } // A Spot describes a single occurence of a word. type Spot struct { - File *File; - Info SpotInfo; + File *File + Info SpotInfo } // A FileRun is a list of KindRuns belonging to the same file. type FileRun struct { - File *File; - Groups []*KindRun; + File *File + Groups []*KindRun } // Spots are sorted by path for the reduction into FileRuns. -func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path } +func lessSpot(x, y interface{}) bool { return x.(Spot).File.Path < y.(Spot).File.Path } // newFileRun allocates a new FileRun from the Spot run [i, j) in h. func newFileRun(h0 *RunList, i, j int) interface{} { - file := h0.At(i).(Spot).File; + file := h0.At(i).(Spot).File // reduce the list of Spots into a list of KindRuns - var h1 RunList; - h1.Vector.Resize(j-i, 0); - k := 0; + var h1 RunList + h1.Vector.Resize(j-i, 0) + k := 0 for ; i < j; i++ { - h1.Set(k, h0.At(i).(Spot).Info); - k++; + h1.Set(k, h0.At(i).(Spot).Info) + k++ } - h2 := h1.reduce(lessKind, newKindRun); + h2 := h1.reduce(lessKind, newKindRun) // create the FileRun - groups := make([]*KindRun, h2.Len()); + groups := make([]*KindRun, h2.Len()) for i := 0; i < h2.Len(); i++ { groups[i] = h2.At(i).(*KindRun) } - return &FileRun{file, groups}; + return &FileRun{file, groups} } @@ -277,14 +277,14 @@ func newFileRun(h0 *RunList, i, j int) interface{} { // A PakRun describes a run of *FileRuns of a package. type PakRun struct { - Pak Pak; - Files []*FileRun; + Pak Pak + Files []*FileRun } // Sorting support for files within a PakRun. -func (p *PakRun) Len() int { return len(p.Files) } -func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path } -func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] } +func (p *PakRun) Len() int { return len(p.Files) } +func (p *PakRun) Less(i, j int) bool { return p.Files[i].File.Path < p.Files[j].File.Path } +func (p *PakRun) Swap(i, j int) { p.Files[i], p.Files[j] = p.Files[j], p.Files[i] } // FileRuns are sorted by package for the reduction into PakRuns. @@ -295,16 +295,16 @@ func lessFileRun(x, y interface{}) bool { // newPakRun allocates a new PakRun from the *FileRun run [i, j) in h. func newPakRun(h *RunList, i, j int) interface{} { - pak := h.At(i).(*FileRun).File.Pak; - files := make([]*FileRun, j-i); - k := 0; + pak := h.At(i).(*FileRun).File.Pak + files := make([]*FileRun, j-i) + k := 0 for ; i < j; i++ { - files[k] = h.At(i).(*FileRun); - k++; + files[k] = h.At(i).(*FileRun) + k++ } - run := &PakRun{pak, files}; - sort.Sort(run); // files were sorted by package; sort them by file now - return run; + run := &PakRun{pak, files} + sort.Sort(run) // files were sorted by package; sort them by file now + return run } @@ -316,43 +316,43 @@ type HitList []*PakRun // PakRuns are sorted by package. -func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(&y.(*PakRun).Pak) } +func lessPakRun(x, y interface{}) bool { return x.(*PakRun).Pak.less(&y.(*PakRun).Pak) } func reduce(h0 *RunList) HitList { // reduce a list of Spots into a list of FileRuns - h1 := h0.reduce(lessSpot, newFileRun); + h1 := h0.reduce(lessSpot, newFileRun) // reduce a list of FileRuns into a list of PakRuns - h2 := h1.reduce(lessFileRun, newPakRun); + h2 := h1.reduce(lessFileRun, newPakRun) // sort the list of PakRuns by package - h2.sort(lessPakRun); + h2.sort(lessPakRun) // create a HitList - h := make(HitList, h2.Len()); + h := make(HitList, h2.Len()) for i := 0; i < h2.Len(); i++ { h[i] = h2.At(i).(*PakRun) } - return h; + return h } func (h HitList) filter(pakname string) HitList { // determine number of matching packages (most of the time just one) - n := 0; + n := 0 for _, p := range h { if p.Pak.Name == pakname { n++ } } // create filtered HitList - hh := make(HitList, n); - i := 0; + hh := make(HitList, n) + i := 0 for _, p := range h { if p.Pak.Name == pakname { - hh[i] = p; - i++; + hh[i] = p + i++ } } - return hh; + return hh } @@ -360,33 +360,33 @@ func (h HitList) filter(pakname string) HitList { // AltWords type wordPair struct { - canon string; // canonical word spelling (all lowercase) - alt string; // alternative spelling + canon string // canonical word spelling (all lowercase) + alt string // alternative spelling } // An AltWords describes a list of alternative spellings for a // canonical (all lowercase) spelling of a word. type AltWords struct { - Canon string; // canonical word spelling (all lowercase) - Alts []string; // alternative spelling for the same word + Canon string // canonical word spelling (all lowercase) + Alts []string // alternative spelling for the same word } // wordPairs are sorted by their canonical spelling. -func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon } +func lessWordPair(x, y interface{}) bool { return x.(*wordPair).canon < y.(*wordPair).canon } // newAltWords allocates a new AltWords from the *wordPair run [i, j) in h. func newAltWords(h *RunList, i, j int) interface{} { - canon := h.At(i).(*wordPair).canon; - alts := make([]string, j-i); - k := 0; + canon := h.At(i).(*wordPair).canon + alts := make([]string, j-i) + k := 0 for ; i < j; i++ { - alts[k] = h.At(i).(*wordPair).alt; - k++; + alts[k] = h.At(i).(*wordPair).alt + k++ } - return &AltWords{canon, alts}; + return &AltWords{canon, alts} } @@ -397,15 +397,15 @@ func (a *AltWords) filter(s string) *AltWords { } // make a new AltWords with the current spelling removed - alts := make([]string, len(a.Alts)); - i := 0; + alts := make([]string, len(a.Alts)) + i := 0 for _, w := range a.Alts { if w != s { - alts[i] = w; - i++; + alts[i] = w + i++ } } - return &AltWords{a.Canon, alts[0:i]}; + return &AltWords{a.Canon, alts[0:i]} } @@ -418,8 +418,8 @@ const excludeTestFiles = false type IndexResult struct { - Decls RunList; // package-level declarations (with snippets) - Others RunList; // all other occurences + Decls RunList // package-level declarations (with snippets) + Others RunList // all other occurences } @@ -428,18 +428,18 @@ type IndexResult struct { // interface for walking file trees, and the ast.Visitor interface for // walking Go ASTs. type Indexer struct { - words map[string]*IndexResult; // RunLists of Spots - snippets vector.Vector; // vector of *Snippets, indexed by snippet indices - file *File; // current file - decl ast.Decl; // current decl - nspots int; // number of spots encountered + words map[string]*IndexResult // RunLists of Spots + snippets vector.Vector // vector of *Snippets, indexed by snippet indices + file *File // current file + decl ast.Decl // current decl + nspots int // number of spots encountered } func (x *Indexer) addSnippet(s *Snippet) int { - index := x.snippets.Len(); - x.snippets.Push(s); - return index; + index := x.snippets.Len() + x.snippets.Push(s) + return index } @@ -452,24 +452,24 @@ func (x *Indexer) visitComment(c *ast.CommentGroup) { func (x *Indexer) visitIdent(kind SpotKind, id *ast.Ident) { if id != nil { - lists, found := x.words[id.Value]; + lists, found := x.words[id.Value] if !found { - lists = new(IndexResult); - x.words[id.Value] = lists; + lists = new(IndexResult) + x.words[id.Value] = lists } if kind == Use || x.decl == nil { // not a declaration or no snippet required - info := makeSpotInfo(kind, id.Pos().Line, false); - lists.Others.Push(Spot{x.file, info}); + info := makeSpotInfo(kind, id.Pos().Line, false) + lists.Others.Push(Spot{x.file, info}) } else { // a declaration with snippet - index := x.addSnippet(NewSnippet(x.decl, id)); - info := makeSpotInfo(kind, index, true); - lists.Decls.Push(Spot{x.file, info}); + index := x.addSnippet(NewSnippet(x.decl, id)) + info := makeSpotInfo(kind, index, true) + lists.Decls.Push(Spot{x.file, info}) } - x.nspots++; + x.nspots++ } } @@ -477,33 +477,33 @@ func (x *Indexer) visitIdent(kind SpotKind, id *ast.Ident) { func (x *Indexer) visitSpec(spec ast.Spec, isVarDecl bool) { switch n := spec.(type) { case *ast.ImportSpec: - x.visitComment(n.Doc); - x.visitIdent(ImportDecl, n.Name); + x.visitComment(n.Doc) + x.visitIdent(ImportDecl, n.Name) for _, s := range n.Path { ast.Walk(x, s) } - x.visitComment(n.Comment); + x.visitComment(n.Comment) case *ast.ValueSpec: - x.visitComment(n.Doc); - kind := ConstDecl; + x.visitComment(n.Doc) + kind := ConstDecl if isVarDecl { kind = VarDecl } for _, n := range n.Names { x.visitIdent(kind, n) } - ast.Walk(x, n.Type); + ast.Walk(x, n.Type) for _, v := range n.Values { ast.Walk(x, v) } - x.visitComment(n.Comment); + x.visitComment(n.Comment) case *ast.TypeSpec: - x.visitComment(n.Doc); - x.visitIdent(TypeDecl, n.Name); - ast.Walk(x, n.Type); - x.visitComment(n.Comment); + x.visitComment(n.Doc) + x.visitIdent(TypeDecl, n.Name) + ast.Walk(x, n.Type) + x.visitComment(n.Comment) } } @@ -518,22 +518,22 @@ func (x *Indexer) Visit(node interface{}) ast.Visitor { x.visitIdent(Use, n) case *ast.Field: - x.decl = nil; // no snippets for fields - x.visitComment(n.Doc); + x.decl = nil // no snippets for fields + x.visitComment(n.Doc) for _, m := range n.Names { x.visitIdent(VarDecl, m) } - ast.Walk(x, n.Type); + ast.Walk(x, n.Type) for _, s := range n.Tag { ast.Walk(x, s) } - x.visitComment(n.Comment); + x.visitComment(n.Comment) case *ast.DeclStmt: if decl, ok := n.Decl.(*ast.GenDecl); ok { // local declarations can only be *ast.GenDecls - x.decl = nil; // no snippets for local declarations - x.visitComment(decl.Doc); + x.decl = nil // no snippets for local declarations + x.visitComment(decl.Doc) for _, s := range decl.Specs { x.visitSpec(s, decl.Tok == token.VAR) } @@ -543,30 +543,30 @@ func (x *Indexer) Visit(node interface{}) ast.Visitor { } case *ast.GenDecl: - x.decl = n; - x.visitComment(n.Doc); + x.decl = n + x.visitComment(n.Doc) for _, s := range n.Specs { x.visitSpec(s, n.Tok == token.VAR) } case *ast.FuncDecl: - x.visitComment(n.Doc); - kind := FuncDecl; + x.visitComment(n.Doc) + kind := FuncDecl if n.Recv != nil { - kind = MethodDecl; - ast.Walk(x, n.Recv); + kind = MethodDecl + ast.Walk(x, n.Recv) } - x.decl = n; - x.visitIdent(kind, n.Name); - ast.Walk(x, n.Type); + x.decl = n + x.visitIdent(kind, n.Name) + ast.Walk(x, n.Type) if n.Body != nil { ast.Walk(x, n.Body) } case *ast.File: - x.visitComment(n.Doc); - x.decl = nil; - x.visitIdent(PackageClause, n.Name); + x.visitComment(n.Doc) + x.decl = nil + x.visitIdent(PackageClause, n.Name) for _, d := range n.Decls { ast.Walk(x, d) } @@ -578,7 +578,7 @@ func (x *Indexer) Visit(node interface{}) ast.Visitor { return x } - return nil; + return nil } @@ -600,15 +600,15 @@ func (x *Indexer) VisitFile(path string, d *os.Dir) { return } - file, err := parser.ParseFile(path, nil, parser.ParseComments); + file, err := parser.ParseFile(path, nil, parser.ParseComments) if err != nil { - return // ignore files with (parse) errors + return // ignore files with (parse) errors } - dir, _ := pathutil.Split(path); - pak := Pak{dir, file.Name.Value}; - x.file = &File{path, pak}; - ast.Walk(x, file); + dir, _ := pathutil.Split(path) + pak := Pak{dir, file.Name.Value} + x.file = &File{path, pak} + ast.Walk(x, file) } @@ -616,65 +616,65 @@ func (x *Indexer) VisitFile(path string, d *os.Dir) { // Index type LookupResult struct { - Decls HitList; // package-level declarations (with snippets) - Others HitList; // all other occurences + Decls HitList // package-level declarations (with snippets) + Others HitList // all other occurences } type Index struct { - words map[string]*LookupResult; // maps words to hit lists - alts map[string]*AltWords; // maps canonical(words) to lists of alternative spellings - snippets []*Snippet; // all snippets, indexed by snippet index - nspots int; // number of spots indexed (a measure of the index size) + words map[string]*LookupResult // maps words to hit lists + alts map[string]*AltWords // maps canonical(words) to lists of alternative spellings + snippets []*Snippet // all snippets, indexed by snippet index + nspots int // number of spots indexed (a measure of the index size) } -func canonical(w string) string { return strings.ToLower(w) } +func canonical(w string) string { return strings.ToLower(w) } // NewIndex creates a new index for the file tree rooted at root. func NewIndex(root string) *Index { - var x Indexer; + var x Indexer // initialize Indexer - x.words = make(map[string]*IndexResult); + x.words = make(map[string]*IndexResult) // collect all Spots - pathutil.Walk(root, &x, nil); + pathutil.Walk(root, &x, nil) // for each word, reduce the RunLists into a LookupResult; // also collect the word with its canonical spelling in a // word list for later computation of alternative spellings - words := make(map[string]*LookupResult); - var wlist RunList; + words := make(map[string]*LookupResult) + var wlist RunList for w, h := range x.words { - decls := reduce(&h.Decls); - others := reduce(&h.Others); + decls := reduce(&h.Decls) + others := reduce(&h.Others) words[w] = &LookupResult{ Decls: decls, Others: others, - }; - wlist.Push(&wordPair{canonical(w), w}); + } + wlist.Push(&wordPair{canonical(w), w}) } // reduce the word list {canonical(w), w} into // a list of AltWords runs {canonical(w), {w}} - alist := wlist.reduce(lessWordPair, newAltWords); + alist := wlist.reduce(lessWordPair, newAltWords) // convert alist into a map of alternative spellings - alts := make(map[string]*AltWords); + alts := make(map[string]*AltWords) for i := 0; i < alist.Len(); i++ { - a := alist.At(i).(*AltWords); - alts[a.Canon] = a; + a := alist.At(i).(*AltWords) + alts[a.Canon] = a } // convert snippet vector into a list - snippets := make([]*Snippet, x.snippets.Len()); + snippets := make([]*Snippet, x.snippets.Len()) for i := 0; i < x.snippets.Len(); i++ { snippets[i] = x.snippets.At(i).(*Snippet) } - return &Index{words, alts, snippets, x.nspots}; + return &Index{words, alts, snippets, x.nspots} } @@ -686,26 +686,26 @@ func (x *Index) Size() (nwords int, nspots int) { func (x *Index) LookupWord(w string) (match *LookupResult, alt *AltWords) { - match, _ = x.words[w]; - alt, _ = x.alts[canonical(w)]; + match, _ = x.words[w] + alt, _ = x.alts[canonical(w)] // remove current spelling from alternatives // (if there is no match, the alternatives do // not contain the current spelling) if match != nil && alt != nil { alt = alt.filter(w) } - return; + return } func isIdentifier(s string) bool { - var S scanner.Scanner; - S.Init("", strings.Bytes(s), nil, 0); + var S scanner.Scanner + S.Init("", strings.Bytes(s), nil, 0) if _, tok, _ := S.Scan(); tok == token.IDENT { - _, tok, _ := S.Scan(); - return tok == token.EOF; + _, tok, _ := S.Scan() + return tok == token.EOF } - return false; + return false } @@ -713,13 +713,13 @@ func isIdentifier(s string) bool { // identifier, Lookup returns a LookupResult, and a list of alternative // spellings, if any. If the query syntax is wrong, illegal is set. func (x *Index) Lookup(query string) (match *LookupResult, alt *AltWords, illegal bool) { - ss := strings.Split(query, ".", 0); + ss := strings.Split(query, ".", 0) // check query syntax for _, s := range ss { if !isIdentifier(s) { - illegal = true; - return; + illegal = true + return } } @@ -728,20 +728,20 @@ func (x *Index) Lookup(query string) (match *LookupResult, alt *AltWords, illega match, alt = x.LookupWord(ss[0]) case 2: - pakname := ss[0]; - match, alt = x.LookupWord(ss[1]); + pakname := ss[0] + match, alt = x.LookupWord(ss[1]) if match != nil { // found a match - filter by package name - decls := match.Decls.filter(pakname); - others := match.Others.filter(pakname); - match = &LookupResult{decls, others}; + decls := match.Decls.filter(pakname) + others := match.Others.filter(pakname) + match = &LookupResult{decls, others} } default: illegal = true } - return; + return } @@ -750,5 +750,5 @@ func (x *Index) Snippet(i int) *Snippet { if 0 <= i && i < len(x.snippets) { return x.snippets[i] } - return nil; + return nil } diff --git a/src/cmd/godoc/main.go b/src/cmd/godoc/main.go index b8967e4bf..701cd006e 100644 --- a/src/cmd/godoc/main.go +++ b/src/cmd/godoc/main.go @@ -26,74 +26,74 @@ package main import ( - "bytes"; - "flag"; - "fmt"; - "http"; - "io"; - "log"; - "os"; - "time"; + "bytes" + "flag" + "fmt" + "http" + "io" + "log" + "os" + "time" ) var ( // periodic sync - syncCmd = flag.String("sync", "", "sync command; disabled if empty"); - syncMin = flag.Int("sync_minutes", 0, "sync interval in minutes; disabled if <= 0"); - syncDelay delayTime; // actual sync delay in minutes; usually syncDelay == syncMin, but delay may back off exponentially + syncCmd = flag.String("sync", "", "sync command; disabled if empty") + syncMin = flag.Int("sync_minutes", 0, "sync interval in minutes; disabled if <= 0") + syncDelay delayTime // actual sync delay in minutes; usually syncDelay == syncMin, but delay may back off exponentially // server control - httpaddr = flag.String("http", "", "HTTP service address (e.g., ':6060')"); + httpaddr = flag.String("http", "", "HTTP service address (e.g., ':6060')") // layout control - html = flag.Bool("html", false, "print HTML in command-line mode"); + html = flag.Bool("html", false, "print HTML in command-line mode") ) func exec(c *http.Conn, args []string) (status int) { - r, w, err := os.Pipe(); + r, w, err := os.Pipe() if err != nil { - log.Stderrf("os.Pipe(): %v\n", err); - return 2; + log.Stderrf("os.Pipe(): %v\n", err) + return 2 } - bin := args[0]; - fds := []*os.File{nil, w, w}; + bin := args[0] + fds := []*os.File{nil, w, w} if *verbose { log.Stderrf("executing %v", args) } - pid, err := os.ForkExec(bin, args, os.Environ(), goroot, fds); - defer r.Close(); - w.Close(); + pid, err := os.ForkExec(bin, args, os.Environ(), goroot, fds) + defer r.Close() + w.Close() if err != nil { - log.Stderrf("os.ForkExec(%q): %v\n", bin, err); - return 2; + log.Stderrf("os.ForkExec(%q): %v\n", bin, err) + return 2 } - var buf bytes.Buffer; - io.Copy(&buf, r); - wait, err := os.Wait(pid, 0); + var buf bytes.Buffer + io.Copy(&buf, r) + wait, err := os.Wait(pid, 0) if err != nil { - os.Stderr.Write(buf.Bytes()); - log.Stderrf("os.Wait(%d, 0): %v\n", pid, err); - return 2; + os.Stderr.Write(buf.Bytes()) + log.Stderrf("os.Wait(%d, 0): %v\n", pid, err) + return 2 } - status = wait.ExitStatus(); + status = wait.ExitStatus() if !wait.Exited() || status > 1 { - os.Stderr.Write(buf.Bytes()); - log.Stderrf("executing %v failed (exit status = %d)", args, status); - return; + os.Stderr.Write(buf.Bytes()) + log.Stderrf("executing %v failed (exit status = %d)", args, status) + return } if *verbose { os.Stderr.Write(buf.Bytes()) } if c != nil { - c.SetHeader("content-type", "text/plain; charset=utf-8"); - c.Write(buf.Bytes()); + c.SetHeader("content-type", "text/plain; charset=utf-8") + c.Write(buf.Bytes()) } - return; + return } @@ -101,7 +101,7 @@ func exec(c *http.Conn, args []string) (status int) { const maxDirDepth = 24 func dosync(c *http.Conn, r *http.Request) { - args := []string{"/bin/sh", "-c", *syncCmd}; + args := []string{"/bin/sh", "-c", *syncCmd} switch exec(c, args) { case 0: // sync succeeded and some files have changed; @@ -109,12 +109,12 @@ func dosync(c *http.Conn, r *http.Request) { // TODO(gri): The directory tree may be temporarily out-of-sync. // Consider keeping separate time stamps so the web- // page can indicate this discrepancy. - fsTree.set(newDirectory(".", maxDirDepth)); - fallthrough; + fsTree.set(newDirectory(".", maxDirDepth)) + fallthrough case 1: // sync failed because no files changed; // don't change the package tree - syncDelay.set(*syncMin) // revert to regular sync schedule + syncDelay.set(*syncMin) // revert to regular sync schedule default: // sync failed because of an error - back off exponentially, but try at least once a day syncDelay.backoff(24 * 60) @@ -125,23 +125,23 @@ func dosync(c *http.Conn, r *http.Request) { func usage() { fmt.Fprintf(os.Stderr, "usage: godoc package [name ...]\n"+ - " godoc -http=:6060\n"); - flag.PrintDefaults(); - os.Exit(2); + " godoc -http=:6060\n") + flag.PrintDefaults() + os.Exit(2) } func loggingHandler(h http.Handler) http.Handler { return http.HandlerFunc(func(c *http.Conn, req *http.Request) { - log.Stderrf("%s\t%s", c.RemoteAddr, req.URL); - h.ServeHTTP(c, req); + log.Stderrf("%s\t%s", c.RemoteAddr, req.URL) + h.ServeHTTP(c, req) }) } func main() { - flag.Usage = usage; - flag.Parse(); + flag.Usage = usage + flag.Parse() // Check usage: either server and no args, or command line and args if (*httpaddr != "") != (flag.NArg() == 0) { @@ -156,23 +156,23 @@ func main() { log.Exitf("chdir %s: %v", goroot, err) } - readTemplates(); + readTemplates() if *httpaddr != "" { // HTTP server mode. - var handler http.Handler = http.DefaultServeMux; + var handler http.Handler = http.DefaultServeMux if *verbose { - log.Stderrf("Go Documentation Server\n"); - log.Stderrf("address = %s\n", *httpaddr); - log.Stderrf("goroot = %s\n", goroot); - log.Stderrf("cmdroot = %s\n", *cmdroot); - log.Stderrf("pkgroot = %s\n", *pkgroot); - log.Stderrf("tmplroot = %s\n", *tmplroot); - log.Stderrf("tabwidth = %d\n", *tabwidth); - handler = loggingHandler(handler); + log.Stderrf("Go Documentation Server\n") + log.Stderrf("address = %s\n", *httpaddr) + log.Stderrf("goroot = %s\n", goroot) + log.Stderrf("cmdroot = %s\n", *cmdroot) + log.Stderrf("pkgroot = %s\n", *pkgroot) + log.Stderrf("tmplroot = %s\n", *tmplroot) + log.Stderrf("tabwidth = %d\n", *tabwidth) + handler = loggingHandler(handler) } - registerPublicHandlers(http.DefaultServeMux); + registerPublicHandlers(http.DefaultServeMux) if *syncCmd != "" { http.Handle("/debug/sync", http.HandlerFunc(dosync)) } @@ -180,39 +180,39 @@ func main() { // Initialize directory tree with corresponding timestamp. // Do it in two steps: // 1) set timestamp right away so that the indexer is kicked on - fsTree.set(nil); + fsTree.set(nil) // 2) compute initial directory tree in a goroutine so that launch is quick - go func() { fsTree.set(newDirectory(".", maxDirDepth)) }(); + go func() { fsTree.set(newDirectory(".", maxDirDepth)) }() // Start sync goroutine, if enabled. if *syncCmd != "" && *syncMin > 0 { - syncDelay.set(*syncMin); // initial sync delay + syncDelay.set(*syncMin) // initial sync delay go func() { for { - dosync(nil, nil); - delay, _ := syncDelay.get(); + dosync(nil, nil) + delay, _ := syncDelay.get() if *verbose { log.Stderrf("next sync in %dmin", delay.(int)) } - time.Sleep(int64(delay.(int)) * 60e9); + time.Sleep(int64(delay.(int)) * 60e9) } - }(); + }() } // Start indexing goroutine. - go indexer(); + go indexer() // The server may have been restarted; always wait 1sec to // give the forking server a chance to shut down and release // the http port. // TODO(gri): Do we still need this? - time.Sleep(1e9); + time.Sleep(1e9) // Start http server. if err := http.ListenAndServe(*httpaddr, handler); err != nil { log.Exitf("ListenAndServe %s: %v", *httpaddr, err) } - return; + return } // Command line mode. @@ -220,7 +220,7 @@ func main() { packageText = packageHTML } - info := pkgHandler.getPageInfo(flag.Arg(0)); + info := pkgHandler.getPageInfo(flag.Arg(0)) if info.PDoc == nil && info.Dirs == nil { // try again, this time assume it's a command @@ -228,8 +228,8 @@ func main() { } if info.PDoc != nil && flag.NArg() > 1 { - args := flag.Args(); - info.PDoc.Filter(args[1:]); + args := flag.Args() + info.PDoc.Filter(args[1:]) } if err := packageText.Execute(info, os.Stdout); err != nil { diff --git a/src/cmd/godoc/snippet.go b/src/cmd/godoc/snippet.go index be027ffc8..98bc97285 100755 --- a/src/cmd/godoc/snippet.go +++ b/src/cmd/godoc/snippet.go @@ -10,44 +10,44 @@ package main import ( - "bytes"; - "go/ast"; - "go/printer"; - "fmt"; - "strings"; + "bytes" + "go/ast" + "go/printer" + "fmt" + "strings" ) type Snippet struct { - Line int; - Text string; + Line int + Text string } type snippetStyler struct { - Styler; // defined in godoc.go - highlight *ast.Ident; // identifier to highlight + Styler // defined in godoc.go + highlight *ast.Ident // identifier to highlight } func (s *snippetStyler) LineTag(line int) (text []uint8, tag printer.HTMLTag) { - return // no LineTag for snippets + return // no LineTag for snippets } func (s *snippetStyler) Ident(id *ast.Ident) (text []byte, tag printer.HTMLTag) { - text = strings.Bytes(id.Value); + text = strings.Bytes(id.Value) if s.highlight == id { tag = printer.HTMLTag{"<span class=highlight>", "</span>"} } - return; + return } func newSnippet(decl ast.Decl, id *ast.Ident) *Snippet { - var buf bytes.Buffer; - writeNode(&buf, decl, true, &snippetStyler{highlight: id}); - return &Snippet{id.Pos().Line, buf.String()}; + var buf bytes.Buffer + writeNode(&buf, decl, true, &snippetStyler{highlight: id}) + return &Snippet{id.Pos().Line, buf.String()} } @@ -70,32 +70,32 @@ func findSpec(list []ast.Spec, id *ast.Ident) ast.Spec { } } } - return nil; + return nil } func genSnippet(d *ast.GenDecl, id *ast.Ident) *Snippet { - s := findSpec(d.Specs, id); + s := findSpec(d.Specs, id) if s == nil { - return nil // declaration doesn't contain id - exit gracefully + return nil // declaration doesn't contain id - exit gracefully } // only use the spec containing the id for the snippet - dd := &ast.GenDecl{d.Doc, d.Position, d.Tok, d.Lparen, []ast.Spec{s}, d.Rparen}; + dd := &ast.GenDecl{d.Doc, d.Position, d.Tok, d.Lparen, []ast.Spec{s}, d.Rparen} - return newSnippet(dd, id); + return newSnippet(dd, id) } func funcSnippet(d *ast.FuncDecl, id *ast.Ident) *Snippet { if d.Name != id { - return nil // declaration doesn't contain id - exit gracefully + return nil // declaration doesn't contain id - exit gracefully } // only use the function signature for the snippet - dd := &ast.FuncDecl{d.Doc, d.Recv, d.Name, d.Type, nil}; + dd := &ast.FuncDecl{d.Doc, d.Recv, d.Name, d.Type, nil} - return newSnippet(dd, id); + return newSnippet(dd, id) } @@ -118,5 +118,5 @@ func NewSnippet(decl ast.Decl, id *ast.Ident) (s *Snippet) { fmt.Sprintf(`could not generate a snippet for <span class="highlight">%s</span>`, id.Value), } } - return; + return } diff --git a/src/cmd/godoc/spec.go b/src/cmd/godoc/spec.go index 15ce2fb9e..15f3cba20 100644 --- a/src/cmd/godoc/spec.go +++ b/src/cmd/godoc/spec.go @@ -11,35 +11,35 @@ package main import ( - "bytes"; - "fmt"; - "go/scanner"; - "go/token"; - "io"; - "strings"; + "bytes" + "fmt" + "go/scanner" + "go/token" + "io" + "strings" ) type ebnfParser struct { - out io.Writer; // parser output - src []byte; // parser source - scanner scanner.Scanner; - prev int; // offset of previous token - pos token.Position; // token position - tok token.Token; // one token look-ahead - lit []byte; // token literal + out io.Writer // parser output + src []byte // parser source + scanner scanner.Scanner + prev int // offset of previous token + pos token.Position // token position + tok token.Token // one token look-ahead + lit []byte // token literal } func (p *ebnfParser) flush() { - p.out.Write(p.src[p.prev:p.pos.Offset]); - p.prev = p.pos.Offset; + p.out.Write(p.src[p.prev:p.pos.Offset]) + p.prev = p.pos.Offset } func (p *ebnfParser) next() { - p.flush(); - p.pos, p.tok, p.lit = p.scanner.Scan(); + p.flush() + p.pos, p.tok, p.lit = p.scanner.Scan() if p.tok.IsKeyword() { // TODO Should keyword mapping always happen outside scanner? // Or should there be a flag to scanner to enable keyword mapping? @@ -54,38 +54,38 @@ func (p *ebnfParser) Error(pos token.Position, msg string) { func (p *ebnfParser) errorExpected(pos token.Position, msg string) { - msg = "expected " + msg; + msg = "expected " + msg if pos.Offset == p.pos.Offset { // the error happened at the current position; // make the error message more specific - msg += ", found '" + p.tok.String() + "'"; + msg += ", found '" + p.tok.String() + "'" if p.tok.IsLiteral() { msg += " " + string(p.lit) } } - p.Error(pos, msg); + p.Error(pos, msg) } func (p *ebnfParser) expect(tok token.Token) token.Position { - pos := p.pos; + pos := p.pos if p.tok != tok { p.errorExpected(pos, "'"+tok.String()+"'") } - p.next(); // make progress in any case - return pos; + p.next() // make progress in any case + return pos } func (p *ebnfParser) parseIdentifier(def bool) { - name := string(p.lit); - p.expect(token.IDENT); + name := string(p.lit) + p.expect(token.IDENT) if def { fmt.Fprintf(p.out, `<a id="%s">%s</a>`, name, name) } else { fmt.Fprintf(p.out, `<a href="#%s" class="noline">%s</a>`, name, name) } - p.prev += len(name); // skip identifier when calling flush + p.prev += len(name) // skip identifier when calling flush } @@ -95,32 +95,32 @@ func (p *ebnfParser) parseTerm() bool { p.parseIdentifier(false) case token.STRING: - p.next(); + p.next() if p.tok == token.ELLIPSIS { - p.next(); - p.expect(token.STRING); + p.next() + p.expect(token.STRING) } case token.LPAREN: - p.next(); - p.parseExpression(); - p.expect(token.RPAREN); + p.next() + p.parseExpression() + p.expect(token.RPAREN) case token.LBRACK: - p.next(); - p.parseExpression(); - p.expect(token.RBRACK); + p.next() + p.parseExpression() + p.expect(token.RBRACK) case token.LBRACE: - p.next(); - p.parseExpression(); - p.expect(token.RBRACE); + p.next() + p.parseExpression() + p.expect(token.RBRACE) default: return false } - return true; + return true } @@ -132,70 +132,70 @@ func (p *ebnfParser) parseSequence() { func (p *ebnfParser) parseExpression() { for { - p.parseSequence(); + p.parseSequence() if p.tok != token.OR { break } - p.next(); + p.next() } } func (p *ebnfParser) parseProduction() { - p.parseIdentifier(true); - p.expect(token.ASSIGN); - p.parseExpression(); - p.expect(token.PERIOD); + p.parseIdentifier(true) + p.expect(token.ASSIGN) + p.parseExpression() + p.expect(token.PERIOD) } func (p *ebnfParser) parse(out io.Writer, src []byte) { // initialize ebnfParser - p.out = out; - p.src = src; - p.scanner.Init("", src, p, 0); - p.next(); // initializes pos, tok, lit + p.out = out + p.src = src + p.scanner.Init("", src, p, 0) + p.next() // initializes pos, tok, lit // process source for p.tok != token.EOF { p.parseProduction() } - p.flush(); + p.flush() } // Markers around EBNF sections var ( - openTag = strings.Bytes(`<pre class="ebnf">`); - closeTag = strings.Bytes(`</pre>`); + openTag = strings.Bytes(`<pre class="ebnf">`) + closeTag = strings.Bytes(`</pre>`) ) func linkify(out io.Writer, src []byte) { for len(src) > 0 { - n := len(src); + n := len(src) // i: beginning of EBNF text (or end of source) - i := bytes.Index(src, openTag); + i := bytes.Index(src, openTag) if i < 0 { i = n - len(openTag) } - i += len(openTag); + i += len(openTag) // j: end of EBNF text (or end of source) - j := bytes.Index(src[i:n], closeTag); // close marker + j := bytes.Index(src[i:n], closeTag) // close marker if j < 0 { j = n - i } - j += i; + j += i // write text before EBNF - out.Write(src[0:i]); + out.Write(src[0:i]) // parse and write EBNF - var p ebnfParser; - p.parse(out, src[i:j]); + var p ebnfParser + p.parse(out, src[i:j]) // advance - src = src[j:n]; + src = src[j:n] } } diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go index f0f23cb00..ee3147d4f 100644 --- a/src/cmd/gofmt/gofmt.go +++ b/src/cmd/gofmt/gofmt.go @@ -5,65 +5,65 @@ package main import ( - "bytes"; - oldParser "exp/parser"; - "flag"; - "fmt"; - "go/ast"; - "go/parser"; - "go/printer"; - "go/scanner"; - "io/ioutil"; - "os"; - pathutil "path"; - "strings"; + "bytes" + oldParser "exp/parser" + "flag" + "fmt" + "go/ast" + "go/parser" + "go/printer" + "go/scanner" + "io/ioutil" + "os" + pathutil "path" + "strings" ) var ( // main operation modes - list = flag.Bool("l", false, "list files whose formatting differs from gofmt's"); - write = flag.Bool("w", false, "write result to (source) file instead of stdout"); - rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'α[β:len(α)] -> α[β:]')"); + list = flag.Bool("l", false, "list files whose formatting differs from gofmt's") + write = flag.Bool("w", false, "write result to (source) file instead of stdout") + rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'α[β:len(α)] -> α[β:]')") // debugging support - comments = flag.Bool("comments", true, "print comments"); - trace = flag.Bool("trace", false, "print parse trace"); + comments = flag.Bool("comments", true, "print comments") + trace = flag.Bool("trace", false, "print parse trace") // layout control - tabWidth = flag.Int("tabwidth", 8, "tab width"); - tabIndent = flag.Bool("tabindent", false, "indent with tabs independent of -spaces"); - useSpaces = flag.Bool("spaces", false, "align with spaces instead of tabs"); + tabWidth = flag.Int("tabwidth", 8, "tab width") + tabIndent = flag.Bool("tabindent", true, "indent with tabs independent of -spaces") + useSpaces = flag.Bool("spaces", true, "align with spaces instead of tabs") // semicolon transition - useOldParser = flag.Bool("oldparser", true, "parse old syntax (required semicolons)"); - useOldPrinter = flag.Bool("oldprinter", true, "print old syntax (required semicolons)"); + useOldParser = flag.Bool("oldparser", false, "parse old syntax (required semicolons)") + useOldPrinter = flag.Bool("oldprinter", false, "print old syntax (required semicolons)") ) var ( - exitCode = 0; - rewrite func(*ast.File) *ast.File; - parserMode uint; - printerMode uint; + exitCode = 0 + rewrite func(*ast.File) *ast.File + parserMode uint + printerMode uint ) func report(err os.Error) { - scanner.PrintError(os.Stderr, err); - exitCode = 2; + scanner.PrintError(os.Stderr, err) + exitCode = 2 } func usage() { - fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [path ...]\n"); - flag.PrintDefaults(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [path ...]\n") + flag.PrintDefaults() + os.Exit(2) } func initParserMode() { - parserMode = uint(0); + parserMode = uint(0) if *comments { parserMode |= parser.ParseComments } @@ -74,7 +74,7 @@ func initParserMode() { func initPrinterMode() { - printerMode = uint(0); + printerMode = uint(0) if *tabIndent { printerMode |= printer.TabIndent } @@ -94,12 +94,12 @@ func isGoFile(d *os.Dir) bool { func processFile(f *os.File) os.Error { - src, err := ioutil.ReadAll(f); + src, err := ioutil.ReadAll(f) if err != nil { return err } - var file *ast.File; + var file *ast.File if *useOldParser { file, err = oldParser.ParseFile(f.Name(), src, parserMode) } else { @@ -113,8 +113,8 @@ func processFile(f *os.File) os.Error { file = rewrite(file) } - var res bytes.Buffer; - _, err = (&printer.Config{printerMode, *tabWidth, nil}).Fprint(&res, file); + var res bytes.Buffer + _, err = (&printer.Config{printerMode, *tabWidth, nil}).Fprint(&res, file) if err != nil { return err } @@ -125,7 +125,7 @@ func processFile(f *os.File) os.Error { fmt.Fprintln(os.Stdout, f.Name()) } if *write { - err = ioutil.WriteFile(f.Name(), res.Bytes(), 0); + err = ioutil.WriteFile(f.Name(), res.Bytes(), 0) if err != nil { return err } @@ -136,17 +136,17 @@ func processFile(f *os.File) os.Error { _, err = os.Stdout.Write(res.Bytes()) } - return err; + return err } func processFileByName(filename string) (err os.Error) { - file, err := os.Open(filename, os.O_RDONLY, 0); + file, err := os.Open(filename, os.O_RDONLY, 0) if err != nil { return } - defer file.Close(); - return processFile(file); + defer file.Close() + return processFile(file) } @@ -159,7 +159,7 @@ func (v fileVisitor) VisitDir(path string, d *os.Dir) bool { func (v fileVisitor) VisitFile(path string, d *os.Dir) { if isGoFile(d) { - v <- nil; // synchronize error handler + v <- nil // synchronize error handler if err := processFileByName(path); err != nil { v <- err } @@ -169,34 +169,34 @@ func (v fileVisitor) VisitFile(path string, d *os.Dir) { func walkDir(path string) { // start an error handler - done := make(chan bool); - v := make(fileVisitor); + done := make(chan bool) + v := make(fileVisitor) go func() { for err := range v { if err != nil { report(err) } } - done <- true; - }(); + done <- true + }() // walk the tree - pathutil.Walk(path, v, v); - close(v); // terminate error handler loop - <-done; // wait for all errors to be reported + pathutil.Walk(path, v, v) + close(v) // terminate error handler loop + <-done // wait for all errors to be reported } func main() { - flag.Usage = usage; - flag.Parse(); + flag.Usage = usage + flag.Parse() if *tabWidth < 0 { - fmt.Fprintf(os.Stderr, "negative tabwidth %d\n", *tabWidth); - os.Exit(2); + fmt.Fprintf(os.Stderr, "negative tabwidth %d\n", *tabWidth) + os.Exit(2) } - initParserMode(); - initPrinterMode(); - initRewrite(); + initParserMode() + initPrinterMode() + initRewrite() if flag.NArg() == 0 { if err := processFile(os.Stdin); err != nil { @@ -205,7 +205,7 @@ func main() { } for i := 0; i < flag.NArg(); i++ { - path := flag.Arg(i); + path := flag.Arg(i) switch dir, err := os.Stat(path); { case err != nil: report(err) @@ -218,5 +218,5 @@ func main() { } } - os.Exit(exitCode); + os.Exit(exitCode) } diff --git a/src/cmd/gofmt/rewrite.go b/src/cmd/gofmt/rewrite.go index ccbfe1d7f..fe35bfb08 100644 --- a/src/cmd/gofmt/rewrite.go +++ b/src/cmd/gofmt/rewrite.go @@ -5,15 +5,15 @@ package main import ( - "fmt"; - "go/ast"; - "go/parser"; - "go/token"; - "os"; - "reflect"; - "strings"; - "unicode"; - "utf8"; + "fmt" + "go/ast" + "go/parser" + "go/token" + "os" + "reflect" + "strings" + "unicode" + "utf8" ) @@ -21,14 +21,14 @@ func initRewrite() { if *rewriteRule == "" { return } - f := strings.Split(*rewriteRule, "->", 0); + f := strings.Split(*rewriteRule, "->", 0) if len(f) != 2 { - fmt.Fprintf(os.Stderr, "rewrite rule must be of the form 'pattern -> replacement'\n"); - os.Exit(2); + fmt.Fprintf(os.Stderr, "rewrite rule must be of the form 'pattern -> replacement'\n") + os.Exit(2) } - pattern := parseExpr(f[0], "pattern"); - replace := parseExpr(f[1], "replacement"); - rewrite = func(p *ast.File) *ast.File { return rewriteFile(pattern, replace, p) }; + pattern := parseExpr(f[0], "pattern") + replace := parseExpr(f[1], "replacement") + rewrite = func(p *ast.File) *ast.File { return rewriteFile(pattern, replace, p) } } @@ -37,41 +37,41 @@ func initRewrite() { // but there are problems with preserving formatting and also // with what a wildcard for a statement looks like. func parseExpr(s string, what string) ast.Expr { - stmts, err := parser.ParseStmtList("input", s); + stmts, err := parser.ParseStmtList("input", s) if err != nil { - fmt.Fprintf(os.Stderr, "parsing %s %s: %s\n", what, s, err); - os.Exit(2); + fmt.Fprintf(os.Stderr, "parsing %s %s: %s\n", what, s, err) + os.Exit(2) } if len(stmts) != 1 { - fmt.Fprintf(os.Stderr, "%s must be single expression\n", what); - os.Exit(2); + fmt.Fprintf(os.Stderr, "%s must be single expression\n", what) + os.Exit(2) } - x, ok := stmts[0].(*ast.ExprStmt); + x, ok := stmts[0].(*ast.ExprStmt) if !ok { - fmt.Fprintf(os.Stderr, "%s must be single expression\n", what); - os.Exit(2); + fmt.Fprintf(os.Stderr, "%s must be single expression\n", what) + os.Exit(2) } - return x.X; + return x.X } // rewriteFile applys the rewrite rule pattern -> replace to an entire file. func rewriteFile(pattern, replace ast.Expr, p *ast.File) *ast.File { - m := make(map[string]reflect.Value); - pat := reflect.NewValue(pattern); - repl := reflect.NewValue(replace); - var f func(val reflect.Value) reflect.Value; // f is recursive + m := make(map[string]reflect.Value) + pat := reflect.NewValue(pattern) + repl := reflect.NewValue(replace) + var f func(val reflect.Value) reflect.Value // f is recursive f = func(val reflect.Value) reflect.Value { for k := range m { m[k] = nil, false } - val = apply(f, val); + val = apply(f, val) if match(m, pat, val) { val = subst(m, repl, reflect.NewValue(val.Interface().(ast.Node).Pos())) } - return val; - }; - return apply(f, reflect.NewValue(p)).Interface().(*ast.File); + return val + } + return apply(f, reflect.NewValue(p)).Interface().(*ast.File) } @@ -80,8 +80,8 @@ var identType = reflect.Typeof((*ast.Ident)(nil)) func isWildcard(s string) bool { - rune, size := utf8.DecodeRuneInString(s); - return size == len(s) && unicode.IsLower(rune); + rune, size := utf8.DecodeRuneInString(s) + return size == len(s) && unicode.IsLower(rune) } @@ -94,19 +94,19 @@ func apply(f func(reflect.Value) reflect.Value, val reflect.Value) reflect.Value switch v := reflect.Indirect(val).(type) { case *reflect.SliceValue: for i := 0; i < v.Len(); i++ { - e := v.Elem(i); - e.SetValue(f(e)); + e := v.Elem(i) + e.SetValue(f(e)) } case *reflect.StructValue: for i := 0; i < v.NumField(); i++ { - e := v.Field(i); - e.SetValue(f(e)); + e := v.Field(i) + e.SetValue(f(e)) } case *reflect.InterfaceValue: - e := v.Elem(); - v.SetValue(f(e)); + e := v.Elem() + v.SetValue(f(e)) } - return val; + return val } @@ -118,13 +118,13 @@ func match(m map[string]reflect.Value, pattern, val reflect.Value) bool { // times in the pattern, it must match the same expression // each time. if m != nil && pattern.Type() == identType { - name := pattern.Interface().(*ast.Ident).Value; + name := pattern.Interface().(*ast.Ident).Value if isWildcard(name) { if old, ok := m[name]; ok { return match(nil, old, val) } - m[name] = val; - return true; + m[name] = val + return true } } @@ -141,35 +141,35 @@ func match(m map[string]reflect.Value, pattern, val reflect.Value) bool { return true } - p := reflect.Indirect(pattern); - v := reflect.Indirect(val); + p := reflect.Indirect(pattern) + v := reflect.Indirect(val) switch p := p.(type) { case *reflect.SliceValue: - v := v.(*reflect.SliceValue); + v := v.(*reflect.SliceValue) for i := 0; i < p.Len(); i++ { if !match(m, p.Elem(i), v.Elem(i)) { return false } } - return true; + return true case *reflect.StructValue: - v := v.(*reflect.StructValue); + v := v.(*reflect.StructValue) for i := 0; i < p.NumField(); i++ { if !match(m, p.Field(i), v.Field(i)) { return false } } - return true; + return true case *reflect.InterfaceValue: - v := v.(*reflect.InterfaceValue); - return match(m, p.Elem(), v.Elem()); + v := v.(*reflect.InterfaceValue) + return match(m, p.Elem(), v.Elem()) } // Handle token integers, etc. - return p.Interface() == v.Interface(); + return p.Interface() == v.Interface() } @@ -184,7 +184,7 @@ func subst(m map[string]reflect.Value, pattern reflect.Value, pos reflect.Value) // Wildcard gets replaced with map value. if m != nil && pattern.Type() == identType { - name := pattern.Interface().(*ast.Ident).Value; + name := pattern.Interface().(*ast.Ident).Value if isWildcard(name) { if old, ok := m[name]; ok { return subst(nil, old, nil) @@ -199,29 +199,29 @@ func subst(m map[string]reflect.Value, pattern reflect.Value, pos reflect.Value) // Otherwise copy. switch p := pattern.(type) { case *reflect.SliceValue: - v := reflect.MakeSlice(p.Type().(*reflect.SliceType), p.Len(), p.Len()); + v := reflect.MakeSlice(p.Type().(*reflect.SliceType), p.Len(), p.Len()) for i := 0; i < p.Len(); i++ { v.Elem(i).SetValue(subst(m, p.Elem(i), pos)) } - return v; + return v case *reflect.StructValue: - v := reflect.MakeZero(p.Type()).(*reflect.StructValue); + v := reflect.MakeZero(p.Type()).(*reflect.StructValue) for i := 0; i < p.NumField(); i++ { v.Field(i).SetValue(subst(m, p.Field(i), pos)) } - return v; + return v case *reflect.PtrValue: - v := reflect.MakeZero(p.Type()).(*reflect.PtrValue); - v.PointTo(subst(m, p.Elem(), pos)); - return v; + v := reflect.MakeZero(p.Type()).(*reflect.PtrValue) + v.PointTo(subst(m, p.Elem(), pos)) + return v case *reflect.InterfaceValue: - v := reflect.MakeZero(p.Type()).(*reflect.InterfaceValue); - v.SetValue(subst(m, p.Elem(), pos)); - return v; + v := reflect.MakeZero(p.Type()).(*reflect.InterfaceValue) + v.SetValue(subst(m, p.Elem(), pos)) + return v } - return pattern; + return pattern } diff --git a/src/cmd/goyacc/goyacc.go b/src/cmd/goyacc/goyacc.go index cdaa7f1cd..59c975232 100644 --- a/src/cmd/goyacc/goyacc.go +++ b/src/cmd/goyacc/goyacc.go @@ -45,62 +45,62 @@ package main // import ( - "flag"; - "fmt"; - "bufio"; - "os"; + "flag" + "fmt" + "bufio" + "os" ) // the following are adjustable // according to memory size const ( - ACTSIZE = 30000; - NSTATES = 2000; - TEMPSIZE = 2000; + ACTSIZE = 30000 + NSTATES = 2000 + TEMPSIZE = 2000 - SYMINC = 50; // increase for non-term or term - RULEINC = 50; // increase for max rule length prodptr[i] - PRODINC = 100; // increase for productions prodptr - WSETINC = 50; // increase for working sets wsets - STATEINC = 200; // increase for states statemem + SYMINC = 50 // increase for non-term or term + RULEINC = 50 // increase for max rule length prodptr[i] + PRODINC = 100 // increase for productions prodptr + WSETINC = 50 // increase for working sets wsets + STATEINC = 200 // increase for states statemem - NAMESIZE = 50; - NTYPES = 63; - ISIZE = 400; + NAMESIZE = 50 + NTYPES = 63 + ISIZE = 400 - PRIVATE = 0xE000; // unicode private use + PRIVATE = 0xE000 // unicode private use // relationships which must hold: // TEMPSIZE >= NTERMS + NNONTERM + 1; // TEMPSIZE >= NSTATES; // - NTBASE = 010000; - ERRCODE = 8190; - ACCEPTCODE = 8191; - YYLEXUNK = 3; - TOKSTART = 4; //index of first defined token + NTBASE = 010000 + ERRCODE = 8190 + ACCEPTCODE = 8191 + YYLEXUNK = 3 + TOKSTART = 4 //index of first defined token ) // no, left, right, binary assoc. const ( - NOASC = iota; - LASC; - RASC; - BASC; + NOASC = iota + LASC + RASC + BASC ) // flags for state generation const ( - DONE = iota; - MUSTDO; - MUSTLOOKAHEAD; + DONE = iota + MUSTDO + MUSTLOOKAHEAD ) // flags for a rule having an action, and being reduced const ( - ACTFLAG = 1 << (iota + 2); - REDFLAG; + ACTFLAG = 1 << (iota + 2) + REDFLAG ) // output parser flags @@ -108,20 +108,20 @@ const YYFLAG = -1000 // parse tokens const ( - IDENTIFIER = PRIVATE + iota; - MARK; - TERM; - LEFT; - RIGHT; - BINARY; - PREC; - LCURLY; - IDENTCOLON; - NUMBER; - START; - TYPEDEF; - TYPENAME; - UNION; + IDENTIFIER = PRIVATE + iota + MARK + TERM + LEFT + RIGHT + BINARY + PREC + LCURLY + IDENTCOLON + NUMBER + START + TYPEDEF + TYPENAME + UNION ) const ENDFILE = 0 @@ -131,97 +131,97 @@ const OK = 1 const NOMORE = -1000 // macros for getting associativity and precedence levels -func ASSOC(i int) int { return i & 3 } +func ASSOC(i int) int { return i & 3 } -func PLEVEL(i int) int { return (i >> 4) & 077 } +func PLEVEL(i int) int { return (i >> 4) & 077 } -func TYPE(i int) int { return (i >> 10) & 077 } +func TYPE(i int) int { return (i >> 10) & 077 } // macros for setting associativity and precedence levels -func SETASC(i, j int) int { return i | j } +func SETASC(i, j int) int { return i | j } -func SETPLEV(i, j int) int { return i | (j << 4) } +func SETPLEV(i, j int) int { return i | (j << 4) } -func SETTYPE(i, j int) int { return i | (j << 10) } +func SETTYPE(i, j int) int { return i | (j << 10) } // I/O descriptors -var finput *bufio.Reader // input file +var finput *bufio.Reader // input file var stderr *bufio.Writer -var ftable *bufio.Writer // y.go file -var foutput *bufio.Writer // y.output file +var ftable *bufio.Writer // y.go file +var foutput *bufio.Writer // y.output file -var oflag string // -o [y.go] - y.go file -var vflag string // -v [y.output] - y.output file -var lflag bool // -l - disable line directives +var oflag string // -o [y.go] - y.go file +var vflag string // -v [y.output] - y.output file +var lflag bool // -l - disable line directives var stacksize = 200 // communication variables between various I/O routines -var infile string // input file name -var numbval int // value of an input number -var tokname string // input token name, slop for runes and 0 +var infile string // input file name +var numbval int // value of an input number +var tokname string // input token name, slop for runes and 0 var tokflag = false // structure declarations type Lkset []int type Pitem struct { - prod []int; - off int; // offset within the production - first int; // first term or non-term in item - prodno int; // production number for sorting + prod []int + off int // offset within the production + first int // first term or non-term in item + prodno int // production number for sorting } type Item struct { - pitem Pitem; - look Lkset; + pitem Pitem + look Lkset } type Symb struct { - name string; - value int; + name string + value int } type Wset struct { - pitem Pitem; - flag int; - ws Lkset; + pitem Pitem + flag int + ws Lkset } // storage of types -var ntypes int // number of types defined -var typeset [NTYPES]string // pointers to type tags +var ntypes int // number of types defined +var typeset [NTYPES]string // pointers to type tags // token information -var ntokens = 0 // number of tokens +var ntokens = 0 // number of tokens var tokset []Symb -var toklev []int // vector with the precedence of the terminals +var toklev []int // vector with the precedence of the terminals // nonterminal information -var nnonter = -1 // the number of nonterminals +var nnonter = -1 // the number of nonterminals var nontrst []Symb -var start int // start symbol +var start int // start symbol // state information -var nstate = 0 // number of states -var pstate = make([]int, NSTATES+2) // index into statemem to the descriptions of the states +var nstate = 0 // number of states +var pstate = make([]int, NSTATES+2) // index into statemem to the descriptions of the states var statemem []Item -var tystate = make([]int, NSTATES) // contains type information about the states -var tstates []int // states generated by terminal gotos -var ntstates []int // states generated by nonterminal gotos -var mstates = make([]int, NSTATES) // chain of overflows of term/nonterm generation lists -var lastred int // number of last reduction of a state -var defact = make([]int, NSTATES) // default actions of states +var tystate = make([]int, NSTATES) // contains type information about the states +var tstates []int // states generated by terminal gotos +var ntstates []int // states generated by nonterminal gotos +var mstates = make([]int, NSTATES) // chain of overflows of term/nonterm generation lists +var lastred int // number of last reduction of a state +var defact = make([]int, NSTATES) // default actions of states // lookahead set information var lkst []Lkset -var nolook = 0 // flag to turn off lookahead computations -var tbitset = 0 // size of lookahead sets -var clset Lkset // temporary storage for lookahead computations +var nolook = 0 // flag to turn off lookahead computations +var tbitset = 0 // size of lookahead sets +var clset Lkset // temporary storage for lookahead computations // working set information @@ -230,16 +230,16 @@ var cwp int // storage for action table -var amem []int // action table storage -var memp int // next free action table position -var indgo = make([]int, NSTATES) // index to the stored goto table +var amem []int // action table storage +var memp int // next free action table position +var indgo = make([]int, NSTATES) // index to the stored goto table // temporary vector, indexable by states, terms, or ntokens -var temp1 = make([]int, TEMPSIZE) // temporary storage, indexed by terms + ntokens or states -var lineno = 1 // current input line number -var fatfl = 1 // if on, error is fatal -var nerrors = 0 // number of errors +var temp1 = make([]int, TEMPSIZE) // temporary storage, indexed by terms + ntokens or states +var lineno = 1 // current input line number +var fatfl = 1 // if on, error is fatal +var nerrors = 0 // number of errors // assigned token type values @@ -247,10 +247,10 @@ var extval = 0 // grammar rule information -var nprod = 1 // number of productions -var prdptr [][]int // pointers to descriptions of productions -var levprd []int // precedence levels for the productions -var rlines []int // line number for this rule +var nprod = 1 // number of productions +var prdptr [][]int // pointers to descriptions of productions +var levprd []int // precedence levels for the productions +var rlines []int // line number for this rule // statistics collection variables @@ -270,29 +270,29 @@ var optst [][]int var ggreed []int var pgo []int -var maxspr int // maximum spread of any entry -var maxoff int // maximum offset into a array +var maxspr int // maximum spread of any entry +var maxoff int // maximum offset into a array var maxa int // storage for information about the nonterminals -var pres [][][]int // vector of pointers to productions yielding each nonterminal +var pres [][][]int // vector of pointers to productions yielding each nonterminal var pfirst []Lkset -var pempty []int // vector of nonterminals nontrivially deriving e +var pempty []int // vector of nonterminals nontrivially deriving e // random stuff picked out from between functions -var indebug = 0 // debugging flag for cpfir -var pidebug = 0 // debugging flag for putitem -var gsdebug = 0 // debugging flag for stagen -var cldebug = 0 // debugging flag for closure -var pkdebug = 0 // debugging flag for apack -var g2debug = 0 // debugging for go2gen -var adb = 0 // debugging for callopt +var indebug = 0 // debugging flag for cpfir +var pidebug = 0 // debugging flag for putitem +var gsdebug = 0 // debugging flag for stagen +var cldebug = 0 // debugging flag for closure +var pkdebug = 0 // debugging flag for apack +var g2debug = 0 // debugging for go2gen +var adb = 0 // debugging for callopt type Resrv struct { - name string; - value int; + name string + value int } var resrv = []Resrv{ @@ -316,59 +316,59 @@ const UTFmax = 0x3f func main() { - setup(); // initialize and read productions + setup() // initialize and read productions - tbitset = (ntokens + 32) / 32; - cpres(); // make table of which productions yield a given nonterminal - cempty(); // make a table of which nonterminals can match the empty string - cpfir(); // make a table of firsts of nonterminals + tbitset = (ntokens + 32) / 32 + cpres() // make table of which productions yield a given nonterminal + cempty() // make a table of which nonterminals can match the empty string + cpfir() // make a table of firsts of nonterminals - stagen(); // generate the states + stagen() // generate the states - yypgo = make([][]int, nnonter+1); - optst = make([][]int, nstate); - output(); // write the states and the tables - go2out(); + yypgo = make([][]int, nnonter+1) + optst = make([][]int, nstate) + output() // write the states and the tables + go2out() - hideprod(); - summary(); + hideprod() + summary() - callopt(); + callopt() - others(); + others() - exit(0); + exit(0) } func setup() { - var j, ty int; + var j, ty int - stderr = bufio.NewWriter(os.NewFile(2, "stderr")); - foutput = nil; + stderr = bufio.NewWriter(os.NewFile(2, "stderr")) + foutput = nil - flag.StringVar(&oflag, "o", "", "parser output"); - flag.StringVar(&vflag, "v", "", "create parsing tables"); - flag.BoolVar(&lflag, "l", false, "disable line directives"); + flag.StringVar(&oflag, "o", "", "parser output") + flag.StringVar(&vflag, "v", "", "create parsing tables") + flag.BoolVar(&lflag, "l", false, "disable line directives") - flag.Parse(); + flag.Parse() if flag.NArg() != 1 { usage() } if stacksize < 1 { // never set so cannot happen - fmt.Fprintf(stderr, "yacc: stack size too small\n"); - usage(); + fmt.Fprintf(stderr, "yacc: stack size too small\n") + usage() } - openup(); + openup() - defin(0, "$end"); - extval = PRIVATE; // tokens start in unicode 'private use' - defin(0, "error"); - defin(1, "$accept"); - defin(0, "$unk"); - i := 0; + defin(0, "$end") + extval = PRIVATE // tokens start in unicode 'private use' + defin(0, "error") + defin(1, "$accept") + defin(0, "$unk") + i := 0 - t := gettok(); + t := gettok() outer: for { @@ -382,25 +382,25 @@ outer: case ';': case START: - t = gettok(); + t = gettok() if t != IDENTIFIER { error("bad %%start construction") } - start = chfind(1, tokname); + start = chfind(1, tokname) case TYPEDEF: - t = gettok(); + t = gettok() if t != TYPENAME { error("bad syntax in %%type") } - ty = numbval; + ty = numbval for { - t = gettok(); + t = gettok() switch t { case IDENTIFIER: - t = chfind(1, tokname); + t = chfind(1, tokname) if t < NTBASE { - j = TYPE(toklev[t]); + j = TYPE(toklev[t]) if j != 0 && j != ty { error("type redeclaration of token ", tokset[t].name) @@ -408,7 +408,7 @@ outer: toklev[t] = SETTYPE(toklev[t], ty) } } else { - j = nontrst[t-NTBASE].value; + j = nontrst[t-NTBASE].value if j != 0 && j != ty { error("type redeclaration of nonterminal %v", nontrst[t-NTBASE].name) @@ -416,45 +416,45 @@ outer: nontrst[t-NTBASE].value = ty } } - continue; + continue case ',': continue } - break; + break } - continue; + continue case UNION: cpyunion() case LEFT, BINARY, RIGHT, TERM: // nonzero means new prec. and assoc. - lev := t - TERM; + lev := t - TERM if lev != 0 { i++ } - ty = 0; + ty = 0 // get identifiers so defined - t = gettok(); + t = gettok() // there is a type defined if t == TYPENAME { - ty = numbval; - t = gettok(); + ty = numbval + t = gettok() } for { switch t { case ',': - t = gettok(); - continue; + t = gettok() + continue case ';': break case IDENTIFIER: - j = chfind(0, tokname); + j = chfind(0, tokname) if j >= NTBASE { error("%v defined earlier as nonterminal", tokname) } @@ -462,31 +462,31 @@ outer: if ASSOC(toklev[j]) != 0 { error("redeclaration of precedence of %v", tokname) } - toklev[j] = SETASC(toklev[j], lev); - toklev[j] = SETPLEV(toklev[j], i); + toklev[j] = SETASC(toklev[j], lev) + toklev[j] = SETPLEV(toklev[j], i) } if ty != 0 { if TYPE(toklev[j]) != 0 { error("redeclaration of type of %v", tokname) } - toklev[j] = SETTYPE(toklev[j], ty); + toklev[j] = SETTYPE(toklev[j], ty) } - t = gettok(); + t = gettok() if t == NUMBER { - tokset[j].value = numbval; - t = gettok(); + tokset[j].value = numbval + t = gettok() } - continue; + continue } - break; + break } - continue; + continue case LCURLY: cpycode() } - t = gettok(); + t = gettok() } if t == ENDFILE { @@ -496,36 +496,36 @@ outer: // put out non-literal terminals for i := TOKSTART; i <= ntokens; i++ { // non-literals - c := tokset[i].name[0]; + c := tokset[i].name[0] if c != ' ' && c != '$' { fmt.Fprintf(ftable, "const\t%v\t= %v\n", tokset[i].name, tokset[i].value) } } // put out names of token names - fmt.Fprintf(ftable, "var\tToknames\t =[]string {\n"); + fmt.Fprintf(ftable, "var\tToknames\t =[]string {\n") for i := TOKSTART; i <= ntokens; i++ { fmt.Fprintf(ftable, "\t\"%v\",\n", tokset[i].name) } - fmt.Fprintf(ftable, "}\n"); + fmt.Fprintf(ftable, "}\n") // put out names of state names - fmt.Fprintf(ftable, "var\tStatenames\t =[]string {\n"); + fmt.Fprintf(ftable, "var\tStatenames\t =[]string {\n") // for i:=TOKSTART; i<=ntokens; i++ { // fmt.Fprintf(ftable, "\t\"%v\",\n", tokset[i].name); // } - fmt.Fprintf(ftable, "}\n"); + fmt.Fprintf(ftable, "}\n") - fmt.Fprintf(ftable, "\nfunc\n"); - fmt.Fprintf(ftable, "yyrun(p int, yypt int) {\n"); - fmt.Fprintf(ftable, "switch p {\n"); + fmt.Fprintf(ftable, "\nfunc\n") + fmt.Fprintf(ftable, "yyrun(p int, yypt int) {\n") + fmt.Fprintf(ftable, "switch p {\n") - moreprod(); - prdptr[0] = []int{NTBASE, start, 1, 0}; + moreprod() + prdptr[0] = []int{NTBASE, start, 1, 0} - nprod = 1; - curprod := make([]int, RULEINC); - t = gettok(); + nprod = 1 + curprod := make([]int, RULEINC) + t = gettok() if t != IDENTCOLON { error("bad syntax on first rule") } @@ -541,85 +541,85 @@ outer: // followd by -nprod for t != MARK && t != ENDFILE { - mem := 0; + mem := 0 // process a rule - rlines[nprod] = lineno; + rlines[nprod] = lineno if t == '|' { - curprod[mem] = prdptr[nprod-1][0]; - mem++; + curprod[mem] = prdptr[nprod-1][0] + mem++ } else if t == IDENTCOLON { - curprod[mem] = chfind(1, tokname); + curprod[mem] = chfind(1, tokname) if curprod[mem] < NTBASE { error("token illegal on LHS of grammar rule") } - mem++; + mem++ } else { error("illegal rule: missing semicolon or | ?") } // read rule body - t = gettok(); + t = gettok() for { for t == IDENTIFIER { - curprod[mem] = chfind(1, tokname); + curprod[mem] = chfind(1, tokname) if curprod[mem] < NTBASE { levprd[nprod] = toklev[curprod[mem]] } - mem++; + mem++ if mem >= len(curprod) { - ncurprod := make([]int, mem+RULEINC); - copy(ncurprod, curprod); - curprod = ncurprod; + ncurprod := make([]int, mem+RULEINC) + copy(ncurprod, curprod) + curprod = ncurprod } - t = gettok(); + t = gettok() } if t == PREC { if gettok() != IDENTIFIER { error("illegal %%prec syntax") } - j = chfind(2, tokname); + j = chfind(2, tokname) if j >= NTBASE { error("nonterminal " + nontrst[j-NTBASE].name + " illegal after %%prec") } - levprd[nprod] = toklev[j]; - t = gettok(); + levprd[nprod] = toklev[j] + t = gettok() } if t != '=' { break } - levprd[nprod] |= ACTFLAG; - fmt.Fprintf(ftable, "\ncase %v:", nprod); - cpyact(curprod, mem); + levprd[nprod] |= ACTFLAG + fmt.Fprintf(ftable, "\ncase %v:", nprod) + cpyact(curprod, mem) // action within rule... - t = gettok(); + t = gettok() if t == IDENTIFIER { // make it a nonterminal - j = chfind(1, fmt.Sprintf("$$%v", nprod)); + j = chfind(1, fmt.Sprintf("$$%v", nprod)) // // the current rule will become rule number nprod+1 // enter null production for action // - prdptr[nprod] = make([]int, 2); - prdptr[nprod][0] = j; - prdptr[nprod][1] = -nprod; + prdptr[nprod] = make([]int, 2) + prdptr[nprod][0] = j + prdptr[nprod][1] = -nprod // update the production information - nprod++; - moreprod(); - levprd[nprod] = levprd[nprod-1] & ^ACTFLAG; - levprd[nprod-1] = ACTFLAG; - rlines[nprod] = lineno; + nprod++ + moreprod() + levprd[nprod] = levprd[nprod-1] & ^ACTFLAG + levprd[nprod-1] = ACTFLAG + rlines[nprod] = lineno // make the action appear in the original rule - curprod[mem] = j; - mem++; + curprod[mem] = j + mem++ if mem >= len(curprod) { - ncurprod := make([]int, mem+RULEINC); - copy(ncurprod, curprod); - curprod = ncurprod; + ncurprod := make([]int, mem+RULEINC) + copy(ncurprod, curprod) + curprod = ncurprod } } } @@ -627,14 +627,14 @@ outer: for t == ';' { t = gettok() } - curprod[mem] = -nprod; - mem++; + curprod[mem] = -nprod + mem++ // check that default action is reasonable if ntypes != 0 && (levprd[nprod]&ACTFLAG) == 0 && nontrst[curprod[0]-NTBASE].value != 0 { // no explicit action, LHS has value - tempty := curprod[1]; + tempty := curprod[1] if tempty < 0 { error("must return a value, since LHS has a type") } @@ -646,16 +646,16 @@ outer: if tempty != nontrst[curprod[0]-NTBASE].value { error("default action causes potential type clash") } - fmt.Fprintf(ftable, "\ncase %v:", nprod); + fmt.Fprintf(ftable, "\ncase %v:", nprod) fmt.Fprintf(ftable, "\n\tYYVAL.%v = YYS[yypt-0].%v;", - typeset[tempty], typeset[tempty]); + typeset[tempty], typeset[tempty]) } - moreprod(); - prdptr[nprod] = make([]int, mem); - copy(prdptr[nprod], curprod); - nprod++; - moreprod(); - levprd[nprod] = 0; + moreprod() + prdptr[nprod] = make([]int, mem) + copy(prdptr[nprod], curprod) + nprod++ + moreprod() + levprd[nprod] = 0 } // @@ -663,12 +663,12 @@ outer: // dump out the prefix code // - fmt.Fprintf(ftable, "\n\t}"); - fmt.Fprintf(ftable, "\n}\n"); + fmt.Fprintf(ftable, "\n\t}") + fmt.Fprintf(ftable, "\n}\n") - fmt.Fprintf(ftable, "const YYEOFCODE = 1\n"); - fmt.Fprintf(ftable, "const YYERRCODE = 2\n"); - fmt.Fprintf(ftable, "const YYMAXDEPTH = %v\n", stacksize); + fmt.Fprintf(ftable, "const YYEOFCODE = 1\n") + fmt.Fprintf(ftable, "const YYERRCODE = 2\n") + fmt.Fprintf(ftable, "const YYMAXDEPTH = %v\n", stacksize) // // copy any postfix code @@ -678,11 +678,11 @@ outer: fmt.Fprintf(ftable, "\n//line %v:%v\n", infile, lineno) } for { - c := getrune(finput); + c := getrune(finput) if c == EOF { break } - putrune(ftable, c); + putrune(ftable, c) } } } @@ -691,20 +691,20 @@ outer: // allocate enough room to hold another production // func moreprod() { - n := len(prdptr); + n := len(prdptr) if nprod >= n { - nn := n + PRODINC; - aprod := make([][]int, nn); - alevprd := make([]int, nn); - arlines := make([]int, nn); + nn := n + PRODINC + aprod := make([][]int, nn) + alevprd := make([]int, nn) + arlines := make([]int, nn) - copy(aprod, prdptr); - copy(alevprd, levprd); - copy(arlines, rlines); + copy(aprod, prdptr) + copy(alevprd, levprd) + copy(arlines, rlines) - prdptr = aprod; - levprd = alevprd; - rlines = arlines; + prdptr = aprod + levprd = alevprd + rlines = arlines } } @@ -713,39 +713,39 @@ func moreprod() { // or a nonterminal if t=1 // func defin(nt int, s string) int { - val := 0; + val := 0 if nt != 0 { - nnonter++; + nnonter++ if nnonter >= len(nontrst) { - anontrst := make([]Symb, nnonter+SYMINC); - copy(anontrst, nontrst); - nontrst = anontrst; + anontrst := make([]Symb, nnonter+SYMINC) + copy(anontrst, nontrst) + nontrst = anontrst } - nontrst[nnonter] = Symb{s, 0}; - return NTBASE + nnonter; + nontrst[nnonter] = Symb{s, 0} + return NTBASE + nnonter } // must be a token - ntokens++; + ntokens++ if ntokens >= len(tokset) { - nn := ntokens + SYMINC; - atokset := make([]Symb, nn); - atoklev := make([]int, nn); + nn := ntokens + SYMINC + atokset := make([]Symb, nn) + atoklev := make([]int, nn) - copy(atoklev, toklev); - copy(atokset, tokset); + copy(atoklev, toklev) + copy(atokset, tokset) - tokset = atokset; - toklev = atoklev; + tokset = atokset + toklev = atoklev } - tokset[ntokens].name = s; - toklev[ntokens] = 0; + tokset[ntokens].name = s + toklev[ntokens] = 0 // establish value for token // single character literal if s[0] == ' ' && len(s) == 1+1 { val = int(s[1]) - } else if s[0] == ' ' && s[1] == '\\' { // escape sequence + } else if s[0] == ' ' && s[1] == '\\' { // escape sequence if len(s) == 2+1 { // single character escape sequence switch s[2] { @@ -770,11 +770,11 @@ func defin(nt int, s string) int { default: error("invalid escape %v", s[1:3]) } - } else if s[2] == 'u' && len(s) == 2+1+4 { // \unnnn sequence - val = 0; - s = s[3:]; + } else if s[2] == 'u' && len(s) == 2+1+4 { // \unnnn sequence + val = 0 + s = s[3:] for s != "" { - c := int(s[0]); + c := int(s[0]) switch { case c >= '0' && c <= '9': c -= '0' @@ -785,8 +785,8 @@ func defin(nt int, s string) int { default: error("illegal \\unnnn construction") } - val = val*16 + c; - s = s[1:]; + val = val*16 + c + s = s[1:] } if val == 0 { error("'\\u0000' is illegal") @@ -795,36 +795,36 @@ func defin(nt int, s string) int { error("unknown escape") } } else { - val = extval; - extval++; + val = extval + extval++ } - tokset[ntokens].value = val; - return ntokens; + tokset[ntokens].value = val + return ntokens } var peekline = 0 func gettok() int { - var i, match, c int; + var i, match, c int - tokname = ""; + tokname = "" for { - lineno += peekline; - peekline = 0; - c = getrune(finput); + lineno += peekline + peekline = 0 + c = getrune(finput) for c == ' ' || c == '\n' || c == '\t' || c == '\v' || c == '\r' { if c == '\n' { lineno++ } - c = getrune(finput); + c = getrune(finput) } // skip comment -- fix if c != '/' { break } - lineno += skipcom(); + lineno += skipcom() } switch c { @@ -832,21 +832,21 @@ func gettok() int { if tokflag { fmt.Printf(">>> ENDFILE %v\n", lineno) } - return ENDFILE; + return ENDFILE case '{': - ungetrune(finput, c); + ungetrune(finput, c) if tokflag { fmt.Printf(">>> ={ %v\n", lineno) } - return '='; + return '=' case '<': // get, and look up, a type name (union member name) - c = getrune(finput); + c = getrune(finput) for c != '>' && c != EOF && c != '\n' { - tokname += string(c); - c = getrune(finput); + tokname += string(c) + c = getrune(finput) } if c != '>' { @@ -855,62 +855,62 @@ func gettok() int { for i = 1; i <= ntypes; i++ { if typeset[i] == tokname { - numbval = i; + numbval = i if tokflag { fmt.Printf(">>> TYPENAME old <%v> %v\n", tokname, lineno) } - return TYPENAME; + return TYPENAME } } - ntypes++; - numbval = ntypes; - typeset[numbval] = tokname; + ntypes++ + numbval = ntypes + typeset[numbval] = tokname if tokflag { fmt.Printf(">>> TYPENAME new <%v> %v\n", tokname, lineno) } - return TYPENAME; + return TYPENAME case '"', '\'': - match = c; - tokname = " "; + match = c + tokname = " " for { - c = getrune(finput); + c = getrune(finput) if c == '\n' || c == EOF { error("illegal or missing ' or \"") } if c == '\\' { - tokname += string('\\'); - c = getrune(finput); + tokname += string('\\') + c = getrune(finput) } else if c == match { if tokflag { fmt.Printf(">>> IDENTIFIER \"%v\" %v\n", tokname, lineno) } - return IDENTIFIER; + return IDENTIFIER } - tokname += string(c); + tokname += string(c) } case '%': - c = getrune(finput); + c = getrune(finput) switch c { case '%': if tokflag { fmt.Printf(">>> MARK %%%% %v\n", lineno) } - return MARK; + return MARK case '=': if tokflag { fmt.Printf(">>> PREC %%= %v\n", lineno) } - return PREC; + return PREC case '{': if tokflag { fmt.Printf(">>> LCURLY %%{ %v\n", lineno) } - return LCURLY; + return LCURLY } - getword(c); + getword(c) // find a reserved word for c = 0; c < len(resrv); c++ { if tokname == resrv[c].name { @@ -918,39 +918,39 @@ func gettok() int { fmt.Printf(">>> %%%v %v %v\n", tokname, resrv[c].value-PRIVATE, lineno) } - return resrv[c].value; + return resrv[c].value } } - error("invalid escape, or illegal reserved word: %v", tokname); + error("invalid escape, or illegal reserved word: %v", tokname) case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': - numbval = c - '0'; + numbval = c - '0' for { - c = getrune(finput); + c = getrune(finput) if !isdigit(c) { break } - numbval = numbval*10 + c - '0'; + numbval = numbval*10 + c - '0' } - ungetrune(finput, c); + ungetrune(finput, c) if tokflag { fmt.Printf(">>> NUMBER %v %v\n", numbval, lineno) } - return NUMBER; + return NUMBER default: if isword(c) || c == '.' || c == '$' { - getword(c); - break; + getword(c) + break } if tokflag { fmt.Printf(">>> OPERATOR %v %v\n", string(c), lineno) } - return c; + return c } // look ahead to distinguish IDENTIFIER from IDENTCOLON - c = getrune(finput); + c = getrune(finput) for c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\r' || c == '/' { if c == '\n' { peekline++ @@ -959,49 +959,49 @@ func gettok() int { if c == '/' { peekline += skipcom() } - c = getrune(finput); + c = getrune(finput) } if c == ':' { if tokflag { fmt.Printf(">>> IDENTCOLON %v: %v\n", tokname, lineno) } - return IDENTCOLON; + return IDENTCOLON } - ungetrune(finput, c); + ungetrune(finput, c) if tokflag { fmt.Printf(">>> IDENTIFIER %v %v\n", tokname, lineno) } - return IDENTIFIER; + return IDENTIFIER } func getword(c int) { - tokname = ""; + tokname = "" for isword(c) || isdigit(c) || c == '_' || c == '.' || c == '$' { - tokname += string(c); - c = getrune(finput); + tokname += string(c) + c = getrune(finput) } - ungetrune(finput, c); + ungetrune(finput, c) } // // determine the type of a symbol // func fdtype(t int) int { - var v int; - var s string; + var v int + var s string if t >= NTBASE { - v = nontrst[t-NTBASE].value; - s = nontrst[t-NTBASE].name; + v = nontrst[t-NTBASE].value + s = nontrst[t-NTBASE].name } else { - v = TYPE(toklev[t]); - s = tokset[t].name; + v = TYPE(toklev[t]) + s = tokset[t].name } if v <= 0 { error("must specify type for %v", s) } - return v; + return v } func chfind(t int, s string) int { @@ -1023,7 +1023,7 @@ func chfind(t int, s string) int { if t > 1 { error("%v should have been defined earlier", s) } - return defin(t, s); + return defin(t, s) } // @@ -1034,17 +1034,17 @@ func cpyunion() { if !lflag { fmt.Fprintf(ftable, "\n//line %v %v\n", lineno, infile) } - fmt.Fprintf(ftable, "type\tYYSTYPE\tstruct"); + fmt.Fprintf(ftable, "type\tYYSTYPE\tstruct") - level := 0; + level := 0 out: for { - c := getrune(finput); + c := getrune(finput) if c == EOF { error("EOF encountered while processing %%union") } - putrune(ftable, c); + putrune(ftable, c) switch c { case '\n': lineno++ @@ -1052,50 +1052,50 @@ out: if level == 0 { fmt.Fprintf(ftable, "\n\tyys\tint;") } - level++; + level++ case '}': - level--; + level-- if level == 0 { break out } } } - fmt.Fprintf(ftable, "\n"); - fmt.Fprintf(ftable, "var\tyylval\tYYSTYPE\n"); - fmt.Fprintf(ftable, "var\tYYVAL\tYYSTYPE\n"); - fmt.Fprintf(ftable, "var\tYYS\t[%v]YYSTYPE\n", stacksize); + fmt.Fprintf(ftable, "\n") + fmt.Fprintf(ftable, "var\tyylval\tYYSTYPE\n") + fmt.Fprintf(ftable, "var\tYYVAL\tYYSTYPE\n") + fmt.Fprintf(ftable, "var\tYYS\t[%v]YYSTYPE\n", stacksize) } // // saves code between %{ and %} // func cpycode() { - lno := lineno; + lno := lineno - c := getrune(finput); + c := getrune(finput) if c == '\n' { - c = getrune(finput); - lineno++; + c = getrune(finput) + lineno++ } if !lflag { fmt.Fprintf(ftable, "\n//line %v %v\n", lineno, infile) } for c != EOF { if c == '%' { - c = getrune(finput); + c = getrune(finput) if c == '}' { return } - putrune(ftable, '%'); + putrune(ftable, '%') } - putrune(ftable, c); + putrune(ftable, c) if c == '\n' { lineno++ } - c = getrune(finput); + c = getrune(finput) } - lineno = lno; - error("eof before %%}"); + lineno = lno + error("eof before %%}") } //func @@ -1171,50 +1171,50 @@ func cpycode() { // skipcom is called after reading a '/' // func skipcom() int { - var c int; + var c int - c = getrune(finput); + c = getrune(finput) if c == '/' { for c != EOF { if c == '\n' { return 1 } - c = getrune(finput); + c = getrune(finput) } - error("EOF inside comment"); - return 0; + error("EOF inside comment") + return 0 } if c != '*' { error("illegal comment") } - nl := 0; // lines skipped - c = getrune(finput); + nl := 0 // lines skipped + c = getrune(finput) l1: switch c { case '*': - c = getrune(finput); + c = getrune(finput) if c == '/' { break } - goto l1; + goto l1 case '\n': - nl++; - fallthrough; + nl++ + fallthrough default: - c = getrune(finput); - goto l1; + c = getrune(finput) + goto l1 } - return nl; + return nl } func dumpprod(curprod []int, max int) { - fmt.Printf("\n"); + fmt.Printf("\n") for i := 0; i < max; i++ { - p := curprod[i]; + p := curprod[i] if p < 0 { fmt.Printf("[%v] %v\n", i, p) } else { @@ -1232,77 +1232,77 @@ func cpyact(curprod []int, max int) { fmt.Fprintf(ftable, "\n//line %v %v\n", lineno, infile) } - lno := lineno; - brac := 0; + lno := lineno + brac := 0 loop: for { - c := getrune(finput); + c := getrune(finput) swt: switch c { case ';': if brac == 0 { - putrune(ftable, c); - return; + putrune(ftable, c) + return } case '{': if brac == 0 { } - putrune(ftable, '\t'); - brac++; + putrune(ftable, '\t') + brac++ case '$': - s := 1; - tok := -1; - c = getrune(finput); + s := 1 + tok := -1 + c = getrune(finput) // type description if c == '<' { - ungetrune(finput, c); + ungetrune(finput, c) if gettok() != TYPENAME { error("bad syntax on $<ident> clause") } - tok = numbval; - c = getrune(finput); + tok = numbval + c = getrune(finput) } if c == '$' { - fmt.Fprintf(ftable, "YYVAL"); + fmt.Fprintf(ftable, "YYVAL") // put out the proper tag... if ntypes != 0 { if tok < 0 { tok = fdtype(curprod[0]) } - fmt.Fprintf(ftable, ".%v", typeset[tok]); + fmt.Fprintf(ftable, ".%v", typeset[tok]) } - continue loop; + continue loop } if c == '-' { - s = -s; - c = getrune(finput); + s = -s + c = getrune(finput) } - j := 0; + j := 0 if isdigit(c) { for isdigit(c) { - j = j*10 + c - '0'; - c = getrune(finput); + j = j*10 + c - '0' + c = getrune(finput) } - ungetrune(finput, c); - j = j * s; + ungetrune(finput, c) + j = j * s if j >= max { error("Illegal use of $%v", j) } } else if isword(c) || c == '_' || c == '.' { // look for $name - ungetrune(finput, c); + ungetrune(finput, c) if gettok() != IDENTIFIER { error("$ must be followed by an identifier") } - tokn := chfind(2, tokname); - fnd := -1; - c = getrune(finput); + tokn := chfind(2, tokname) + fnd := -1 + c = getrune(finput) if c != '@' { ungetrune(finput, c) } else if gettok() != NUMBER { @@ -1312,7 +1312,7 @@ loop: } for j = 1; j < max; j++ { if tokn == curprod[j] { - fnd--; + fnd-- if fnd <= 0 { break } @@ -1322,14 +1322,14 @@ loop: error("$name or $name@number not found") } } else { - putrune(ftable, '$'); + putrune(ftable, '$') if s < 0 { putrune(ftable, '-') } - ungetrune(finput, c); - continue loop; + ungetrune(finput, c) + continue loop } - fmt.Fprintf(ftable, "YYS[yypt-%v]", max-j-1); + fmt.Fprintf(ftable, "YYS[yypt-%v]", max-j-1) // put out the proper tag if ntypes != 0 { @@ -1339,41 +1339,41 @@ loop: if tok < 0 { tok = fdtype(curprod[j]) } - fmt.Fprintf(ftable, ".%v", typeset[tok]); + fmt.Fprintf(ftable, ".%v", typeset[tok]) } - continue loop; + continue loop case '}': - brac--; + brac-- if brac != 0 { break } - putrune(ftable, c); - return; + putrune(ftable, c) + return case '/': // a comment - putrune(ftable, c); - c = getrune(finput); + putrune(ftable, c) + c = getrune(finput) for c != EOF { if c == '\n' { - lineno++; - break swt; + lineno++ + break swt } - putrune(ftable, c); - c = getrune(finput); + putrune(ftable, c) + c = getrune(finput) } - error("EOF inside comment"); + error("EOF inside comment") case '\'', '"': // character string or constant - match := c; - putrune(ftable, c); - c = getrune(finput); + match := c + putrune(ftable, c) + c = getrune(finput) for c != EOF { if c == '\\' { - putrune(ftable, c); - c = getrune(finput); + putrune(ftable, c) + c = getrune(finput) if c == '\n' { lineno++ } @@ -1383,43 +1383,43 @@ loop: if c == '\n' { error("newline in string or char const") } - putrune(ftable, c); - c = getrune(finput); + putrune(ftable, c) + c = getrune(finput) } - error("EOF in string or character constant"); + error("EOF in string or character constant") case EOF: - lineno = lno; - error("action does not terminate"); + lineno = lno + error("action does not terminate") case '\n': lineno++ } - putrune(ftable, c); + putrune(ftable, c) } } func openup() { - infile = flag.Arg(0); - finput = open(infile); + infile = flag.Arg(0) + finput = open(infile) if finput == nil { error("cannot open %v", infile) } - foutput = nil; + foutput = nil if vflag != "" { - foutput = create(vflag, 0666); + foutput = create(vflag, 0666) if foutput == nil { error("can't create file %v", vflag) } } - ftable = nil; + ftable = nil if oflag == "" { oflag = "y.go" } - ftable = create(oflag, 0666); + ftable = create(oflag, 0666) if ftable == nil { error("can't create file %v", oflag) } @@ -1430,7 +1430,7 @@ func openup() { // return a pointer to the name of symbol i // func symnam(i int) string { - var s string; + var s string if i >= NTBASE { s = nontrst[i-NTBASE].name @@ -1440,7 +1440,7 @@ func symnam(i int) string { if s[0] == ' ' { s = s[1:] } - return s; + return s } // @@ -1458,8 +1458,8 @@ func aryfil(v []int, n, c int) { // the array pyield has the lists: the total size is only NPROD+1 // func cpres() { - pres = make([][][]int, nnonter+1); - curres := make([][]int, nprod); + pres = make([][][]int, nnonter+1) + curres := make([][]int, nprod) if false { for j := 0; j <= nnonter; j++ { @@ -1470,41 +1470,41 @@ func cpres() { } } - fatfl = 0; // make undefined symbols nonfatal + fatfl = 0 // make undefined symbols nonfatal for i := 0; i <= nnonter; i++ { - n := 0; - c := i + NTBASE; + n := 0 + c := i + NTBASE for j := 0; j < nprod; j++ { if prdptr[j][0] == c { - curres[n] = prdptr[j][1:]; - n++; + curres[n] = prdptr[j][1:] + n++ } } if n == 0 { - error("nonterminal %v not defined", nontrst[i].name); - continue; + error("nonterminal %v not defined", nontrst[i].name) + continue } - pres[i] = make([][]int, n); - copy(pres[i], curres); + pres[i] = make([][]int, n) + copy(pres[i], curres) } - fatfl = 1; + fatfl = 1 if nerrors != 0 { - summary(); - exit(1); + summary() + exit(1) } } func dumppres() { for i := 0; i <= nnonter; i++ { - print("nonterm %d\n", i); - curres := pres[i]; + print("nonterm %d\n", i) + curres := pres[i] for j := 0; j < len(curres); j++ { - print("\tproduction %d:", j); - prd := curres[j]; + print("\tproduction %d:", j) + prd := curres[j] for k := 0; k < len(prd); k++ { print(" %d", prd[k]) } - print("\n"); + print("\n") } } } @@ -1514,24 +1514,24 @@ func dumppres() { // also, look for nonterminals which don't derive any token strings // func cempty() { - var i, p, np int; - var prd []int; + var i, p, np int + var prd []int - pempty = make([]int, nnonter+1); + pempty = make([]int, nnonter+1) // first, use the array pempty to detect productions that can never be reduced // set pempty to WHONOWS - aryfil(pempty, nnonter+1, WHOKNOWS); + aryfil(pempty, nnonter+1, WHOKNOWS) // now, look at productions, marking nonterminals which derive something more: for { for i = 0; i < nprod; i++ { - prd = prdptr[i]; + prd = prdptr[i] if pempty[prd[0]-NTBASE] != 0 { continue } - np = len(prd) - 1; + np = len(prd) - 1 for p = 1; p < np; p++ { if prd[p] >= NTBASE && pempty[prd[p]-NTBASE] == WHOKNOWS { break @@ -1539,11 +1539,11 @@ more: } // production can be derived if p == np { - pempty[prd[0]-NTBASE] = OK; - continue more; + pempty[prd[0]-NTBASE] = OK + continue more } } - break; + break } // now, look at the nonterminals, to see if they are all OK @@ -1553,19 +1553,19 @@ more: continue } if pempty[i] != OK { - fatfl = 0; - error("nonterminal " + nontrst[i].name + " never derives any token string"); + fatfl = 0 + error("nonterminal " + nontrst[i].name + " never derives any token string") } } if nerrors != 0 { - summary(); - exit(1); + summary() + exit(1) } // now, compute the pempty array, to see which nonterminals derive the empty string // set pempty to WHOKNOWS - aryfil(pempty, nnonter+1, WHOKNOWS); + aryfil(pempty, nnonter+1, WHOKNOWS) // loop as long as we keep finding empty nonterminals @@ -1574,11 +1574,11 @@ again: next: for i = 1; i < nprod; i++ { // not known to be empty - prd = prdptr[i]; + prd = prdptr[i] if pempty[prd[0]-NTBASE] != WHOKNOWS { continue } - np = len(prd) - 1; + np = len(prd) - 1 for p = 1; p < np; p++ { if prd[p] < NTBASE || pempty[prd[p]-NTBASE] != EMPTY { continue next @@ -1586,12 +1586,12 @@ again: } // we have a nontrivially empty nonterminal - pempty[prd[0]-NTBASE] = EMPTY; + pempty[prd[0]-NTBASE] = EMPTY // got one ... try for another - continue again; + continue again } - return; + return } } @@ -1607,27 +1607,27 @@ func dumpempty() { // compute an array with the first of nonterminals // func cpfir() { - var s, n, p, np, ch, i int; - var curres [][]int; - var prd []int; + var s, n, p, np, ch, i int + var curres [][]int + var prd []int - wsets = make([]Wset, nnonter+WSETINC); - pfirst = make([]Lkset, nnonter+1); + wsets = make([]Wset, nnonter+WSETINC) + pfirst = make([]Lkset, nnonter+1) for i = 0; i <= nnonter; i++ { - wsets[i].ws = mkset(); - pfirst[i] = mkset(); - curres = pres[i]; - n = len(curres); + wsets[i].ws = mkset() + pfirst[i] = mkset() + curres = pres[i] + n = len(curres) // initially fill the sets for s = 0; s < n; s++ { - prd = curres[s]; - np = len(prd) - 1; + prd = curres[s] + np = len(prd) - 1 for p = 0; p < np; p++ { - ch = prd[p]; + ch = prd[p] if ch < NTBASE { - setbit(pfirst[i], ch); - break; + setbit(pfirst[i], ch) + break } if pempty[ch-NTBASE] == 0 { break @@ -1637,21 +1637,21 @@ func cpfir() { } // now, reflect transitivity - changes := 1; + changes := 1 for changes != 0 { - changes = 0; + changes = 0 for i = 0; i <= nnonter; i++ { - curres = pres[i]; - n = len(curres); + curres = pres[i] + n = len(curres) for s = 0; s < n; s++ { - prd = curres[s]; - np = len(prd) - 1; + prd = curres[s] + np = len(prd) - 1 for p = 0; p < np; p++ { - ch = prd[p] - NTBASE; + ch = prd[p] - NTBASE if ch < 0 { break } - changes |= setunion(pfirst[i], pfirst[ch]); + changes |= setunion(pfirst[i], pfirst[ch]) if pempty[ch] == 0 { break } @@ -1676,20 +1676,20 @@ func cpfir() { // func stagen() { // initialize - nstate = 0; - tstates = make([]int, ntokens+1); // states generated by terminal gotos - ntstates = make([]int, nnonter+1); // states generated by nonterminal gotos - amem = make([]int, ACTSIZE); - memp = 0; - - clset = mkset(); - pstate[0] = 0; - pstate[1] = 0; - aryfil(clset, tbitset, 0); - putitem(Pitem{prdptr[0], 0, 0, 0}, clset); - tystate[0] = MUSTDO; - nstate = 1; - pstate[2] = pstate[1]; + nstate = 0 + tstates = make([]int, ntokens+1) // states generated by terminal gotos + ntstates = make([]int, nnonter+1) // states generated by nonterminal gotos + amem = make([]int, ACTSIZE) + memp = 0 + + clset = mkset() + pstate[0] = 0 + pstate[1] = 0 + aryfil(clset, tbitset, 0) + putitem(Pitem{prdptr[0], 0, 0, 0}, clset) + tystate[0] = MUSTDO + nstate = 1 + pstate[2] = pstate[1] // // now, the main state generation loop @@ -1698,67 +1698,67 @@ func stagen() { // could be sped up a lot by remembering // results of the first pass rather than recomputing // - first := 1; + first := 1 for more := 1; more != 0; first = 0 { - more = 0; + more = 0 for i := 0; i < nstate; i++ { if tystate[i] != MUSTDO { continue } - tystate[i] = DONE; - aryfil(temp1, nnonter+1, 0); + tystate[i] = DONE + aryfil(temp1, nnonter+1, 0) // take state i, close it, and do gotos - closure(i); + closure(i) // generate goto's for p := 0; p < cwp; p++ { - pi := wsets[p]; + pi := wsets[p] if pi.flag != 0 { continue } - wsets[p].flag = 1; - c := pi.pitem.first; + wsets[p].flag = 1 + c := pi.pitem.first if c <= 1 { if pstate[i+1]-pstate[i] <= p { tystate[i] = MUSTLOOKAHEAD } - continue; + continue } // do a goto on c - putitem(wsets[p].pitem, wsets[p].ws); + putitem(wsets[p].pitem, wsets[p].ws) for q := p + 1; q < cwp; q++ { // this item contributes to the goto if c == wsets[q].pitem.first { - putitem(wsets[q].pitem, wsets[q].ws); - wsets[q].flag = 1; + putitem(wsets[q].pitem, wsets[q].ws) + wsets[q].flag = 1 } } if c < NTBASE { - state(c) // register new state + state(c) // register new state } else { temp1[c-NTBASE] = state(c) } } if gsdebug != 0 && foutput != nil { - fmt.Fprintf(foutput, "%v: ", i); + fmt.Fprintf(foutput, "%v: ", i) for j := 0; j <= nnonter; j++ { if temp1[j] != 0 { fmt.Fprintf(foutput, "%v %v,", nontrst[j].name, temp1[j]) } } - fmt.Fprintf(foutput, "\n"); + fmt.Fprintf(foutput, "\n") } if first != 0 { indgo[i] = apack(temp1[1:], nnonter-1) - 1 } - more++; + more++ } } } @@ -1767,67 +1767,67 @@ func stagen() { // generate the closure of state i // func closure(i int) { - zzclose++; + zzclose++ // first, copy kernel of state i to wsets - cwp = 0; - q := pstate[i+1]; + cwp = 0 + q := pstate[i+1] for p := pstate[i]; p < q; p++ { - wsets[cwp].pitem = statemem[p].pitem; - wsets[cwp].flag = 1; // this item must get closed - copy(wsets[cwp].ws, statemem[p].look); - cwp++; + wsets[cwp].pitem = statemem[p].pitem + wsets[cwp].flag = 1 // this item must get closed + copy(wsets[cwp].ws, statemem[p].look) + cwp++ } // now, go through the loop, closing each item - work := 1; + work := 1 for work != 0 { - work = 0; + work = 0 for u := 0; u < cwp; u++ { if wsets[u].flag == 0 { continue } // dot is before c - c := wsets[u].pitem.first; + c := wsets[u].pitem.first if c < NTBASE { - wsets[u].flag = 0; + wsets[u].flag = 0 // only interesting case is where . is before nonterminal - continue; + continue } // compute the lookahead - aryfil(clset, tbitset, 0); + aryfil(clset, tbitset, 0) // find items involving c for v := u; v < cwp; v++ { if wsets[v].flag != 1 || wsets[v].pitem.first != c { continue } - pi := wsets[v].pitem.prod; - ipi := wsets[v].pitem.off + 1; + pi := wsets[v].pitem.prod + ipi := wsets[v].pitem.off + 1 - wsets[v].flag = 0; + wsets[v].flag = 0 if nolook != 0 { continue } - ch := pi[ipi]; - ipi++; + ch := pi[ipi] + ipi++ for ch > 0 { // terminal symbol if ch < NTBASE { - setbit(clset, ch); - break; + setbit(clset, ch) + break } // nonterminal symbol - setunion(clset, pfirst[ch-NTBASE]); + setunion(clset, pfirst[ch-NTBASE]) if pempty[ch-NTBASE] == 0 { break } - ch = pi[ipi]; - ipi++; + ch = pi[ipi] + ipi++ } if ch <= 0 { setunion(clset, wsets[v].ws) @@ -1837,13 +1837,13 @@ func closure(i int) { // // now loop over productions derived from c // - curres := pres[c-NTBASE]; - n := len(curres); + curres := pres[c-NTBASE] + n := len(curres) nexts: // initially fill the sets for s := 0; s < n; s++ { - prd := curres[s]; + prd := curres[s] // // put these items into the closure @@ -1855,42 +1855,42 @@ func closure(i int) { aryeq(wsets[v].pitem.prod, prd) != 0 { if nolook == 0 && setunion(wsets[v].ws, clset) != 0 { - wsets[v].flag = 1; - work = 1; + wsets[v].flag = 1 + work = 1 } - continue nexts; + continue nexts } } // not there; make a new entry if cwp >= len(wsets) { - awsets := make([]Wset, cwp+WSETINC); - copy(awsets, wsets); - wsets = awsets; + awsets := make([]Wset, cwp+WSETINC) + copy(awsets, wsets) + wsets = awsets } - wsets[cwp].pitem = Pitem{prd, 0, prd[0], -prd[len(prd)-1]}; - wsets[cwp].flag = 1; - wsets[cwp].ws = mkset(); + wsets[cwp].pitem = Pitem{prd, 0, prd[0], -prd[len(prd)-1]} + wsets[cwp].flag = 1 + wsets[cwp].ws = mkset() if nolook == 0 { - work = 1; - copy(wsets[cwp].ws, clset); + work = 1 + copy(wsets[cwp].ws, clset) } - cwp++; + cwp++ } } } // have computed closure; flags are reset; return if cldebug != 0 && foutput != nil { - fmt.Fprintf(foutput, "\nState %v, nolook = %v\n", i, nolook); + fmt.Fprintf(foutput, "\nState %v, nolook = %v\n", i, nolook) for u := 0; u < cwp; u++ { if wsets[u].flag != 0 { fmt.Fprintf(foutput, "flag set\n") } - wsets[u].flag = 0; - fmt.Fprintf(foutput, "\t%v", writem(wsets[u].pitem)); - prlook(wsets[u].ws); - fmt.Fprintf(foutput, "\n"); + wsets[u].flag = 0 + fmt.Fprintf(foutput, "\t%v", writem(wsets[u].pitem)) + prlook(wsets[u].ws) + fmt.Fprintf(foutput, "\n") } } } @@ -1899,32 +1899,32 @@ func closure(i int) { // sorts last state,and sees if it equals earlier ones. returns state number // func state(c int) int { - zzstate++; - p1 := pstate[nstate]; - p2 := pstate[nstate+1]; + zzstate++ + p1 := pstate[nstate] + p2 := pstate[nstate+1] if p1 == p2 { - return 0 // null state + return 0 // null state } // sort the items - var k, l int; - for k = p1 + 1; k < p2; k++ { // make k the biggest + var k, l int + for k = p1 + 1; k < p2; k++ { // make k the biggest for l = k; l > p1; l-- { if statemem[l].pitem.prodno < statemem[l-1].pitem.prodno || statemem[l].pitem.prodno == statemem[l-1].pitem.prodno && statemem[l].pitem.off < statemem[l-1].pitem.off { - s := statemem[l]; - statemem[l] = statemem[l-1]; - statemem[l-1] = s; + s := statemem[l] + statemem[l] = statemem[l-1] + statemem[l-1] = s } else { break } } } - size1 := p2 - p1; // size of state + size1 := p2 - p1 // size of state - var i int; + var i int if c >= NTBASE { i = ntstates[c-NTBASE] } else { @@ -1934,116 +1934,116 @@ func state(c int) int { look: for ; i != 0; i = mstates[i] { // get ith state - q1 := pstate[i]; - q2 := pstate[i+1]; - size2 := q2 - q1; + q1 := pstate[i] + q2 := pstate[i+1] + size2 := q2 - q1 if size1 != size2 { continue } - k = p1; + k = p1 for l = q1; l < q2; l++ { if aryeq(statemem[l].pitem.prod, statemem[k].pitem.prod) == 0 || statemem[l].pitem.off != statemem[k].pitem.off { continue look } - k++; + k++ } // found it - pstate[nstate+1] = pstate[nstate]; // delete last state + pstate[nstate+1] = pstate[nstate] // delete last state // fix up lookaheads if nolook != 0 { return i } - k = p1; + k = p1 for l = q1; l < q2; l++ { if setunion(statemem[l].look, statemem[k].look) != 0 { tystate[i] = MUSTDO } - k++; + k++ } - return i; + return i } // state is new - zznewstate++; + zznewstate++ if nolook != 0 { error("yacc state/nolook error") } - pstate[nstate+2] = p2; + pstate[nstate+2] = p2 if nstate+1 >= NSTATES { error("too many states") } if c >= NTBASE { - mstates[nstate] = ntstates[c-NTBASE]; - ntstates[c-NTBASE] = nstate; + mstates[nstate] = ntstates[c-NTBASE] + ntstates[c-NTBASE] = nstate } else { - mstates[nstate] = tstates[c]; - tstates[c] = nstate; + mstates[nstate] = tstates[c] + tstates[c] = nstate } - tystate[nstate] = MUSTDO; - nstate++; - return nstate - 1; + tystate[nstate] = MUSTDO + nstate++ + return nstate - 1 } func putitem(p Pitem, set Lkset) { - p.off++; - p.first = p.prod[p.off]; + p.off++ + p.first = p.prod[p.off] if pidebug != 0 && foutput != nil { fmt.Fprintf(foutput, "putitem(%v), state %v\n", writem(p), nstate) } - j := pstate[nstate+1]; + j := pstate[nstate+1] if j >= len(statemem) { - asm := make([]Item, j+STATEINC); - copy(asm, statemem); - statemem = asm; + asm := make([]Item, j+STATEINC) + copy(asm, statemem) + statemem = asm } - statemem[j].pitem = p; + statemem[j].pitem = p if nolook == 0 { - s := mkset(); - copy(s, set); - statemem[j].look = s; + s := mkset() + copy(s, set) + statemem[j].look = s } - j++; - pstate[nstate+1] = j; + j++ + pstate[nstate+1] = j } // // creates output string for item pointed to by pp // func writem(pp Pitem) string { - var i int; + var i int - p := pp.prod; - q := chcopy(nontrst[prdptr[pp.prodno][0]-NTBASE].name) + ": "; - npi := pp.off; + p := pp.prod + q := chcopy(nontrst[prdptr[pp.prodno][0]-NTBASE].name) + ": " + npi := pp.off - pi := aryeq(p, prdptr[pp.prodno]); + pi := aryeq(p, prdptr[pp.prodno]) for { - c := ' '; + c := ' ' if pi == npi { c = '.' } - q += string(c); + q += string(c) - i = p[pi]; - pi++; + i = p[pi] + pi++ if i <= 0 { break } - q += chcopy(symnam(i)); + q += chcopy(symnam(i)) } // an item calling for a reduction - i = p[npi]; + i = p[npi] if i < 0 { q += fmt.Sprintf(" (%v)", -i) } - return q; + return q } // @@ -2055,8 +2055,8 @@ func apack(p []int, n int) int { // we will only look at entries known to be there... // eliminate leading and trailing 0's // - off := 0; - pp := 0; + off := 0 + pp := 0 for ; pp <= n && p[pp] == 0; pp++ { off-- } @@ -2067,84 +2067,84 @@ func apack(p []int, n int) int { } for ; n > pp && p[n] == 0; n-- { } - p = p[pp : n+1]; + p = p[pp : n+1] // now, find a place for the elements from p to q, inclusive - r := len(amem) - len(p); + r := len(amem) - len(p) nextk: for rr := 0; rr <= r; rr++ { - qq := rr; + qq := rr for pp = 0; pp < len(p); pp++ { if p[pp] != 0 { if p[pp] != amem[qq] && amem[qq] != 0 { continue nextk } } - qq++; + qq++ } // we have found an acceptable k if pkdebug != 0 && foutput != nil { fmt.Fprintf(foutput, "off = %v, k = %v\n", off+rr, rr) } - qq = rr; + qq = rr for pp = 0; pp < len(p); pp++ { if p[pp] != 0 { if qq > memp { memp = qq } - amem[qq] = p[pp]; + amem[qq] = p[pp] } - qq++; + qq++ } if pkdebug != 0 && foutput != nil { for pp = 0; pp <= memp; pp += 10 { - fmt.Fprintf(foutput, "\n"); + fmt.Fprintf(foutput, "\n") for qq = pp; qq <= pp+9; qq++ { fmt.Fprintf(foutput, "%v ", amem[qq]) } - fmt.Fprintf(foutput, "\n"); + fmt.Fprintf(foutput, "\n") } } - return off + rr; + return off + rr } - error("no space in action table"); - return 0; + error("no space in action table") + return 0 } // // print the output for the states // func output() { - var c, u, v int; + var c, u, v int - fmt.Fprintf(ftable, "var\tYYEXCA = []int {\n"); + fmt.Fprintf(ftable, "var\tYYEXCA = []int {\n") - noset := mkset(); + noset := mkset() // output the stuff for state i for i := 0; i < nstate; i++ { - nolook = 0; + nolook = 0 if tystate[i] != MUSTLOOKAHEAD { nolook = 1 } - closure(i); + closure(i) // output actions - nolook = 1; - aryfil(temp1, ntokens+nnonter+1, 0); + nolook = 1 + aryfil(temp1, ntokens+nnonter+1, 0) for u = 0; u < cwp; u++ { - c = wsets[u].pitem.first; + c = wsets[u].pitem.first if c > 1 && c < NTBASE && temp1[c] == 0 { for v = u; v < cwp; v++ { if c == wsets[v].pitem.first { putitem(wsets[v].pitem, noset) } } - temp1[c] = state(c); + temp1[c] = state(c) } else if c > NTBASE { - c -= NTBASE; + c -= NTBASE if temp1[c+ntokens] == 0 { temp1[c+ntokens] = amem[indgo[i]+c] } @@ -2155,23 +2155,23 @@ func output() { } // now, we have the shifts; look at the reductions - lastred = 0; + lastred = 0 for u = 0; u < cwp; u++ { - c = wsets[u].pitem.first; + c = wsets[u].pitem.first // reduction if c > 0 { continue } - lastred = -c; - us := wsets[u].ws; + lastred = -c + us := wsets[u].ws for k := 0; k <= ntokens; k++ { if bitset(us, k) == 0 { continue } if temp1[k] == 0 { temp1[k] = c - } else if temp1[k] < 0 { // reduce/reduce conflict + } else if temp1[k] < 0 { // reduce/reduce conflict if foutput != nil { fmt.Fprintf(foutput, "\n %v: reduce/reduce conflict (red'ns "+ @@ -2181,21 +2181,21 @@ func output() { if -temp1[k] > lastred { temp1[k] = -lastred } - zzrrconf++; + zzrrconf++ } else { // potential shift/reduce conflict precftn(lastred, k, i) } } } - wract(i); + wract(i) } - fmt.Fprintf(ftable, "}\n"); - fmt.Fprintf(ftable, "const\tYYNPROD\t= %v\n", nprod); - fmt.Fprintf(ftable, "const\tYYPRIVATE\t= %v\n", PRIVATE); - fmt.Fprintf(ftable, "var\tYYTOKENNAMES []string\n"); - fmt.Fprintf(ftable, "var\tYYSTATES []string\n"); + fmt.Fprintf(ftable, "}\n") + fmt.Fprintf(ftable, "const\tYYNPROD\t= %v\n", nprod) + fmt.Fprintf(ftable, "const\tYYPRIVATE\t= %v\n", PRIVATE) + fmt.Fprintf(ftable, "var\tYYTOKENNAMES []string\n") + fmt.Fprintf(ftable, "var\tYYSTATES []string\n") } // @@ -2205,10 +2205,10 @@ func output() { // temp1[t] is changed to reflect the action // func precftn(r, t, s int) { - var action int; + var action int - lp := levprd[r]; - lt := toklev[t]; + lp := levprd[r] + lt := toklev[t] if PLEVEL(lt) == 0 || PLEVEL(lp) == 0 { // conflict if foutput != nil { @@ -2216,20 +2216,20 @@ func precftn(r, t, s int) { "\n%v: shift/reduce conflict (shift %v(%v), red'n %v(%v)) on %v", s, temp1[t], PLEVEL(lt), r, PLEVEL(lp), symnam(t)) } - zzsrconf++; - return; + zzsrconf++ + return } if PLEVEL(lt) == PLEVEL(lp) { action = ASSOC(lt) } else if PLEVEL(lt) > PLEVEL(lp) { - action = RASC // shift + action = RASC // shift } else { action = LASC - } // reduce + } // reduce switch action { - case BASC: // error action + case BASC: // error action temp1[t] = ERRCODE - case LASC: // reduce + case LASC: // reduce temp1[t] = -r } } @@ -2239,11 +2239,11 @@ func precftn(r, t, s int) { // temp1 has the actions, lastred the default // func wract(i int) { - var p, p1 int; + var p, p1 int // find the best choice for lastred - lastred = 0; - ntimes := 0; + lastred = 0 + ntimes := 0 for j := 0; j <= ntokens; j++ { if temp1[j] >= 0 { continue @@ -2252,17 +2252,17 @@ func wract(i int) { continue } // count the number of appearances of temp1[j] - count := 0; - tred := -temp1[j]; - levprd[tred] |= REDFLAG; + count := 0 + tred := -temp1[j] + levprd[tred] |= REDFLAG for p = 0; p <= ntokens; p++ { if temp1[p]+tred == 0 { count++ } } if count > ntimes { - lastred = tred; - ntimes = count; + lastred = tred + ntimes = count } } @@ -2276,25 +2276,25 @@ func wract(i int) { // clear out entries in temp1 which equal lastred // count entries in optst table - n := 0; + n := 0 for p = 0; p <= ntokens; p++ { - p1 = temp1[p]; + p1 = temp1[p] if p1+lastred == 0 { - temp1[p] = 0; - p1 = 0; + temp1[p] = 0 + p1 = 0 } if p1 > 0 && p1 != ACCEPTCODE && p1 != ERRCODE { n++ } } - wrstate(i); - defact[i] = lastred; - flag := 0; - os := make([]int, n*2); - n = 0; + wrstate(i) + defact[i] = lastred + flag := 0 + os := make([]int, n*2) + n = 0 for p = 0; p <= ntokens; p++ { - p1 = temp1[p]; + p1 = temp1[p] if p1 != 0 { if p1 < 0 { p1 = -p1 @@ -2303,40 +2303,40 @@ func wract(i int) { } else if p1 == ERRCODE { p1 = 0 } else { - os[n] = p; - n++; - os[n] = p1; - n++; - zzacent++; - continue; + os[n] = p + n++ + os[n] = p1 + n++ + zzacent++ + continue } if flag == 0 { fmt.Fprintf(ftable, "-1, %v,\n", i) } - flag++; - fmt.Fprintf(ftable, "\t%v, %v,\n", p, p1); - zzexcp++; + flag++ + fmt.Fprintf(ftable, "\t%v, %v,\n", p, p1) + zzexcp++ } } if flag != 0 { - defact[i] = -2; - fmt.Fprintf(ftable, "\t-2, %v,\n", lastred); + defact[i] = -2 + fmt.Fprintf(ftable, "\t-2, %v,\n", lastred) } - optst[i] = os; + optst[i] = os } // // writes state i // func wrstate(i int) { - var j0, j1, u int; - var pp, qq int; + var j0, j1, u int + var pp, qq int if foutput == nil { return } - fmt.Fprintf(foutput, "\nstate %v\n", i); - qq = pstate[i+1]; + fmt.Fprintf(foutput, "\nstate %v\n", i) + qq = pstate[i+1] for pp = pstate[i]; pp < qq; pp++ { fmt.Fprintf(foutput, "\t%v\n", writem(statemem[pp].pitem)) } @@ -2351,9 +2351,9 @@ func wrstate(i int) { // check for state equal to another for j0 = 0; j0 <= ntokens; j0++ { - j1 = temp1[j0]; + j1 = temp1[j0] if j1 != 0 { - fmt.Fprintf(foutput, "\n\t%v ", symnam(j0)); + fmt.Fprintf(foutput, "\n\t%v ", symnam(j0)) // shift, error, or accept if j1 > 0 { @@ -2379,9 +2379,9 @@ func wrstate(i int) { } // now, output nonterminal actions - j1 = ntokens; + j1 = ntokens for j0 = 1; j0 <= nnonter; j0++ { - j1++; + j1++ if temp1[j1] != 0 { fmt.Fprintf(foutput, "\t%v goto %v\n", symnam(j0+NTBASE), temp1[j1]) } @@ -2393,11 +2393,11 @@ func wrstate(i int) { // func go2out() { for i := 1; i <= nnonter; i++ { - go2gen(i); + go2gen(i) // find the best one to make default - best := -1; - times := 0; + best := -1 + times := 0 // is j the most frequent for j := 0; j < nstate; j++ { @@ -2409,36 +2409,36 @@ func go2out() { } // is tystate[j] the most frequent - count := 0; - cbest := tystate[j]; + count := 0 + cbest := tystate[j] for k := j; k < nstate; k++ { if tystate[k] == cbest { count++ } } if count > times { - best = cbest; - times = count; + best = cbest + times = count } } // best is now the default entry - zzgobest += times - 1; - n := 0; + zzgobest += times - 1 + n := 0 for j := 0; j < nstate; j++ { if tystate[j] != 0 && tystate[j] != best { n++ } } - goent := make([]int, 2*n+1); - n = 0; + goent := make([]int, 2*n+1) + n = 0 for j := 0; j < nstate; j++ { if tystate[j] != 0 && tystate[j] != best { - goent[n] = j; - n++; - goent[n] = tystate[j]; - n++; - zzgoent++; + goent[n] = j + n++ + goent[n] = tystate[j] + n++ + zzgoent++ } } @@ -2447,9 +2447,9 @@ func go2out() { best = 0 } - zzgoent++; - goent[n] = best; - yypgo[i] = goent; + zzgoent++ + goent[n] = best + yypgo[i] = goent } } @@ -2457,23 +2457,23 @@ func go2out() { // output the gotos for nonterminal c // func go2gen(c int) { - var i, cc, p, q int; + var i, cc, p, q int // first, find nonterminals with gotos on c - aryfil(temp1, nnonter+1, 0); - temp1[c] = 1; - work := 1; + aryfil(temp1, nnonter+1, 0) + temp1[c] = 1 + work := 1 for work != 0 { - work = 0; + work = 0 for i = 0; i < nprod; i++ { // cc is a nonterminal with a goto on c - cc = prdptr[i][1] - NTBASE; + cc = prdptr[i][1] - NTBASE if cc >= 0 && temp1[cc] != 0 { // thus, the left side of production i does too - cc = prdptr[i][0] - NTBASE; + cc = prdptr[i][0] - NTBASE if temp1[cc] == 0 { - work = 1; - temp1[cc] = 1; + work = 1 + temp1[cc] = 1 } } } @@ -2481,26 +2481,26 @@ func go2gen(c int) { // now, we have temp1[c] = 1 if a goto on c in closure of cc if g2debug != 0 && foutput != nil { - fmt.Fprintf(foutput, "%v: gotos on ", nontrst[c].name); + fmt.Fprintf(foutput, "%v: gotos on ", nontrst[c].name) for i = 0; i <= nnonter; i++ { if temp1[i] != 0 { fmt.Fprintf(foutput, "%v ", nontrst[i].name) } } - fmt.Fprintf(foutput, "\n"); + fmt.Fprintf(foutput, "\n") } // now, go through and put gotos into tystate - aryfil(tystate, nstate, 0); + aryfil(tystate, nstate, 0) for i = 0; i < nstate; i++ { - q = pstate[i+1]; + q = pstate[i+1] for p = pstate[i]; p < q; p++ { - cc = statemem[p].pitem.first; + cc = statemem[p].pitem.first if cc >= NTBASE { // goto on c is possible if temp1[cc-NTBASE] != 0 { - tystate[i] = amem[indgo[i]+c]; - break; + tystate[i] = amem[indgo[i]+c] + break } } } @@ -2514,18 +2514,18 @@ func go2gen(c int) { // derived by productions in levprd. // func hideprod() { - nred := 0; - levprd[0] = 0; + nred := 0 + levprd[0] = 0 for i := 1; i < nprod; i++ { if (levprd[i] & REDFLAG) == 0 { if foutput != nil { fmt.Fprintf(foutput, "Rule not reduced: %v\n", writem(Pitem{prdptr[i], 0, 0, i})) } - fmt.Printf("rule %v never reduced\n", writem(Pitem{prdptr[i], 0, 0, i})); - nred++; + fmt.Printf("rule %v never reduced\n", writem(Pitem{prdptr[i], 0, 0, i})) + nred++ } - levprd[i] = prdptr[i][0] - NTBASE; + levprd[i] = prdptr[i][0] - NTBASE } if nred != 0 { fmt.Printf("%v rules never reduced\n", nred) @@ -2533,18 +2533,18 @@ func hideprod() { } func callopt() { - var j, k, p, q, i int; - var v []int; + var j, k, p, q, i int + var v []int - pgo = make([]int, nnonter+1); - pgo[0] = 0; - maxoff = 0; - maxspr = 0; + pgo = make([]int, nnonter+1) + pgo[0] = 0 + maxoff = 0 + maxspr = 0 for i = 0; i < nstate; i++ { - k = 32000; - j = 0; - v = optst[i]; - q = len(v); + k = 32000 + j = 0 + v = optst[i] + q = len(v) for p = 0; p < q; p += 2 { if v[p] > j { j = v[p] @@ -2562,28 +2562,28 @@ func callopt() { maxoff = k } } - tystate[i] = q + 2*j; + tystate[i] = q + 2*j if j > maxspr { maxspr = j } } // initialize ggreed table - ggreed = make([]int, nnonter+1); + ggreed = make([]int, nnonter+1) for i = 1; i <= nnonter; i++ { - ggreed[i] = 1; - j = 0; + ggreed[i] = 1 + j = 0 // minimum entry index is always 0 - v = yypgo[i]; - q = len(v) - 1; + v = yypgo[i] + q = len(v) - 1 for p = 0; p < q; p += 2 { - ggreed[i] += 2; + ggreed[i] += 2 if v[p] > j { j = v[p] } } - ggreed[i] = ggreed[i] + 2*j; + ggreed[i] = ggreed[i] + 2*j if j > maxoff { maxoff = j } @@ -2593,71 +2593,71 @@ func callopt() { for i = 0; i < ACTSIZE; i++ { amem[i] = 0 } - maxa = 0; + maxa = 0 for i = 0; i < nstate; i++ { if tystate[i] == 0 && adb > 1 { fmt.Fprintf(ftable, "State %v: null\n", i) } - indgo[i] = YYFLAG; + indgo[i] = YYFLAG } - i = nxti(); + i = nxti() for i != NOMORE { if i >= 0 { stin(i) } else { gin(-i) } - i = nxti(); + i = nxti() } // print amem array if adb > 2 { for p = 0; p <= maxa; p += 10 { - fmt.Fprintf(ftable, "%v ", p); + fmt.Fprintf(ftable, "%v ", p) for i = 0; i < 10; i++ { fmt.Fprintf(ftable, "%v ", amem[p+i]) } - putrune(ftable, '\n'); + putrune(ftable, '\n') } } - aoutput(); - osummary(); + aoutput() + osummary() } // // finds the next i // func nxti() int { - max := 0; - maxi := 0; + max := 0 + maxi := 0 for i := 1; i <= nnonter; i++ { if ggreed[i] >= max { - max = ggreed[i]; - maxi = -i; + max = ggreed[i] + maxi = -i } } for i := 0; i < nstate; i++ { if tystate[i] >= max { - max = tystate[i]; - maxi = i; + max = tystate[i] + maxi = i } } if max == 0 { return NOMORE } - return maxi; + return maxi } func gin(i int) { - var s int; + var s int // enter gotos on nonterminal i into array amem - ggreed[i] = 0; + ggreed[i] = 0 - q := yypgo[i]; - nq := len(q) - 1; + q := yypgo[i] + nq := len(q) - 1 // now, find amem place for it nextgp: @@ -2666,9 +2666,9 @@ nextgp: continue } for r := 0; r < nq; r += 2 { - s = p + q[r] + 1; + s = p + q[r] + 1 if s > maxa { - maxa = s; + maxa = s if maxa >= ACTSIZE { error("a array overflow") } @@ -2679,38 +2679,38 @@ nextgp: } // we have found amem spot - amem[p] = q[nq]; + amem[p] = q[nq] if p > maxa { maxa = p } for r := 0; r < nq; r += 2 { - s = p + q[r] + 1; - amem[s] = q[r+1]; + s = p + q[r] + 1 + amem[s] = q[r+1] } - pgo[i] = p; + pgo[i] = p if adb > 1 { fmt.Fprintf(ftable, "Nonterminal %v, entry at %v\n", i, pgo[i]) } - return; + return } - error("cannot place goto %v\n", i); + error("cannot place goto %v\n", i) } func stin(i int) { - var s int; + var s int - tystate[i] = 0; + tystate[i] = 0 // enter state i into the amem array - q := optst[i]; - nq := len(q); + q := optst[i] + nq := len(q) nextn: // find an acceptable place for n := -maxoff; n < ACTSIZE; n++ { - flag := 0; + flag := 0 for r := 0; r < nq; r += 2 { - s = q[r] + n; + s = q[r] + n if s < 0 || s > ACTSIZE { continue nextn } @@ -2732,37 +2732,37 @@ nextn: if nq == len(optst[j]) { // states are equal - indgo[i] = n; + indgo[i] = n if adb > 1 { fmt.Fprintf(ftable, "State %v: entry at"+ "%v equals state %v\n", i, n, j) } - return; + return } // we have some disagreement - continue nextn; + continue nextn } } for r := 0; r < nq; r += 2 { - s = q[r] + n; + s = q[r] + n if s > maxa { maxa = s } if amem[s] != 0 && amem[s] != q[r+1] { error("clobber of a array, pos'n %v, by %v", s, q[r+1]) } - amem[s] = q[r+1]; + amem[s] = q[r+1] } - indgo[i] = n; + indgo[i] = n if adb > 1 { fmt.Fprintf(ftable, "State %v: entry at %v\n", i, indgo[i]) } - return; + return } - error("Error; failure to place state %v", i); + error("Error; failure to place state %v", i) } // @@ -2770,20 +2770,20 @@ nextn: // write out the optimized parser // func aoutput() { - fmt.Fprintf(ftable, "const\tYYLAST\t= %v\n", maxa+1); - arout("YYACT", amem, maxa+1); - arout("YYPACT", indgo, nstate); - arout("YYPGO", pgo, nnonter+1); + fmt.Fprintf(ftable, "const\tYYLAST\t= %v\n", maxa+1) + arout("YYACT", amem, maxa+1) + arout("YYPACT", indgo, nstate) + arout("YYPGO", pgo, nnonter+1) } // // put out other arrays, copy the parsers // func others() { - var i, j int; + var i, j int - arout("YYR1", levprd, nprod); - aryfil(temp1, nprod, 0); + arout("YYR1", levprd, nprod) + aryfil(temp1, nprod, 0) // //yyr2 is the number of rules for each production @@ -2791,9 +2791,9 @@ func others() { for i = 1; i < nprod; i++ { temp1[i] = len(prdptr[i]) - 2 } - arout("YYR2", temp1, nprod); + arout("YYR2", temp1, nprod) - aryfil(temp1, nstate, -1000); + aryfil(temp1, nstate, -1000) for i = 0; i <= ntokens; i++ { for j := tstates[i]; j != 0; j = mstates[j] { temp1[j] = i @@ -2804,22 +2804,22 @@ func others() { temp1[j] = -i } } - arout("YYCHK", temp1, nstate); - arout("YYDEF", defact, nstate); + arout("YYCHK", temp1, nstate) + arout("YYDEF", defact, nstate) // put out token translation tables // table 1 has 0-256 - aryfil(temp1, 256, 0); - c := 0; + aryfil(temp1, 256, 0) + c := 0 for i = 1; i <= ntokens; i++ { - j = tokset[i].value; + j = tokset[i].value if j >= 0 && j < 256 { if temp1[j] != 0 { - print("yacc bug -- cant have 2 different Ts with same value\n"); - print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name); - nerrors++; + print("yacc bug -- cant have 2 different Ts with same value\n") + print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name) + nerrors++ } - temp1[j] = i; + temp1[j] = i if j > c { c = j } @@ -2830,32 +2830,32 @@ func others() { temp1[i] = YYLEXUNK } } - arout("YYTOK1", temp1, c+1); + arout("YYTOK1", temp1, c+1) // table 2 has PRIVATE-PRIVATE+256 - aryfil(temp1, 256, 0); - c = 0; + aryfil(temp1, 256, 0) + c = 0 for i = 1; i <= ntokens; i++ { - j = tokset[i].value - PRIVATE; + j = tokset[i].value - PRIVATE if j >= 0 && j < 256 { if temp1[j] != 0 { - print("yacc bug -- cant have 2 different Ts with same value\n"); - print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name); - nerrors++; + print("yacc bug -- cant have 2 different Ts with same value\n") + print(" %s and %s\n", tokset[i].name, tokset[temp1[j]].name) + nerrors++ } - temp1[j] = i; + temp1[j] = i if j > c { c = j } } } - arout("YYTOK2", temp1, c+1); + arout("YYTOK2", temp1, c+1) // table 3 has everything else - fmt.Fprintf(ftable, "var\tYYTOK3\t= []int {\n"); - c = 0; + fmt.Fprintf(ftable, "var\tYYTOK3\t= []int {\n") + c = 0 for i = 1; i <= ntokens; i++ { - j = tokset[i].value; + j = tokset[i].value if j >= 0 && j < 256 { continue } @@ -2863,35 +2863,35 @@ func others() { continue } - fmt.Fprintf(ftable, "%4d,%4d,", j, i); - c++; + fmt.Fprintf(ftable, "%4d,%4d,", j, i) + c++ if c%5 == 0 { putrune(ftable, '\n') } } - fmt.Fprintf(ftable, "%4d,\n };\n", 0); + fmt.Fprintf(ftable, "%4d,\n };\n", 0) // copy parser text - c = getrune(finput); + c = getrune(finput) for c != EOF { - putrune(ftable, c); - c = getrune(finput); + putrune(ftable, c) + c = getrune(finput) } // copy yaccpar - fmt.Fprintf(ftable, "%v", yaccpar); + fmt.Fprintf(ftable, "%v", yaccpar) } func arout(s string, v []int, n int) { - fmt.Fprintf(ftable, "var\t%v\t= []int {\n", s); + fmt.Fprintf(ftable, "var\t%v\t= []int {\n", s) for i := 0; i < n; i++ { if i%10 == 0 { putrune(ftable, '\n') } - fmt.Fprintf(ftable, "%4d", v[i]); - putrune(ftable, ','); + fmt.Fprintf(ftable, "%4d", v[i]) + putrune(ftable, ',') } - fmt.Fprintf(ftable, "\n};\n"); + fmt.Fprintf(ftable, "\n};\n") } // @@ -2899,18 +2899,18 @@ func arout(s string, v []int, n int) { // func summary() { if foutput != nil { - fmt.Fprintf(foutput, "\n%v terminals, %v nonterminals\n", ntokens, nnonter+1); - fmt.Fprintf(foutput, "%v grammar rules, %v/%v states\n", nprod, nstate, NSTATES); - fmt.Fprintf(foutput, "%v shift/reduce, %v reduce/reduce conflicts reported\n", zzsrconf, zzrrconf); - fmt.Fprintf(foutput, "%v working sets used\n", len(wsets)); - fmt.Fprintf(foutput, "memory: parser %v/%v\n", memp, ACTSIZE); - fmt.Fprintf(foutput, "%v extra closures\n", zzclose-2*nstate); - fmt.Fprintf(foutput, "%v shift entries, %v exceptions\n", zzacent, zzexcp); - fmt.Fprintf(foutput, "%v goto entries\n", zzgoent); - fmt.Fprintf(foutput, "%v entries saved by goto default\n", zzgobest); + fmt.Fprintf(foutput, "\n%v terminals, %v nonterminals\n", ntokens, nnonter+1) + fmt.Fprintf(foutput, "%v grammar rules, %v/%v states\n", nprod, nstate, NSTATES) + fmt.Fprintf(foutput, "%v shift/reduce, %v reduce/reduce conflicts reported\n", zzsrconf, zzrrconf) + fmt.Fprintf(foutput, "%v working sets used\n", len(wsets)) + fmt.Fprintf(foutput, "memory: parser %v/%v\n", memp, ACTSIZE) + fmt.Fprintf(foutput, "%v extra closures\n", zzclose-2*nstate) + fmt.Fprintf(foutput, "%v shift entries, %v exceptions\n", zzacent, zzexcp) + fmt.Fprintf(foutput, "%v goto entries\n", zzgoent) + fmt.Fprintf(foutput, "%v entries saved by goto default\n", zzgobest) } if zzsrconf != 0 || zzrrconf != 0 { - fmt.Printf("\nconflicts: "); + fmt.Printf("\nconflicts: ") if zzsrconf != 0 { fmt.Printf("%v shift/reduce", zzsrconf) } @@ -2920,7 +2920,7 @@ func summary() { if zzrrconf != 0 { fmt.Printf("%v reduce/reduce", zzrrconf) } - fmt.Printf("\n"); + fmt.Printf("\n") } } @@ -2931,74 +2931,74 @@ func osummary() { if foutput == nil { return } - i := 0; + i := 0 for p := maxa; p >= 0; p-- { if amem[p] == 0 { i++ } } - fmt.Fprintf(foutput, "Optimizer space used: output %v/%v\n", maxa+1, ACTSIZE); - fmt.Fprintf(foutput, "%v table entries, %v zero\n", maxa+1, i); - fmt.Fprintf(foutput, "maximum spread: %v, maximum offset: %v\n", maxspr, maxoff); + fmt.Fprintf(foutput, "Optimizer space used: output %v/%v\n", maxa+1, ACTSIZE) + fmt.Fprintf(foutput, "%v table entries, %v zero\n", maxa+1, i) + fmt.Fprintf(foutput, "maximum spread: %v, maximum offset: %v\n", maxspr, maxoff) } // // copies and protects "'s in q // func chcopy(q string) string { - s := ""; - i := 0; - j := 0; + s := "" + i := 0 + j := 0 for i = 0; i < len(q); i++ { if q[i] == '"' { - s += q[j:i] + "\\"; - j = i; + s += q[j:i] + "\\" + j = i } } - return s + q[j:i]; + return s + q[j:i] } func usage() { - fmt.Fprintf(stderr, "usage: gacc [-o output] [-v parsetable] input\n"); - exit(1); + fmt.Fprintf(stderr, "usage: gacc [-o output] [-v parsetable] input\n") + exit(1) } -func bitset(set Lkset, bit int) int { return set[bit>>5] & (1 << uint(bit&31)) } +func bitset(set Lkset, bit int) int { return set[bit>>5] & (1 << uint(bit&31)) } -func setbit(set Lkset, bit int) { set[bit>>5] |= (1 << uint(bit&31)) } +func setbit(set Lkset, bit int) { set[bit>>5] |= (1 << uint(bit&31)) } -func mkset() Lkset { return make([]int, tbitset) } +func mkset() Lkset { return make([]int, tbitset) } // // set a to the union of a and b // return 1 if b is not a subset of a, 0 otherwise // func setunion(a, b []int) int { - sub := 0; + sub := 0 for i := 0; i < tbitset; i++ { - x := a[i]; - y := x | b[i]; - a[i] = y; + x := a[i] + y := x | b[i] + a[i] = y if y != x { sub = 1 } } - return sub; + return sub } func prlook(p Lkset) { if p == nil { - fmt.Fprintf(foutput, "\tNULL"); - return; + fmt.Fprintf(foutput, "\tNULL") + return } - fmt.Fprintf(foutput, " { "); + fmt.Fprintf(foutput, " { ") for j := 0; j <= ntokens; j++ { if bitset(p, j) != 0 { fmt.Fprintf(foutput, "%v ", symnam(j)) } } - fmt.Fprintf(foutput, "}"); + fmt.Fprintf(foutput, "}") } // @@ -3006,20 +3006,20 @@ func prlook(p Lkset) { // var peekrune int -func isdigit(c int) bool { return c >= '0' && c <= '9' } +func isdigit(c int) bool { return c >= '0' && c <= '9' } func isword(c int) bool { return c >= 0xa0 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') } -func mktemp(t string) string { return t } +func mktemp(t string) string { return t } // // return 1 if 2 arrays are equal // return 0 if not equal // func aryeq(a []int, b []int) int { - n := len(a); + n := len(a) if len(b) != n { return 0 } @@ -3028,29 +3028,29 @@ func aryeq(a []int, b []int) int { return 0 } } - return 1; + return 1 } func putrune(f *bufio.Writer, c int) { - s := string(c); + s := string(c) for i := 0; i < len(s); i++ { f.WriteByte(s[i]) } } func getrune(f *bufio.Reader) int { - var r int; + var r int if peekrune != 0 { if peekrune == EOF { return EOF } - r = peekrune; - peekrune = 0; - return r; + r = peekrune + peekrune = 0 + return r } - c, n, err := f.ReadRune(); + c, n, err := f.ReadRune() if n == 0 { return EOF } @@ -3058,7 +3058,7 @@ func getrune(f *bufio.Reader) int { error("read error: %v", err) } //fmt.Printf("rune = %v n=%v\n", string(c), n); - return c; + return c } func ungetrune(f *bufio.Reader, c int) { @@ -3068,59 +3068,59 @@ func ungetrune(f *bufio.Reader, c int) { if peekrune != 0 { panic("ungetc - 2nd unget") } - peekrune = c; + peekrune = c } func write(f *bufio.Writer, b []byte, n int) int { - println("write"); - return 0; + println("write") + return 0 } func open(s string) *bufio.Reader { - fi, err := os.Open(s, os.O_RDONLY, 0); + fi, err := os.Open(s, os.O_RDONLY, 0) if err != nil { error("error opening %v: %v", s, err) } //fmt.Printf("open %v\n", s); - return bufio.NewReader(fi); + return bufio.NewReader(fi) } func create(s string, m int) *bufio.Writer { - fo, err := os.Open(s, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, m); + fo, err := os.Open(s, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, m) if err != nil { error("error opening %v: %v", s, err) } //fmt.Printf("create %v mode %v\n", s, m); - return bufio.NewWriter(fo); + return bufio.NewWriter(fo) } // // write out error comment // func error(s string, v ...) { - nerrors++; - fmt.Fprintf(stderr, s, v); - fmt.Fprintf(stderr, ": %v:%v\n", infile, lineno); + nerrors++ + fmt.Fprintf(stderr, s, v) + fmt.Fprintf(stderr, ": %v:%v\n", infile, lineno) if fatfl != 0 { - summary(); - exit(1); + summary() + exit(1) } } func exit(status int) { if ftable != nil { - ftable.Flush(); - ftable = nil; + ftable.Flush() + ftable = nil } if foutput != nil { - foutput.Flush(); - foutput = nil; + foutput.Flush() + foutput = nil } if stderr != nil { - stderr.Flush(); - stderr = nil; + stderr.Flush() + stderr = nil } - os.Exit(status); + os.Exit(status) } var yaccpar = ` diff --git a/src/cmd/hgpatch/main.go b/src/cmd/hgpatch/main.go index 3d2b0817e..282122daa 100644 --- a/src/cmd/hgpatch/main.go +++ b/src/cmd/hgpatch/main.go @@ -5,35 +5,35 @@ package main import ( - "bytes"; - "container/vector"; - "exec"; - "flag"; - "fmt"; - "io"; - "io/ioutil"; - "os"; - "patch"; - "path"; - "sort"; - "strings"; + "bytes" + "container/vector" + "exec" + "flag" + "fmt" + "io" + "io/ioutil" + "os" + "patch" + "path" + "sort" + "strings" ) var checkSync = flag.Bool("checksync", true, "check whether repository is out of sync") func usage() { - fmt.Fprintf(os.Stderr, "usage: hgpatch [options] [patchfile]\n"); - flag.PrintDefaults(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "usage: hgpatch [options] [patchfile]\n") + flag.PrintDefaults() + os.Exit(2) } func main() { - flag.Usage = usage; - flag.Parse(); + flag.Usage = usage + flag.Parse() - args := flag.Args(); - var data []byte; - var err os.Error; + args := flag.Args() + var data []byte + var err os.Error switch len(args) { case 0: data, err = ioutil.ReadAll(os.Stdin) @@ -42,31 +42,31 @@ func main() { default: usage() } - chk(err); + chk(err) - pset, err := patch.Parse(data); - chk(err); + pset, err := patch.Parse(data) + chk(err) // Change to hg root directory, because // patch paths are relative to root. - root, err := hgRoot(); - chk(err); - chk(os.Chdir(root)); + root, err := hgRoot() + chk(err) + chk(os.Chdir(root)) // Make sure there are no pending changes on the server. if *checkSync && hgIncoming() { - fmt.Fprintf(os.Stderr, "incoming changes waiting; run hg sync first\n"); - os.Exit(2); + fmt.Fprintf(os.Stderr, "incoming changes waiting; run hg sync first\n") + os.Exit(2) } // Make sure we won't be editing files with local pending changes. - dirtylist, err := hgModified(); - chk(err); - dirty := make(map[string]int); + dirtylist, err := hgModified() + chk(err) + dirty := make(map[string]int) for _, f := range dirtylist { dirty[f] = 1 } - conflict := make(map[string]int); + conflict := make(map[string]int) for _, f := range pset.File { if f.Verb == patch.Delete || f.Verb == patch.Rename { if _, ok := dirty[f.Src]; ok { @@ -80,21 +80,21 @@ func main() { } } if len(conflict) > 0 { - fmt.Fprintf(os.Stderr, "cannot apply patch to locally modified files:\n"); + fmt.Fprintf(os.Stderr, "cannot apply patch to locally modified files:\n") for name := range conflict { fmt.Fprintf(os.Stderr, "\t%s\n", name) } - os.Exit(2); + os.Exit(2) } // Apply changes in memory. - op, err := pset.Apply(ioutil.ReadFile); - chk(err); + op, err := pset.Apply(ioutil.ReadFile) + chk(err) // Write changes to disk copy: order of commands matters. // Accumulate undo log as we go, in case there is an error. // Also accumulate list of modified files to print at end. - changed := make(map[string]int); + changed := make(map[string]int) // Copy, Rename create the destination file, so they // must happen before we write the data out. @@ -102,82 +102,82 @@ func main() { // with the same source, so we have to run all the // Copy in one pass, then all the Rename. for i := range op { - o := &op[i]; + o := &op[i] if o.Verb == patch.Copy { - makeParent(o.Dst); - chk(hgCopy(o.Dst, o.Src)); - undoRevert(o.Dst); - changed[o.Dst] = 1; + makeParent(o.Dst) + chk(hgCopy(o.Dst, o.Src)) + undoRevert(o.Dst) + changed[o.Dst] = 1 } } for i := range op { - o := &op[i]; + o := &op[i] if o.Verb == patch.Rename { - makeParent(o.Dst); - chk(hgRename(o.Dst, o.Src)); - undoRevert(o.Dst); - undoRevert(o.Src); - changed[o.Src] = 1; - changed[o.Dst] = 1; + makeParent(o.Dst) + chk(hgRename(o.Dst, o.Src)) + undoRevert(o.Dst) + undoRevert(o.Src) + changed[o.Src] = 1 + changed[o.Dst] = 1 } } // Run Delete before writing to files in case one of the // deleted paths is becoming a directory. for i := range op { - o := &op[i]; + o := &op[i] if o.Verb == patch.Delete { - chk(hgRemove(o.Src)); - undoRevert(o.Src); - changed[o.Src] = 1; + chk(hgRemove(o.Src)) + undoRevert(o.Src) + changed[o.Src] = 1 } } // Write files. for i := range op { - o := &op[i]; + o := &op[i] if o.Verb == patch.Delete { continue } if o.Verb == patch.Add { - makeParent(o.Dst); - changed[o.Dst] = 1; + makeParent(o.Dst) + changed[o.Dst] = 1 } if o.Data != nil { - chk(ioutil.WriteFile(o.Dst, o.Data, 0644)); + chk(ioutil.WriteFile(o.Dst, o.Data, 0644)) if o.Verb == patch.Add { undoRm(o.Dst) } else { undoRevert(o.Dst) } - changed[o.Dst] = 1; + changed[o.Dst] = 1 } if o.Mode != 0 { - chk(os.Chmod(o.Dst, o.Mode&0755)); - undoRevert(o.Dst); - changed[o.Dst] = 1; + chk(os.Chmod(o.Dst, o.Mode&0755)) + undoRevert(o.Dst) + changed[o.Dst] = 1 } } // hg add looks at the destination file, so it must happen // after we write the data out. for i := range op { - o := &op[i]; + o := &op[i] if o.Verb == patch.Add { - chk(hgAdd(o.Dst)); - undoRevert(o.Dst); - changed[o.Dst] = 1; + chk(hgAdd(o.Dst)) + undoRevert(o.Dst) + changed[o.Dst] = 1 } } // Finished editing files. Write the list of changed files to stdout. - list := make([]string, len(changed)); - i := 0; + list := make([]string, len(changed)) + i := 0 for f := range changed { - list[i] = f; - i++; + list[i] = f + i++ } - sort.SortStrings(list); + sort.SortStrings(list) for _, f := range list { fmt.Printf("%s\n", f) } @@ -186,58 +186,58 @@ func main() { // make parent directory for name, if necessary func makeParent(name string) { - parent, _ := path.Split(name); - chk(mkdirAll(parent, 0755)); + parent, _ := path.Split(name) + chk(mkdirAll(parent, 0755)) } // Copy of os.MkdirAll but adds to undo log after // creating a directory. func mkdirAll(path string, perm int) os.Error { - dir, err := os.Lstat(path); + dir, err := os.Lstat(path) if err == nil { if dir.IsDirectory() { return nil } - return &os.PathError{"mkdir", path, os.ENOTDIR}; + return &os.PathError{"mkdir", path, os.ENOTDIR} } - i := len(path); - for i > 0 && path[i-1] == '/' { // Skip trailing slashes. + i := len(path) + for i > 0 && path[i-1] == '/' { // Skip trailing slashes. i-- } - j := i; - for j > 0 && path[j-1] != '/' { // Scan backward over element. + j := i + for j > 0 && path[j-1] != '/' { // Scan backward over element. j-- } if j > 0 { - err = mkdirAll(path[0:j-1], perm); + err = mkdirAll(path[0:j-1], perm) if err != nil { return err } } - err = os.Mkdir(path, perm); + err = os.Mkdir(path, perm) if err != nil { // Handle arguments like "foo/." by // double-checking that directory doesn't exist. - dir, err1 := os.Lstat(path); + dir, err1 := os.Lstat(path) if err1 == nil && dir.IsDirectory() { return nil } - return err; + return err } - undoRm(path); - return nil; + undoRm(path) + return nil } // If err != nil, process the undo log and exit. func chk(err os.Error) { if err != nil { - fmt.Fprintf(os.Stderr, "%s\n", err); - runUndo(); - os.Exit(2); + fmt.Fprintf(os.Stderr, "%s\n", err) + runUndo() + os.Exit(2) } } @@ -245,11 +245,11 @@ func chk(err os.Error) { // Undo log type undo func() os.Error -var undoLog vector.Vector // vector of undo +var undoLog vector.Vector // vector of undo -func undoRevert(name string) { undoLog.Push(undo(func() os.Error { return hgRevert(name) })) } +func undoRevert(name string) { undoLog.Push(undo(func() os.Error { return hgRevert(name) })) } -func undoRm(name string) { undoLog.Push(undo(func() os.Error { return os.Remove(name) })) } +func undoRm(name string) { undoLog.Push(undo(func() os.Error { return os.Remove(name) })) } func runUndo() { for i := undoLog.Len() - 1; i >= 0; i-- { @@ -262,68 +262,68 @@ func runUndo() { // hgRoot returns the root directory of the repository. func hgRoot() (string, os.Error) { - out, err := run([]string{"hg", "root"}, nil); + out, err := run([]string{"hg", "root"}, nil) if err != nil { return "", err } - return strings.TrimSpace(out), nil; + return strings.TrimSpace(out), nil } // hgIncoming returns true if hg sync will pull in changes. func hgIncoming() bool { // hg -q incoming exits 0 when there is nothing incoming, 1 otherwise. - _, err := run([]string{"hg", "-q", "incoming"}, nil); - return err == nil; + _, err := run([]string{"hg", "-q", "incoming"}, nil) + return err == nil } // hgModified returns a list of the modified files in the // repository. func hgModified() ([]string, os.Error) { - out, err := run([]string{"hg", "status", "-n"}, nil); + out, err := run([]string{"hg", "status", "-n"}, nil) if err != nil { return nil, err } - return strings.Split(strings.TrimSpace(out), "\n", 0), nil; + return strings.Split(strings.TrimSpace(out), "\n", 0), nil } // hgAdd adds name to the repository. func hgAdd(name string) os.Error { - _, err := run([]string{"hg", "add", name}, nil); - return err; + _, err := run([]string{"hg", "add", name}, nil) + return err } // hgRemove removes name from the repository. func hgRemove(name string) os.Error { - _, err := run([]string{"hg", "rm", name}, nil); - return err; + _, err := run([]string{"hg", "rm", name}, nil) + return err } // hgRevert reverts name. func hgRevert(name string) os.Error { - _, err := run([]string{"hg", "revert", name}, nil); - return err; + _, err := run([]string{"hg", "revert", name}, nil) + return err } // hgCopy copies src to dst in the repository. // Note that the argument order matches io.Copy, not "hg cp". func hgCopy(dst, src string) os.Error { - _, err := run([]string{"hg", "cp", src, dst}, nil); - return err; + _, err := run([]string{"hg", "cp", src, dst}, nil) + return err } // hgRename renames src to dst in the repository. // Note that the argument order matches io.Copy, not "hg mv". func hgRename(dst, src string) os.Error { - _, err := run([]string{"hg", "mv", src, dst}, nil); - return err; + _, err := run([]string{"hg", "mv", src, dst}, nil) + return err } func copy(a []string) []string { - b := make([]string, len(a)); + b := make([]string, len(a)) for i, s := range a { b[i] = s } - return b; + return b } var lookPathCache = make(map[string]string) @@ -332,61 +332,61 @@ var lookPathCache = make(map[string]string) // It provides input on standard input to the command. func run(argv []string, input []byte) (out string, err os.Error) { if len(argv) < 1 { - err = os.EINVAL; - goto Error; + err = os.EINVAL + goto Error } - prog, ok := lookPathCache[argv[0]]; + prog, ok := lookPathCache[argv[0]] if !ok { - prog, err = exec.LookPath(argv[0]); + prog, err = exec.LookPath(argv[0]) if err != nil { goto Error } - lookPathCache[argv[0]] = prog; + lookPathCache[argv[0]] = prog } // fmt.Fprintf(os.Stderr, "%v\n", argv); - var cmd *exec.Cmd; + var cmd *exec.Cmd if len(input) == 0 { - cmd, err = exec.Run(prog, argv, os.Environ(), exec.DevNull, exec.Pipe, exec.MergeWithStdout); + cmd, err = exec.Run(prog, argv, os.Environ(), exec.DevNull, exec.Pipe, exec.MergeWithStdout) if err != nil { goto Error } } else { - cmd, err = exec.Run(prog, argv, os.Environ(), exec.Pipe, exec.Pipe, exec.MergeWithStdout); + cmd, err = exec.Run(prog, argv, os.Environ(), exec.Pipe, exec.Pipe, exec.MergeWithStdout) if err != nil { goto Error } go func() { - cmd.Stdin.Write(input); - cmd.Stdin.Close(); - }(); + cmd.Stdin.Write(input) + cmd.Stdin.Close() + }() } - defer cmd.Close(); - var buf bytes.Buffer; - _, err = io.Copy(&buf, cmd.Stdout); - out = buf.String(); + defer cmd.Close() + var buf bytes.Buffer + _, err = io.Copy(&buf, cmd.Stdout) + out = buf.String() if err != nil { - cmd.Wait(0); - goto Error; + cmd.Wait(0) + goto Error } - w, err := cmd.Wait(0); + w, err := cmd.Wait(0) if err != nil { goto Error } if !w.Exited() || w.ExitStatus() != 0 { - err = w; - goto Error; + err = w + goto Error } - return; + return Error: - err = &runError{copy(argv), err}; - return; + err = &runError{copy(argv), err} + return } // A runError represents an error that occurred while running a command. type runError struct { - cmd []string; - err os.Error; + cmd []string + err os.Error } -func (e *runError) String() string { return strings.Join(e.cmd, " ") + ": " + e.err.String() } +func (e *runError) String() string { return strings.Join(e.cmd, " ") + ": " + e.err.String() } diff --git a/src/pkg/archive/tar/common.go b/src/pkg/archive/tar/common.go index 792a3050b..4d399e5fe 100644 --- a/src/pkg/archive/tar/common.go +++ b/src/pkg/archive/tar/common.go @@ -12,39 +12,39 @@ package tar const ( - blockSize = 512; + blockSize = 512 // Types - TypeReg = '0'; - TypeRegA = '\x00'; - TypeLink = '1'; - TypeSymlink = '2'; - TypeChar = '3'; - TypeBlock = '4'; - TypeDir = '5'; - TypeFifo = '6'; - TypeCont = '7'; - TypeXHeader = 'x'; - TypeXGlobalHeader = 'g'; + TypeReg = '0' + TypeRegA = '\x00' + TypeLink = '1' + TypeSymlink = '2' + TypeChar = '3' + TypeBlock = '4' + TypeDir = '5' + TypeFifo = '6' + TypeCont = '7' + TypeXHeader = 'x' + TypeXGlobalHeader = 'g' ) // A Header represents a single header in a tar archive. // Some fields may not be populated. type Header struct { - Name string; - Mode int64; - Uid int64; - Gid int64; - Size int64; - Mtime int64; - Typeflag byte; - Linkname string; - Uname string; - Gname string; - Devmajor int64; - Devminor int64; - Atime int64; - Ctime int64; + Name string + Mode int64 + Uid int64 + Gid int64 + Size int64 + Mtime int64 + Typeflag byte + Linkname string + Uname string + Gname string + Devmajor int64 + Devminor int64 + Atime int64 + Ctime int64 } var zeroBlock = make([]byte, blockSize) @@ -55,21 +55,21 @@ func checksum(header []byte) (unsigned int64, signed int64) { for i := 0; i < len(header); i++ { if i == 148 { // The chksum field (header[148:156]) is special: it should be treated as space bytes. - unsigned += ' ' * 8; - signed += ' ' * 8; - i += 7; - continue; + unsigned += ' ' * 8 + signed += ' ' * 8 + i += 7 + continue } - unsigned += int64(header[i]); - signed += int64(int8(header[i])); + unsigned += int64(header[i]) + signed += int64(int8(header[i])) } - return; + return } type slicer []byte func (sp *slicer) next(n int) (b []byte) { - s := *sp; - b, *sp = s[0:n], s[n:]; - return; + s := *sp + b, *sp = s[0:n], s[n:] + return } diff --git a/src/pkg/archive/tar/reader.go b/src/pkg/archive/tar/reader.go index 50cda624b..9d598361a 100644 --- a/src/pkg/archive/tar/reader.go +++ b/src/pkg/archive/tar/reader.go @@ -8,14 +8,14 @@ package tar // - pax extensions import ( - "bytes"; - "io"; - "os"; - "strconv"; + "bytes" + "io" + "os" + "strconv" ) var ( - HeaderError os.Error = os.ErrorString("invalid tar header"); + HeaderError os.Error = os.ErrorString("invalid tar header") ) // A Reader provides sequential access to the contents of a tar archive. @@ -37,35 +37,35 @@ var ( // io.Copy(data, tr); // } type Reader struct { - r io.Reader; - err os.Error; - nb int64; // number of unread bytes for current file entry - pad int64; // amount of padding (ignored) after current file entry + r io.Reader + err os.Error + nb int64 // number of unread bytes for current file entry + pad int64 // amount of padding (ignored) after current file entry } // NewReader creates a new Reader reading from r. -func NewReader(r io.Reader) *Reader { return &Reader{r: r} } +func NewReader(r io.Reader) *Reader { return &Reader{r: r} } // Next advances to the next entry in the tar archive. func (tr *Reader) Next() (*Header, os.Error) { - var hdr *Header; + var hdr *Header if tr.err == nil { tr.skipUnread() } if tr.err == nil { hdr = tr.readHeader() } - return hdr, tr.err; + return hdr, tr.err } // Parse bytes as a NUL-terminated C-style string. // If a NUL byte is not found then the whole slice is returned as a string. func cString(b []byte) string { - n := 0; + n := 0 for n < len(b) && b[n] != 0 { n++ } - return string(b[0:n]); + return string(b[0:n]) } func (tr *Reader) octal(b []byte) int64 { @@ -77,11 +77,11 @@ func (tr *Reader) octal(b []byte) int64 { for len(b) > 0 && (b[len(b)-1] == ' ' || b[len(b)-1] == '\x00') { b = b[0 : len(b)-1] } - x, err := strconv.Btoui64(cString(b), 8); + x, err := strconv.Btoui64(cString(b), 8) if err != nil { tr.err = err } - return int64(x); + return int64(x) } type ignoreWriter struct{} @@ -92,14 +92,14 @@ func (ignoreWriter) Write(b []byte) (n int, err os.Error) { // Skip any unread bytes in the existing file entry, as well as any alignment padding. func (tr *Reader) skipUnread() { - nr := tr.nb + tr.pad; // number of bytes to skip - tr.nb, tr.pad = 0, 0; + nr := tr.nb + tr.pad // number of bytes to skip + tr.nb, tr.pad = 0, 0 if sr, ok := tr.r.(io.Seeker); ok { if _, err := sr.Seek(nr, 1); err == nil { return } } - _, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr); + _, tr.err = io.Copyn(ignoreWriter{}, tr.r, nr) } func (tr *Reader) verifyChecksum(header []byte) bool { @@ -107,13 +107,13 @@ func (tr *Reader) verifyChecksum(header []byte) bool { return false } - given := tr.octal(header[148:156]); - unsigned, signed := checksum(header); - return given == unsigned || given == signed; + given := tr.octal(header[148:156]) + unsigned, signed := checksum(header) + return given == unsigned || given == signed } func (tr *Reader) readHeader() *Header { - header := make([]byte, blockSize); + header := make([]byte, blockSize) if _, tr.err = io.ReadFull(tr.r, header); tr.err != nil { return nil } @@ -126,64 +126,64 @@ func (tr *Reader) readHeader() *Header { if bytes.Equal(header, zeroBlock[0:blockSize]) { tr.err = os.EOF } else { - tr.err = HeaderError // zero block and then non-zero block + tr.err = HeaderError // zero block and then non-zero block } - return nil; + return nil } if !tr.verifyChecksum(header) { - tr.err = HeaderError; - return nil; + tr.err = HeaderError + return nil } // Unpack - hdr := new(Header); - s := slicer(header); - - hdr.Name = cString(s.next(100)); - hdr.Mode = tr.octal(s.next(8)); - hdr.Uid = tr.octal(s.next(8)); - hdr.Gid = tr.octal(s.next(8)); - hdr.Size = tr.octal(s.next(12)); - hdr.Mtime = tr.octal(s.next(12)); - s.next(8); // chksum - hdr.Typeflag = s.next(1)[0]; - hdr.Linkname = cString(s.next(100)); + hdr := new(Header) + s := slicer(header) + + hdr.Name = cString(s.next(100)) + hdr.Mode = tr.octal(s.next(8)) + hdr.Uid = tr.octal(s.next(8)) + hdr.Gid = tr.octal(s.next(8)) + hdr.Size = tr.octal(s.next(12)) + hdr.Mtime = tr.octal(s.next(12)) + s.next(8) // chksum + hdr.Typeflag = s.next(1)[0] + hdr.Linkname = cString(s.next(100)) // The remainder of the header depends on the value of magic. // The original (v7) version of tar had no explicit magic field, // so its magic bytes, like the rest of the block, are NULs. - magic := string(s.next(8)); // contains version field as well. - var format string; + magic := string(s.next(8)) // contains version field as well. + var format string switch magic { - case "ustar\x0000": // POSIX tar (1003.1-1988) + case "ustar\x0000": // POSIX tar (1003.1-1988) if string(header[508:512]) == "tar\x00" { format = "star" } else { format = "posix" } - case "ustar \x00": // old GNU tar + case "ustar \x00": // old GNU tar format = "gnu" } switch format { case "posix", "gnu", "star": - hdr.Uname = cString(s.next(32)); - hdr.Gname = cString(s.next(32)); - devmajor := s.next(8); - devminor := s.next(8); + hdr.Uname = cString(s.next(32)) + hdr.Gname = cString(s.next(32)) + devmajor := s.next(8) + devminor := s.next(8) if hdr.Typeflag == TypeChar || hdr.Typeflag == TypeBlock { - hdr.Devmajor = tr.octal(devmajor); - hdr.Devminor = tr.octal(devminor); + hdr.Devmajor = tr.octal(devmajor) + hdr.Devminor = tr.octal(devminor) } - var prefix string; + var prefix string switch format { case "posix", "gnu": prefix = cString(s.next(155)) case "star": - prefix = cString(s.next(131)); - hdr.Atime = tr.octal(s.next(12)); - hdr.Ctime = tr.octal(s.next(12)); + prefix = cString(s.next(131)) + hdr.Atime = tr.octal(s.next(12)) + hdr.Ctime = tr.octal(s.next(12)) } if len(prefix) > 0 { hdr.Name = prefix + "/" + hdr.Name @@ -191,16 +191,16 @@ func (tr *Reader) readHeader() *Header { } if tr.err != nil { - tr.err = HeaderError; - return nil; + tr.err = HeaderError + return nil } // Maximum value of hdr.Size is 64 GB (12 octal digits), // so there's no risk of int64 overflowing. - tr.nb = int64(hdr.Size); - tr.pad = -tr.nb & (blockSize - 1); // blockSize is a power of two + tr.nb = int64(hdr.Size) + tr.pad = -tr.nb & (blockSize - 1) // blockSize is a power of two - return hdr; + return hdr } // Read reads from the current entry in the tar archive. @@ -215,12 +215,12 @@ func (tr *Reader) Read(b []byte) (n int, err os.Error) { if int64(len(b)) > tr.nb { b = b[0:tr.nb] } - n, err = tr.r.Read(b); - tr.nb -= int64(n); + n, err = tr.r.Read(b) + tr.nb -= int64(n) if err == os.EOF && tr.nb > 0 { err = io.ErrUnexpectedEOF } - tr.err = err; - return; + tr.err = err + return } diff --git a/src/pkg/archive/tar/reader_test.go b/src/pkg/archive/tar/reader_test.go index f5a77dd38..719e3d87e 100644 --- a/src/pkg/archive/tar/reader_test.go +++ b/src/pkg/archive/tar/reader_test.go @@ -5,20 +5,20 @@ package tar import ( - "bytes"; - "crypto/md5"; - "fmt"; - "io"; - "os"; - "reflect"; - "strings"; - "testing"; + "bytes" + "crypto/md5" + "fmt" + "io" + "os" + "reflect" + "strings" + "testing" ) type untarTest struct { - file string; - headers []*Header; - cksums []string; + file string + headers []*Header + cksums []string } var gnuTarTest = &untarTest{ @@ -114,50 +114,50 @@ var untarTests = []*untarTest{ func TestReader(t *testing.T) { testLoop: for i, test := range untarTests { - f, err := os.Open(test.file, os.O_RDONLY, 0444); + f, err := os.Open(test.file, os.O_RDONLY, 0444) if err != nil { - t.Errorf("test %d: Unexpected error: %v", i, err); - continue; + t.Errorf("test %d: Unexpected error: %v", i, err) + continue } - tr := NewReader(f); + tr := NewReader(f) for j, header := range test.headers { - hdr, err := tr.Next(); + hdr, err := tr.Next() if err != nil || hdr == nil { - t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err); - f.Close(); - continue testLoop; + t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err) + f.Close() + continue testLoop } if !reflect.DeepEqual(hdr, header) { t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v", i, j, *hdr, *header) } } - hdr, err := tr.Next(); + hdr, err := tr.Next() if err == os.EOF { break } if hdr != nil || err != nil { t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err) } - f.Close(); + f.Close() } } func TestPartialRead(t *testing.T) { - f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444); + f, err := os.Open("testdata/gnu.tar", os.O_RDONLY, 0444) if err != nil { t.Fatalf("Unexpected error: %v", err) } - defer f.Close(); + defer f.Close() - tr := NewReader(f); + tr := NewReader(f) // Read the first four bytes; Next() should skip the last byte. - hdr, err := tr.Next(); + hdr, err := tr.Next() if err != nil || hdr == nil { t.Fatalf("Didn't get first file: %v", err) } - buf := make([]byte, 4); + buf := make([]byte, 4) if _, err := io.ReadFull(tr, buf); err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -166,11 +166,11 @@ func TestPartialRead(t *testing.T) { } // Second file - hdr, err = tr.Next(); + hdr, err = tr.Next() if err != nil || hdr == nil { t.Fatalf("Didn't get second file: %v", err) } - buf = make([]byte, 6); + buf = make([]byte, 6) if _, err := io.ReadFull(tr, buf); err != nil { t.Fatalf("Unexpected error: %v", err) } @@ -181,22 +181,22 @@ func TestPartialRead(t *testing.T) { func TestIncrementalRead(t *testing.T) { - test := gnuTarTest; - f, err := os.Open(test.file, os.O_RDONLY, 0444); + test := gnuTarTest + f, err := os.Open(test.file, os.O_RDONLY, 0444) if err != nil { t.Fatalf("Unexpected error: %v", err) } - defer f.Close(); + defer f.Close() - tr := NewReader(f); + tr := NewReader(f) - headers := test.headers; - cksums := test.cksums; - nread := 0; + headers := test.headers + cksums := test.cksums + nread := 0 // loop over all files for ; ; nread++ { - hdr, err := tr.Next(); + hdr, err := tr.Next() if hdr == nil || err == os.EOF { break } @@ -209,22 +209,22 @@ func TestIncrementalRead(t *testing.T) { // read file contents in little chunks EOF, // checksumming all the way - h := md5.New(); - rdbuf := make([]uint8, 8); + h := md5.New() + rdbuf := make([]uint8, 8) for { - nr, err := tr.Read(rdbuf); + nr, err := tr.Read(rdbuf) if err == os.EOF { break } if err != nil { - t.Errorf("Read: unexpected error %v\n", err); - break; + t.Errorf("Read: unexpected error %v\n", err) + break } - h.Write(rdbuf[0:nr]); + h.Write(rdbuf[0:nr]) } // verify checksum - have := fmt.Sprintf("%x", h.Sum()); - want := cksums[nread]; + have := fmt.Sprintf("%x", h.Sum()) + want := cksums[nread] if want != have { t.Errorf("Bad checksum on file %s:\nhave %+v\nwant %+v", hdr.Name, have, want) } @@ -235,35 +235,35 @@ func TestIncrementalRead(t *testing.T) { } func TestNonSeekable(t *testing.T) { - test := gnuTarTest; - f, err := os.Open(test.file, os.O_RDONLY, 0444); + test := gnuTarTest + f, err := os.Open(test.file, os.O_RDONLY, 0444) if err != nil { t.Fatalf("Unexpected error: %v", err) } - defer f.Close(); + defer f.Close() // pipe the data in - r, w, err := os.Pipe(); + r, w, err := os.Pipe() if err != nil { t.Fatalf("Unexpected error %s", err) } go func() { - rdbuf := make([]uint8, 1<<16); + rdbuf := make([]uint8, 1<<16) for { - nr, err := f.Read(rdbuf); - w.Write(rdbuf[0:nr]); + nr, err := f.Read(rdbuf) + w.Write(rdbuf[0:nr]) if err == os.EOF { break } } - w.Close(); - }(); + w.Close() + }() - tr := NewReader(r); - nread := 0; + tr := NewReader(r) + nread := 0 for ; ; nread++ { - hdr, err := tr.Next(); + hdr, err := tr.Next() if hdr == nil || err == os.EOF { break } diff --git a/src/pkg/archive/tar/writer.go b/src/pkg/archive/tar/writer.go index f3ce84afa..88f9c72bd 100644 --- a/src/pkg/archive/tar/writer.go +++ b/src/pkg/archive/tar/writer.go @@ -8,16 +8,16 @@ package tar // - catch more errors (no first header, write after close, etc.) import ( - "io"; - "os"; - "strconv"; - "strings"; + "io" + "os" + "strconv" + "strings" ) var ( - ErrWriteTooLong = os.NewError("write too long"); - ErrFieldTooLong = os.NewError("header field too long"); - ErrWriteAfterClose = os.NewError("write after close"); + ErrWriteTooLong = os.NewError("write too long") + ErrFieldTooLong = os.NewError("header field too long") + ErrWriteAfterClose = os.NewError("write after close") ) // A Writer provides sequential writing of a tar archive in POSIX.1 format. @@ -36,32 +36,32 @@ var ( // io.Copy(tw, data); // tw.Close(); type Writer struct { - w io.Writer; - err os.Error; - nb int64; // number of unwritten bytes for current file entry - pad int64; // amount of padding to write after current file entry - closed bool; - usedBinary bool; // whether the binary numeric field extension was used + w io.Writer + err os.Error + nb int64 // number of unwritten bytes for current file entry + pad int64 // amount of padding to write after current file entry + closed bool + usedBinary bool // whether the binary numeric field extension was used } // NewWriter creates a new Writer writing to w. -func NewWriter(w io.Writer) *Writer { return &Writer{w: w} } +func NewWriter(w io.Writer) *Writer { return &Writer{w: w} } // Flush finishes writing the current file (optional). func (tw *Writer) Flush() os.Error { - n := tw.nb + tw.pad; + n := tw.nb + tw.pad for n > 0 && tw.err == nil { - nr := n; + nr := n if nr > blockSize { nr = blockSize } - var nw int; - nw, tw.err = tw.w.Write(zeroBlock[0:nr]); - n -= int64(nw); + var nw int + nw, tw.err = tw.w.Write(zeroBlock[0:nr]) + n -= int64(nw) } - tw.nb = 0; - tw.pad = 0; - return tw.err; + tw.nb = 0 + tw.pad = 0 + return tw.err } // Write s into b, terminating it with a NUL if there is room. @@ -70,7 +70,7 @@ func (tw *Writer) cString(b []byte, s string) { if tw.err == nil { tw.err = ErrFieldTooLong } - return; + return } for i, ch := range strings.Bytes(s) { b[i] = ch @@ -82,29 +82,29 @@ func (tw *Writer) cString(b []byte, s string) { // Encode x as an octal ASCII string and write it into b with leading zeros. func (tw *Writer) octal(b []byte, x int64) { - s := strconv.Itob64(x, 8); + s := strconv.Itob64(x, 8) // leading zeros, but leave room for a NUL. for len(s)+1 < len(b) { s = "0" + s } - tw.cString(b, s); + tw.cString(b, s) } // Write x into b, either as octal or as binary (GNUtar/star extension). func (tw *Writer) numeric(b []byte, x int64) { // Try octal first. - s := strconv.Itob64(x, 8); + s := strconv.Itob64(x, 8) if len(s) < len(b) { - tw.octal(b, x); - return; + tw.octal(b, x) + return } // Too big: use binary (big-endian). - tw.usedBinary = true; + tw.usedBinary = true for i := len(b) - 1; x > 0 && i >= 0; i-- { - b[i] = byte(x); - x >>= 8; + b[i] = byte(x) + x >>= 8 } - b[0] |= 0x80; // highest bit indicates binary format + b[0] |= 0x80 // highest bit indicates binary format } // WriteHeader writes hdr and prepares to accept the file's contents. @@ -121,28 +121,28 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error { return tw.err } - tw.nb = int64(hdr.Size); - tw.pad = -tw.nb & (blockSize - 1); // blockSize is a power of two + tw.nb = int64(hdr.Size) + tw.pad = -tw.nb & (blockSize - 1) // blockSize is a power of two - header := make([]byte, blockSize); - s := slicer(header); + header := make([]byte, blockSize) + s := slicer(header) // TODO(dsymonds): handle names longer than 100 chars - copy(s.next(100), strings.Bytes(hdr.Name)); - - tw.octal(s.next(8), hdr.Mode); // 100:108 - tw.numeric(s.next(8), hdr.Uid); // 108:116 - tw.numeric(s.next(8), hdr.Gid); // 116:124 - tw.numeric(s.next(12), hdr.Size); // 124:136 - tw.numeric(s.next(12), hdr.Mtime); // 136:148 - s.next(8); // chksum (148:156) - s.next(1)[0] = hdr.Typeflag; // 156:157 - s.next(100); // linkname (157:257) - copy(s.next(8), strings.Bytes("ustar\x0000")); // 257:265 - tw.cString(s.next(32), hdr.Uname); // 265:297 - tw.cString(s.next(32), hdr.Gname); // 297:329 - tw.numeric(s.next(8), hdr.Devmajor); // 329:337 - tw.numeric(s.next(8), hdr.Devminor); // 337:345 + copy(s.next(100), strings.Bytes(hdr.Name)) + + tw.octal(s.next(8), hdr.Mode) // 100:108 + tw.numeric(s.next(8), hdr.Uid) // 108:116 + tw.numeric(s.next(8), hdr.Gid) // 116:124 + tw.numeric(s.next(12), hdr.Size) // 124:136 + tw.numeric(s.next(12), hdr.Mtime) // 136:148 + s.next(8) // chksum (148:156) + s.next(1)[0] = hdr.Typeflag // 156:157 + s.next(100) // linkname (157:257) + copy(s.next(8), strings.Bytes("ustar\x0000")) // 257:265 + tw.cString(s.next(32), hdr.Uname) // 265:297 + tw.cString(s.next(32), hdr.Gname) // 297:329 + tw.numeric(s.next(8), hdr.Devmajor) // 329:337 + tw.numeric(s.next(8), hdr.Devminor) // 337:345 // Use the GNU magic instead of POSIX magic if we used any GNU extensions. if tw.usedBinary { @@ -151,18 +151,18 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error { // The chksum field is terminated by a NUL and a space. // This is different from the other octal fields. - chksum, _ := checksum(header); - tw.octal(header[148:155], chksum); - header[155] = ' '; + chksum, _ := checksum(header) + tw.octal(header[148:155], chksum) + header[155] = ' ' if tw.err != nil { // problem with header; probably integer too big for a field. return tw.err } - _, tw.err = tw.w.Write(header); + _, tw.err = tw.w.Write(header) - return tw.err; + return tw.err } // Write writes to the current entry in the tar archive. @@ -170,22 +170,22 @@ func (tw *Writer) WriteHeader(hdr *Header) os.Error { // hdr.Size bytes are written after WriteHeader. func (tw *Writer) Write(b []byte) (n int, err os.Error) { if tw.closed { - err = ErrWriteTooLong; - return; + err = ErrWriteTooLong + return } - overwrite := false; + overwrite := false if int64(len(b)) > tw.nb { - b = b[0:tw.nb]; - overwrite = true; + b = b[0:tw.nb] + overwrite = true } - n, err = tw.w.Write(b); - tw.nb -= int64(n); + n, err = tw.w.Write(b) + tw.nb -= int64(n) if err == nil && overwrite { - err = ErrWriteTooLong; - return; + err = ErrWriteTooLong + return } - tw.err = err; - return; + tw.err = err + return } // Close closes the tar archive, flushing any unwritten @@ -194,15 +194,15 @@ func (tw *Writer) Close() os.Error { if tw.err != nil || tw.closed { return tw.err } - tw.Flush(); - tw.closed = true; + tw.Flush() + tw.closed = true // trailer: two zero blocks for i := 0; i < 2; i++ { - _, tw.err = tw.w.Write(zeroBlock); + _, tw.err = tw.w.Write(zeroBlock) if tw.err != nil { break } } - return tw.err; + return tw.err } diff --git a/src/pkg/archive/tar/writer_test.go b/src/pkg/archive/tar/writer_test.go index 0df0144b1..f060efcbe 100644 --- a/src/pkg/archive/tar/writer_test.go +++ b/src/pkg/archive/tar/writer_test.go @@ -5,22 +5,22 @@ package tar import ( - "bytes"; - "fmt"; - "io"; - "io/ioutil"; - "testing"; - "testing/iotest"; + "bytes" + "fmt" + "io" + "io/ioutil" + "testing" + "testing/iotest" ) type writerTestEntry struct { - header *Header; - contents string; + header *Header + contents string } type writerTest struct { - file string; // filename of expected output - entries []*writerTestEntry; + file string // filename of expected output + entries []*writerTestEntry } var writerTests = []*writerTest{ @@ -83,8 +83,8 @@ var writerTests = []*writerTest{ // Render byte array in a two-character hexadecimal string, spaced for easy visual inspection. func bytestr(offset int, b []byte) string { - const rowLen = 32; - s := fmt.Sprintf("%04x ", offset); + const rowLen = 32 + s := fmt.Sprintf("%04x ", offset) for _, ch := range b { switch { case '0' <= ch && ch <= '9', 'A' <= ch && ch <= 'Z', 'a' <= ch && ch <= 'z': @@ -93,59 +93,59 @@ func bytestr(offset int, b []byte) string { s += fmt.Sprintf(" %02x", ch) } } - return s; + return s } // Render a pseudo-diff between two blocks of bytes. func bytediff(a []byte, b []byte) string { - const rowLen = 32; - s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b)); + const rowLen = 32 + s := fmt.Sprintf("(%d bytes vs. %d bytes)\n", len(a), len(b)) for offset := 0; len(a)+len(b) > 0; offset += rowLen { - na, nb := rowLen, rowLen; + na, nb := rowLen, rowLen if na > len(a) { na = len(a) } if nb > len(b) { nb = len(b) } - sa := bytestr(offset, a[0:na]); - sb := bytestr(offset, b[0:nb]); + sa := bytestr(offset, a[0:na]) + sb := bytestr(offset, b[0:nb]) if sa != sb { s += fmt.Sprintf("-%v\n+%v\n", sa, sb) } - a = a[na:]; - b = b[nb:]; + a = a[na:] + b = b[nb:] } - return s; + return s } func TestWriter(t *testing.T) { testLoop: for i, test := range writerTests { - expected, err := ioutil.ReadFile(test.file); + expected, err := ioutil.ReadFile(test.file) if err != nil { - t.Errorf("test %d: Unexpected error: %v", i, err); - continue; + t.Errorf("test %d: Unexpected error: %v", i, err) + continue } - buf := new(bytes.Buffer); - tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)); // only catch the first 4 KB + buf := new(bytes.Buffer) + tw := NewWriter(iotest.TruncateWriter(buf, 4<<10)) // only catch the first 4 KB for j, entry := range test.entries { if err := tw.WriteHeader(entry.header); err != nil { - t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err); - continue testLoop; + t.Errorf("test %d, entry %d: Failed writing header: %v", i, j, err) + continue testLoop } if _, err := io.WriteString(tw, entry.contents); err != nil { - t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err); - continue testLoop; + t.Errorf("test %d, entry %d: Failed writing contents: %v", i, j, err) + continue testLoop } } if err := tw.Close(); err != nil { - t.Errorf("test %d: Failed closing archive: %v", err); - continue testLoop; + t.Errorf("test %d: Failed closing archive: %v", err) + continue testLoop } - actual := buf.Bytes(); + actual := buf.Bytes() if !bytes.Equal(expected, actual) { t.Errorf("test %d: Incorrect result: (-=expected, +=actual)\n%v", i, bytediff(expected, actual)) diff --git a/src/pkg/asn1/asn1.go b/src/pkg/asn1/asn1.go index 4a1ef7f5e..a422f28ad 100644 --- a/src/pkg/asn1/asn1.go +++ b/src/pkg/asn1/asn1.go @@ -20,26 +20,26 @@ package asn1 // everything by any means. import ( - "fmt"; - "os"; - "reflect"; - "time"; + "fmt" + "os" + "reflect" + "time" ) // A StructuralError suggests that the ASN.1 data is valid, but the Go type // which is receiving it doesn't match. type StructuralError struct { - Msg string; + Msg string } -func (e StructuralError) String() string { return "ASN.1 structure error: " + e.Msg } +func (e StructuralError) String() string { return "ASN.1 structure error: " + e.Msg } // A SyntaxError suggests that the ASN.1 data is invalid. type SyntaxError struct { - Msg string; + Msg string } -func (e SyntaxError) String() string { return "ASN.1 syntax error: " + e.Msg } +func (e SyntaxError) String() string { return "ASN.1 syntax error: " + e.Msg } // We start by dealing with each of the primitive types in turn. @@ -47,11 +47,11 @@ func (e SyntaxError) String() string { return "ASN.1 syntax error: " + e.Msg } func parseBool(bytes []byte) (ret bool, err os.Error) { if len(bytes) != 1 { - err = SyntaxError{"invalid boolean"}; - return; + err = SyntaxError{"invalid boolean"} + return } - return bytes[0] != 0, nil; + return bytes[0] != 0, nil } // INTEGER @@ -61,31 +61,31 @@ func parseBool(bytes []byte) (ret bool, err os.Error) { func parseInt64(bytes []byte) (ret int64, err os.Error) { if len(bytes) > 8 { // We'll overflow an int64 in this case. - err = StructuralError{"integer too large"}; - return; + err = StructuralError{"integer too large"} + return } for bytesRead := 0; bytesRead < len(bytes); bytesRead++ { - ret <<= 8; - ret |= int64(bytes[bytesRead]); + ret <<= 8 + ret |= int64(bytes[bytesRead]) } // Shift up and down in order to sign extend the result. - ret <<= 64 - uint8(len(bytes))*8; - ret >>= 64 - uint8(len(bytes))*8; - return; + ret <<= 64 - uint8(len(bytes))*8 + ret >>= 64 - uint8(len(bytes))*8 + return } // parseInt treats the given bytes as a big-endian, signed integer and returns // the result. func parseInt(bytes []byte) (int, os.Error) { - ret64, err := parseInt64(bytes); + ret64, err := parseInt64(bytes) if err != nil { return 0, err } if ret64 != int64(int(ret64)) { return 0, StructuralError{"integer too large"} } - return int(ret64), nil; + return int(ret64), nil } // BIT STRING @@ -94,8 +94,8 @@ func parseInt(bytes []byte) (int, os.Error) { // bit string is padded up to the nearest byte in memory and the number of // valid bits is recorded. Padding bits will be zero. type BitString struct { - Bytes []byte; // bits packed into bytes. - BitLength int; // length in bits. + Bytes []byte // bits packed into bytes. + BitLength int // length in bits. } // At returns the bit at the given index. If the index is out of range it @@ -104,45 +104,45 @@ func (b BitString) At(i int) int { if i < 0 || i >= b.BitLength { return 0 } - x := i / 8; - y := 7 - uint(i%8); - return int(b.Bytes[x]>>y) & 1; + x := i / 8 + y := 7 - uint(i%8) + return int(b.Bytes[x]>>y) & 1 } // RightAlign returns a slice where the padding bits are at the beginning. The // slice may share memory with the BitString. func (b BitString) RightAlign() []byte { - shift := uint(8 - (b.BitLength % 8)); + shift := uint(8 - (b.BitLength % 8)) if shift == 8 || len(b.Bytes) == 0 { return b.Bytes } - a := make([]byte, len(b.Bytes)); - a[0] = b.Bytes[0] >> shift; + a := make([]byte, len(b.Bytes)) + a[0] = b.Bytes[0] >> shift for i := 1; i < len(b.Bytes); i++ { - a[i] = b.Bytes[i-1] << (8 - shift); - a[i] |= b.Bytes[i] >> shift; + a[i] = b.Bytes[i-1] << (8 - shift) + a[i] |= b.Bytes[i] >> shift } - return a; + return a } // parseBitString parses an ASN.1 bit string from the given byte array and returns it. func parseBitString(bytes []byte) (ret BitString, err os.Error) { if len(bytes) == 0 { - err = SyntaxError{"zero length BIT STRING"}; - return; + err = SyntaxError{"zero length BIT STRING"} + return } - paddingBits := int(bytes[0]); + paddingBits := int(bytes[0]) if paddingBits > 7 || len(bytes) == 1 && paddingBits > 0 || bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 { - err = SyntaxError{"invalid padding bits in BIT STRING"}; - return; + err = SyntaxError{"invalid padding bits in BIT STRING"} + return } - ret.BitLength = (len(bytes)-1)*8 - paddingBits; - ret.Bytes = bytes[1:]; - return; + ret.BitLength = (len(bytes)-1)*8 - paddingBits + ret.Bytes = bytes[1:] + return } // OBJECT IDENTIFIER @@ -155,54 +155,54 @@ type ObjectIdentifier []int // that are assigned in a hierarachy. func parseObjectIdentifier(bytes []byte) (s []int, err os.Error) { if len(bytes) == 0 { - err = SyntaxError{"zero length OBJECT IDENTIFIER"}; - return; + err = SyntaxError{"zero length OBJECT IDENTIFIER"} + return } // In the worst case, we get two elements from the first byte (which is // encoded differently) and then every varint is a single byte long. - s = make([]int, len(bytes)+1); + s = make([]int, len(bytes)+1) // The first byte is 40*value1 + value2: - s[0] = int(bytes[0]) / 40; - s[1] = int(bytes[0]) % 40; - i := 2; + s[0] = int(bytes[0]) / 40 + s[1] = int(bytes[0]) % 40 + i := 2 for offset := 1; offset < len(bytes); i++ { - var v int; - v, offset, err = parseBase128Int(bytes, offset); + var v int + v, offset, err = parseBase128Int(bytes, offset) if err != nil { return } - s[i] = v; + s[i] = v } - s = s[0:i]; - return; + s = s[0:i] + return } // parseBase128Int parses a base-128 encoded int from the given offset in the // given byte array. It returns the value and the new offset. func parseBase128Int(bytes []byte, initOffset int) (ret, offset int, err os.Error) { - offset = initOffset; + offset = initOffset for shifted := 0; offset < len(bytes); shifted++ { if shifted > 4 { - err = StructuralError{"base 128 integer too large"}; - return; + err = StructuralError{"base 128 integer too large"} + return } - ret <<= 7; - b := bytes[offset]; - ret |= int(b & 0x7f); - offset++; + ret <<= 7 + b := bytes[offset] + ret |= int(b & 0x7f) + offset++ if b&0x80 == 0 { return } } - err = SyntaxError{"truncated base 128 integer"}; - return; + err = SyntaxError{"truncated base 128 integer"} + return } // UTCTime -func isDigit(b byte) bool { return '0' <= b && b <= '9' } +func isDigit(b byte) bool { return '0' <= b && b <= '9' } // twoDigits returns the value of two, base 10 digits. func twoDigits(bytes []byte, max int) (int, bool) { @@ -211,11 +211,11 @@ func twoDigits(bytes []byte, max int) (int, bool) { return 0, false } } - value := (int(bytes[0])-'0')*10 + int(bytes[1]-'0'); + value := (int(bytes[0])-'0')*10 + int(bytes[1]-'0') if value > max { return 0, false } - return value, true; + return value, true } // parseUTCTime parses the UTCTime from the given byte array and returns the @@ -233,13 +233,13 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) { // YYMMDDhhmmss+hhmm // YYMMDDhhmmss-hhmm if len(bytes) < 11 { - err = SyntaxError{"UTCTime too short"}; - return; + err = SyntaxError{"UTCTime too short"} + return } - ret = new(time.Time); + ret = new(time.Time) - var ok1, ok2, ok3, ok4, ok5 bool; - year, ok1 := twoDigits(bytes[0:2], 99); + var ok1, ok2, ok3, ok4, ok5 bool + year, ok1 := twoDigits(bytes[0:2], 99) // RFC 5280, section 5.1.2.4 says that years 2050 or later use another date // scheme. if year >= 50 { @@ -247,24 +247,24 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) { } else { ret.Year = 2000 + int64(year) } - ret.Month, ok2 = twoDigits(bytes[2:4], 12); - ret.Day, ok3 = twoDigits(bytes[4:6], 31); - ret.Hour, ok4 = twoDigits(bytes[6:8], 23); - ret.Minute, ok5 = twoDigits(bytes[8:10], 59); + ret.Month, ok2 = twoDigits(bytes[2:4], 12) + ret.Day, ok3 = twoDigits(bytes[4:6], 31) + ret.Hour, ok4 = twoDigits(bytes[6:8], 23) + ret.Minute, ok5 = twoDigits(bytes[8:10], 59) if !ok1 || !ok2 || !ok3 || !ok4 || !ok5 { goto Error } - bytes = bytes[10:]; + bytes = bytes[10:] switch bytes[0] { case '0', '1', '2', '3', '4', '5', '6': if len(bytes) < 3 { goto Error } - ret.Second, ok1 = twoDigits(bytes[0:2], 60); // 60, not 59, because of leap seconds. + ret.Second, ok1 = twoDigits(bytes[0:2], 60) // 60, not 59, because of leap seconds. if !ok1 { goto Error } - bytes = bytes[2:]; + bytes = bytes[2:] } if len(bytes) == 0 { goto Error @@ -274,29 +274,29 @@ func parseUTCTime(bytes []byte) (ret *time.Time, err os.Error) { if len(bytes) != 1 { goto Error } - return; + return case '-', '+': if len(bytes) != 5 { goto Error } - hours, ok1 := twoDigits(bytes[1:3], 12); - minutes, ok2 := twoDigits(bytes[3:5], 59); + hours, ok1 := twoDigits(bytes[1:3], 12) + minutes, ok2 := twoDigits(bytes[3:5], 59) if !ok1 || !ok2 { goto Error } - sign := 1; + sign := 1 if bytes[0] == '-' { sign = -1 } - ret.ZoneOffset = sign * (60 * (hours*60 + minutes)); + ret.ZoneOffset = sign * (60 * (hours*60 + minutes)) default: goto Error } - return; + return Error: - err = SyntaxError{"invalid UTCTime"}; - return; + err = SyntaxError{"invalid UTCTime"} + return } // PrintableString @@ -306,12 +306,12 @@ Error: func parsePrintableString(bytes []byte) (ret string, err os.Error) { for _, b := range bytes { if !isPrintable(b) { - err = SyntaxError{"PrintableString contains invalid character"}; - return; + err = SyntaxError{"PrintableString contains invalid character"} + return } } - ret = string(bytes); - return; + ret = string(bytes) + return } // isPrintable returns true iff the given b is in the ASN.1 PrintableString set. @@ -334,19 +334,19 @@ func isPrintable(b byte) bool { func parseIA5String(bytes []byte) (ret string, err os.Error) { for _, b := range bytes { if b >= 0x80 { - err = SyntaxError{"IA5String contains invalid character"}; - return; + err = SyntaxError{"IA5String contains invalid character"} + return } } - ret = string(bytes); - return; + ret = string(bytes) + return } // A RawValue represents an undecoded ASN.1 object. type RawValue struct { - Class, Tag int; - IsCompound bool; - Bytes []byte; + Class, Tag int + IsCompound bool + Bytes []byte } // RawContent is used to signal that the undecoded, DER data needs to be @@ -361,52 +361,52 @@ type RawContent []byte // SET OF (tag 17) are mapped to SEQUENCE and SEQUENCE OF (tag 16) since we // don't distinguish between ordered and unordered objects in this code. func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset int, err os.Error) { - offset = initOffset; - b := bytes[offset]; - offset++; - ret.class = int(b >> 6); - ret.isCompound = b&0x20 == 0x20; - ret.tag = int(b & 0x1f); + offset = initOffset + b := bytes[offset] + offset++ + ret.class = int(b >> 6) + ret.isCompound = b&0x20 == 0x20 + ret.tag = int(b & 0x1f) // If the bottom five bits are set, then the tag number is actually base 128 // encoded afterwards if ret.tag == 0x1f { - ret.tag, offset, err = parseBase128Int(bytes, offset); + ret.tag, offset, err = parseBase128Int(bytes, offset) if err != nil { return } } if offset >= len(bytes) { - err = SyntaxError{"truncated tag or length"}; - return; + err = SyntaxError{"truncated tag or length"} + return } - b = bytes[offset]; - offset++; + b = bytes[offset] + offset++ if b&0x80 == 0 { // The length is encoded in the bottom 7 bits. ret.length = int(b & 0x7f) } else { // Bottom 7 bits give the number of length bytes to follow. - numBytes := int(b & 0x7f); + numBytes := int(b & 0x7f) // We risk overflowing a signed 32-bit number if we accept more than 3 bytes. if numBytes > 3 { - err = StructuralError{"length too large"}; - return; + err = StructuralError{"length too large"} + return } if numBytes == 0 { - err = SyntaxError{"indefinite length found (not DER)"}; - return; + err = SyntaxError{"indefinite length found (not DER)"} + return } - ret.length = 0; + ret.length = 0 for i := 0; i < numBytes; i++ { if offset >= len(bytes) { - err = SyntaxError{"truncated tag or length"}; - return; + err = SyntaxError{"truncated tag or length"} + return } - b = bytes[offset]; - offset++; - ret.length <<= 8; - ret.length |= int(b); + b = bytes[offset] + offset++ + ret.length <<= 8 + ret.length |= int(b) } } @@ -415,57 +415,57 @@ func parseTagAndLength(bytes []byte, initOffset int) (ret tagAndLength, offset i if ret.tag == tagSet { ret.tag = tagSequence } - return; + return } // parseSequenceOf is used for SEQUENCE OF and SET OF values. It tries to parse // a number of ASN.1 values from the given byte array and returns them as a // slice of Go values of the given type. func parseSequenceOf(bytes []byte, sliceType *reflect.SliceType, elemType reflect.Type) (ret *reflect.SliceValue, err os.Error) { - expectedTag, compoundType, ok := getUniversalType(elemType); + expectedTag, compoundType, ok := getUniversalType(elemType) if !ok { - err = StructuralError{"unknown Go type for slice"}; - return; + err = StructuralError{"unknown Go type for slice"} + return } // First we iterate over the input and count the number of elements, // checking that the types are correct in each case. - numElements := 0; + numElements := 0 for offset := 0; offset < len(bytes); { - var t tagAndLength; - t, offset, err = parseTagAndLength(bytes, offset); + var t tagAndLength + t, offset, err = parseTagAndLength(bytes, offset) if err != nil { return } if t.class != classUniversal || t.isCompound != compoundType || t.tag != expectedTag { - err = StructuralError{"sequence tag mismatch"}; - return; + err = StructuralError{"sequence tag mismatch"} + return } if invalidLength(offset, t.length, len(bytes)) { - err = SyntaxError{"truncated sequence"}; - return; + err = SyntaxError{"truncated sequence"} + return } - offset += t.length; - numElements++; + offset += t.length + numElements++ } - ret = reflect.MakeSlice(sliceType, numElements, numElements); - params := fieldParameters{}; - offset := 0; + ret = reflect.MakeSlice(sliceType, numElements, numElements) + params := fieldParameters{} + offset := 0 for i := 0; i < numElements; i++ { - offset, err = parseField(ret.Elem(i), bytes, offset, params); + offset, err = parseField(ret.Elem(i), bytes, offset, params) if err != nil { return } } - return; + return } var ( - bitStringType = reflect.Typeof(BitString{}); - objectIdentifierType = reflect.Typeof(ObjectIdentifier{}); - timeType = reflect.Typeof(&time.Time{}); - rawValueType = reflect.Typeof(RawValue{}); - rawContentsType = reflect.Typeof(RawContent(nil)); + bitStringType = reflect.Typeof(BitString{}) + objectIdentifierType = reflect.Typeof(ObjectIdentifier{}) + timeType = reflect.Typeof(&time.Time{}) + rawValueType = reflect.Typeof(RawValue{}) + rawContentsType = reflect.Typeof(RawContent(nil)) ) // invalidLength returns true iff offset + length > sliceLength, or if the @@ -478,49 +478,49 @@ func invalidLength(offset, length, sliceLength int) bool { // into the array, it will try to parse a suitable ASN.1 value out and store it // in the given Value. func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err os.Error) { - offset = initOffset; - fieldType := v.Type(); + offset = initOffset + fieldType := v.Type() // If we have run out of data, it may be that there are optional elements at the end. if offset == len(bytes) { if !setDefaultValue(v, params) { err = SyntaxError{"sequence truncated"} } - return; + return } // Deal with raw values. if fieldType == rawValueType { - var t tagAndLength; - t, offset, err = parseTagAndLength(bytes, offset); + var t tagAndLength + t, offset, err = parseTagAndLength(bytes, offset) if err != nil { return } if invalidLength(offset, t.length, len(bytes)) { - err = SyntaxError{"data truncated"}; - return; + err = SyntaxError{"data truncated"} + return } - result := RawValue{t.class, t.tag, t.isCompound, bytes[offset : offset+t.length]}; - offset += t.length; - v.(*reflect.StructValue).Set(reflect.NewValue(result).(*reflect.StructValue)); - return; + result := RawValue{t.class, t.tag, t.isCompound, bytes[offset : offset+t.length]} + offset += t.length + v.(*reflect.StructValue).Set(reflect.NewValue(result).(*reflect.StructValue)) + return } // Deal with the ANY type. if ifaceType, ok := fieldType.(*reflect.InterfaceType); ok && ifaceType.NumMethod() == 0 { - ifaceValue := v.(*reflect.InterfaceValue); - var t tagAndLength; - t, offset, err = parseTagAndLength(bytes, offset); + ifaceValue := v.(*reflect.InterfaceValue) + var t tagAndLength + t, offset, err = parseTagAndLength(bytes, offset) if err != nil { return } if invalidLength(offset, t.length, len(bytes)) { - err = SyntaxError{"data truncated"}; - return; + err = SyntaxError{"data truncated"} + return } var result interface{} if !t.isCompound && t.class == classUniversal { - innerBytes := bytes[offset : offset+t.length]; + innerBytes := bytes[offset : offset+t.length] switch t.tag { case tagPrintableString: result, err = parsePrintableString(innerBytes) @@ -540,40 +540,40 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam // If we don't know how to handle the type, we just leave Value as nil. } } - offset += t.length; + offset += t.length if err != nil { return } if result != nil { ifaceValue.Set(reflect.NewValue(result)) } - return; + return } - universalTag, compoundType, ok1 := getUniversalType(fieldType); + universalTag, compoundType, ok1 := getUniversalType(fieldType) if !ok1 { - err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)}; - return; + err = StructuralError{fmt.Sprintf("unknown Go type: %v", fieldType)} + return } - t, offset, err := parseTagAndLength(bytes, offset); + t, offset, err := parseTagAndLength(bytes, offset) if err != nil { return } if params.explicit { if t.class == classContextSpecific && t.tag == *params.tag && t.isCompound { - t, offset, err = parseTagAndLength(bytes, offset); + t, offset, err = parseTagAndLength(bytes, offset) if err != nil { return } } else { // The tags didn't match, it might be an optional element. - ok := setDefaultValue(v, params); + ok := setDefaultValue(v, params) if ok { offset = initOffset } else { err = StructuralError{"explicitly tagged member didn't match"} } - return; + return } } @@ -585,128 +585,128 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam universalTag = tagIA5String } - expectedClass := classUniversal; - expectedTag := universalTag; + expectedClass := classUniversal + expectedTag := universalTag if !params.explicit && params.tag != nil { - expectedClass = classContextSpecific; - expectedTag = *params.tag; + expectedClass = classContextSpecific + expectedTag = *params.tag } // We have unwrapped any explicit tagging at this point. if t.class != expectedClass || t.tag != expectedTag || t.isCompound != compoundType { // Tags don't match. Again, it could be an optional element. - ok := setDefaultValue(v, params); + ok := setDefaultValue(v, params) if ok { offset = initOffset } else { err = StructuralError{fmt.Sprintf("tags don't match (%d vs %+v) %+v %s @%d", expectedTag, t, params, fieldType.Name(), offset)} } - return; + return } if invalidLength(offset, t.length, len(bytes)) { - err = SyntaxError{"data truncated"}; - return; + err = SyntaxError{"data truncated"} + return } - innerBytes := bytes[offset : offset+t.length]; + innerBytes := bytes[offset : offset+t.length] // We deal with the structures defined in this package first. switch fieldType { case objectIdentifierType: - newSlice, err1 := parseObjectIdentifier(innerBytes); - sliceValue := v.(*reflect.SliceValue); - sliceValue.Set(reflect.MakeSlice(sliceValue.Type().(*reflect.SliceType), len(newSlice), len(newSlice))); + newSlice, err1 := parseObjectIdentifier(innerBytes) + sliceValue := v.(*reflect.SliceValue) + sliceValue.Set(reflect.MakeSlice(sliceValue.Type().(*reflect.SliceType), len(newSlice), len(newSlice))) if err1 == nil { reflect.ArrayCopy(sliceValue, reflect.NewValue(newSlice).(reflect.ArrayOrSliceValue)) } - offset += t.length; - err = err1; - return; + offset += t.length + err = err1 + return case bitStringType: - structValue := v.(*reflect.StructValue); - bs, err1 := parseBitString(innerBytes); - offset += t.length; + structValue := v.(*reflect.StructValue) + bs, err1 := parseBitString(innerBytes) + offset += t.length if err1 == nil { structValue.Set(reflect.NewValue(bs).(*reflect.StructValue)) } - err = err1; - return; + err = err1 + return case timeType: - ptrValue := v.(*reflect.PtrValue); - time, err1 := parseUTCTime(innerBytes); - offset += t.length; + ptrValue := v.(*reflect.PtrValue) + time, err1 := parseUTCTime(innerBytes) + offset += t.length if err1 == nil { ptrValue.Set(reflect.NewValue(time).(*reflect.PtrValue)) } - err = err1; - return; + err = err1 + return } switch val := v.(type) { case *reflect.BoolValue: - parsedBool, err1 := parseBool(innerBytes); - offset += t.length; + parsedBool, err1 := parseBool(innerBytes) + offset += t.length if err1 == nil { val.Set(parsedBool) } - err = err1; - return; + err = err1 + return case *reflect.IntValue: - parsedInt, err1 := parseInt(innerBytes); - offset += t.length; + parsedInt, err1 := parseInt(innerBytes) + offset += t.length if err1 == nil { val.Set(parsedInt) } - err = err1; - return; + err = err1 + return case *reflect.Int64Value: - parsedInt, err1 := parseInt64(innerBytes); - offset += t.length; + parsedInt, err1 := parseInt64(innerBytes) + offset += t.length if err1 == nil { val.Set(parsedInt) } - err = err1; - return; + err = err1 + return case *reflect.StructValue: - structType := fieldType.(*reflect.StructType); + structType := fieldType.(*reflect.StructType) if structType.NumField() > 0 && structType.Field(0).Type == rawContentsType { - bytes := bytes[initOffset : offset+t.length]; - val.Field(0).SetValue(reflect.NewValue(RawContent(bytes))); + bytes := bytes[initOffset : offset+t.length] + val.Field(0).SetValue(reflect.NewValue(RawContent(bytes))) } - innerOffset := 0; + innerOffset := 0 for i := 0; i < structType.NumField(); i++ { - field := structType.Field(i); + field := structType.Field(i) if i == 0 && field.Type == rawContentsType { continue } - innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag)); + innerOffset, err = parseField(val.Field(i), innerBytes, innerOffset, parseFieldParameters(field.Tag)) if err != nil { return } } - offset += t.length; + offset += t.length // We allow extra bytes at the end of the SEQUENCE because // adding elements to the end has been used in X.509 as the // version numbers have increased. - return; + return case *reflect.SliceValue: - sliceType := fieldType.(*reflect.SliceType); + sliceType := fieldType.(*reflect.SliceType) if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok { - val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes))); - reflect.ArrayCopy(val, reflect.NewValue(innerBytes).(reflect.ArrayOrSliceValue)); - return; + val.Set(reflect.MakeSlice(sliceType, len(innerBytes), len(innerBytes))) + reflect.ArrayCopy(val, reflect.NewValue(innerBytes).(reflect.ArrayOrSliceValue)) + return } - newSlice, err1 := parseSequenceOf(innerBytes, sliceType, sliceType.Elem()); - offset += t.length; + newSlice, err1 := parseSequenceOf(innerBytes, sliceType, sliceType.Elem()) + offset += t.length if err1 == nil { val.Set(newSlice) } - err = err1; - return; + err = err1 + return case *reflect.StringValue: - var v string; + var v string switch universalTag { case tagPrintableString: v, err = parsePrintableString(innerBytes) @@ -718,10 +718,10 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam if err == nil { val.Set(v) } - return; + return } - err = StructuralError{"unknown Go type"}; - return; + err = StructuralError{"unknown Go type"} + return } // setDefaultValue is used to install a default value, from a tag string, into @@ -731,7 +731,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) { if !params.optional { return } - ok = true; + ok = true if params.defaultValue == nil { return } @@ -741,7 +741,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) { case *reflect.Int64Value: val.Set(int64(*params.defaultValue)) } - return; + return } // Unmarshal parses the DER-encoded ASN.1 data structure b @@ -785,10 +785,10 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) { // Other ASN.1 types are not supported; if it encounters them, // Unmarshal returns a parse error. func Unmarshal(val interface{}, b []byte) (rest []byte, err os.Error) { - v := reflect.NewValue(val).(*reflect.PtrValue).Elem(); - offset, err := parseField(v, b, 0, fieldParameters{}); + v := reflect.NewValue(val).(*reflect.PtrValue).Elem() + offset, err := parseField(v, b, 0, fieldParameters{}) if err != nil { return nil, err } - return b[offset:], nil; + return b[offset:], nil } diff --git a/src/pkg/asn1/asn1_test.go b/src/pkg/asn1/asn1_test.go index 6f677ffb6..5071facfc 100644 --- a/src/pkg/asn1/asn1_test.go +++ b/src/pkg/asn1/asn1_test.go @@ -5,17 +5,17 @@ package asn1 import ( - "bytes"; - "reflect"; - "strings"; - "testing"; - "time"; + "bytes" + "reflect" + "strings" + "testing" + "time" ) type int64Test struct { - in []byte; - ok bool; - out int64; + in []byte + ok bool + out int64 } var int64TestData = []int64Test{ @@ -33,7 +33,7 @@ var int64TestData = []int64Test{ func TestParseInt64(t *testing.T) { for i, test := range int64TestData { - ret, err := parseInt64(test.in); + ret, err := parseInt64(test.in) if (err == nil) != test.ok { t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok) } @@ -44,10 +44,10 @@ func TestParseInt64(t *testing.T) { } type bitStringTest struct { - in []byte; - ok bool; - out []byte; - bitLength int; + in []byte + ok bool + out []byte + bitLength int } var bitStringTestData = []bitStringTest{ @@ -61,7 +61,7 @@ var bitStringTestData = []bitStringTest{ func TestBitString(t *testing.T) { for i, test := range bitStringTestData { - ret, err := parseBitString(test.in); + ret, err := parseBitString(test.in) if (err == nil) != test.ok { t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok) } @@ -74,7 +74,7 @@ func TestBitString(t *testing.T) { } func TestBitStringAt(t *testing.T) { - bs := BitString{[]byte{0x82, 0x40}, 16}; + bs := BitString{[]byte{0x82, 0x40}, 16} if bs.At(0) != 1 { t.Error("#1: Failed") } @@ -90,9 +90,9 @@ func TestBitStringAt(t *testing.T) { } type bitStringRightAlignTest struct { - in []byte; - inlen int; - out []byte; + in []byte + inlen int + out []byte } var bitStringRightAlignTests = []bitStringRightAlignTest{ @@ -106,8 +106,8 @@ var bitStringRightAlignTests = []bitStringRightAlignTest{ func TestBitStringRightAlign(t *testing.T) { for i, test := range bitStringRightAlignTests { - bs := BitString{test.in, test.inlen}; - out := bs.RightAlign(); + bs := BitString{test.in, test.inlen} + out := bs.RightAlign() if bytes.Compare(out, test.out) != 0 { t.Errorf("#%d got: %x want: %x", i, out, test.out) } @@ -115,9 +115,9 @@ func TestBitStringRightAlign(t *testing.T) { } type objectIdentifierTest struct { - in []byte; - ok bool; - out []int; + in []byte + ok bool + out []int } var objectIdentifierTestData = []objectIdentifierTest{ @@ -130,7 +130,7 @@ var objectIdentifierTestData = []objectIdentifierTest{ func TestObjectIdentifier(t *testing.T) { for i, test := range objectIdentifierTestData { - ret, err := parseObjectIdentifier(test.in); + ret, err := parseObjectIdentifier(test.in) if (err == nil) != test.ok { t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok) } @@ -143,9 +143,9 @@ func TestObjectIdentifier(t *testing.T) { } type timeTest struct { - in string; - ok bool; - out *time.Time; + in string + ok bool + out *time.Time } var timeTestData = []timeTest{ @@ -165,7 +165,7 @@ var timeTestData = []timeTest{ func TestTime(t *testing.T) { for i, test := range timeTestData { - ret, err := parseUTCTime(strings.Bytes(test.in)); + ret, err := parseUTCTime(strings.Bytes(test.in)) if (err == nil) != test.ok { t.Errorf("#%d: Incorrect error result (did fail? %v, expected: %v)", i, err == nil, test.ok) } @@ -178,9 +178,9 @@ func TestTime(t *testing.T) { } type tagAndLengthTest struct { - in []byte; - ok bool; - out tagAndLength; + in []byte + ok bool + out tagAndLength } var tagAndLengthData = []tagAndLengthTest{ @@ -200,7 +200,7 @@ var tagAndLengthData = []tagAndLengthTest{ func TestParseTagAndLength(t *testing.T) { for i, test := range tagAndLengthData { - tagAndLength, _, err := parseTagAndLength(test.in, 0); + tagAndLength, _, err := parseTagAndLength(test.in, 0) if (err == nil) != test.ok { t.Errorf("#%d: Incorrect error result (did pass? %v, expected: %v)", i, err == nil, test.ok) } @@ -211,17 +211,17 @@ func TestParseTagAndLength(t *testing.T) { } type parseFieldParametersTest struct { - in string; - out fieldParameters; + in string + out fieldParameters } -func newInt(n int) *int { return &n } +func newInt(n int) *int { return &n } -func newInt64(n int64) *int64 { return &n } +func newInt64(n int64) *int64 { return &n } -func newString(s string) *string { return &s } +func newString(s string) *string { return &s } -func newBool(b bool) *bool { return &b } +func newBool(b bool) *bool { return &b } var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParametersTest{ parseFieldParametersTest{"", fieldParameters{false, false, nil, nil, 0}}, @@ -238,7 +238,7 @@ var parseFieldParametersTestData []parseFieldParametersTest = []parseFieldParame func TestParseFieldParameters(t *testing.T) { for i, test := range parseFieldParametersTestData { - f := parseFieldParameters(test.in); + f := parseFieldParameters(test.in) if !reflect.DeepEqual(f, test.out) { t.Errorf("#%d: Bad result: %v (expected %v)", i, f, test.out) } @@ -246,21 +246,21 @@ func TestParseFieldParameters(t *testing.T) { } type unmarshalTest struct { - in []byte; - out interface{}; + in []byte + out interface{} } type TestObjectIdentifierStruct struct { - OID ObjectIdentifier; + OID ObjectIdentifier } type TestContextSpecificTags struct { - A int "tag:1"; + A int "tag:1" } type TestContextSpecificTags2 struct { - A int "explicit,tag:1"; - B int; + A int "explicit,tag:1" + B int } var unmarshalTestData []unmarshalTest = []unmarshalTest{ @@ -281,11 +281,11 @@ var unmarshalTestData []unmarshalTest = []unmarshalTest{ func TestUnmarshal(t *testing.T) { for i, test := range unmarshalTestData { - pv := reflect.MakeZero(reflect.NewValue(test.out).Type()); - zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem()); - pv.(*reflect.PtrValue).PointTo(zv); - val := pv.Interface(); - _, err := Unmarshal(val, test.in); + pv := reflect.MakeZero(reflect.NewValue(test.out).Type()) + zv := reflect.MakeZero(pv.Type().(*reflect.PtrType).Elem()) + pv.(*reflect.PtrValue).PointTo(zv) + val := pv.Interface() + _, err := Unmarshal(val, test.in) if err != nil { t.Errorf("Unmarshal failed at index %d %v", i, err) } @@ -296,23 +296,23 @@ func TestUnmarshal(t *testing.T) { } type Certificate struct { - TBSCertificate TBSCertificate; - SignatureAlgorithm AlgorithmIdentifier; - SignatureValue BitString; + TBSCertificate TBSCertificate + SignatureAlgorithm AlgorithmIdentifier + SignatureValue BitString } type TBSCertificate struct { - Version int "optional,explicit,default:0,tag:0"; - SerialNumber RawValue; - SignatureAlgorithm AlgorithmIdentifier; - Issuer RDNSequence; - Validity Validity; - Subject RDNSequence; - PublicKey PublicKeyInfo; + Version int "optional,explicit,default:0,tag:0" + SerialNumber RawValue + SignatureAlgorithm AlgorithmIdentifier + Issuer RDNSequence + Validity Validity + Subject RDNSequence + PublicKey PublicKeyInfo } type AlgorithmIdentifier struct { - Algorithm ObjectIdentifier; + Algorithm ObjectIdentifier } type RDNSequence []RelativeDistinguishedName @@ -320,22 +320,22 @@ type RDNSequence []RelativeDistinguishedName type RelativeDistinguishedName []AttributeTypeAndValue type AttributeTypeAndValue struct { - Type ObjectIdentifier; - Value interface{}; + Type ObjectIdentifier + Value interface{} } type Validity struct { - NotBefore, NotAfter *time.Time; + NotBefore, NotAfter *time.Time } type PublicKeyInfo struct { - Algorithm AlgorithmIdentifier; - PublicKey BitString; + Algorithm AlgorithmIdentifier + PublicKey BitString } func TestCertificate(t *testing.T) { // This is a minimal, self-signed certificate that should parse correctly. - var cert Certificate; + var cert Certificate if _, err := Unmarshal(&cert, derEncodedSelfSignedCertBytes); err != nil { t.Errorf("Unmarshal failed: %v", err) } @@ -348,29 +348,29 @@ func TestCertificateWithNUL(t *testing.T) { // This is the paypal NUL-hack certificate. It should fail to parse because // NUL isn't a permitted character in a PrintableString. - var cert Certificate; + var cert Certificate if _, err := Unmarshal(&cert, derEncodedPaypalNULCertBytes); err == nil { t.Error("Unmarshal succeeded, should not have") } } type rawStructTest struct { - Raw RawContent; - A int; + Raw RawContent + A int } func TestRawStructs(t *testing.T) { - var s rawStructTest; - input := []byte{0x30, 0x03, 0x02, 0x01, 0x50}; + var s rawStructTest + input := []byte{0x30, 0x03, 0x02, 0x01, 0x50} - rest, err := Unmarshal(&s, input); + rest, err := Unmarshal(&s, input) if len(rest) != 0 { - t.Errorf("incomplete parse: %x", rest); - return; + t.Errorf("incomplete parse: %x", rest) + return } if err != nil { - t.Error(err); - return; + t.Error(err) + return } if s.A != 0x50 { t.Errorf("bad value for A: got %d want %d", s.A, 0x50) diff --git a/src/pkg/asn1/common.go b/src/pkg/asn1/common.go index bdc4c8abd..a3278b639 100644 --- a/src/pkg/asn1/common.go +++ b/src/pkg/asn1/common.go @@ -5,9 +5,9 @@ package asn1 import ( - "reflect"; - "strconv"; - "strings"; + "reflect" + "strconv" + "strings" ) // ASN.1 objects have metadata preceeding them: @@ -19,28 +19,28 @@ import ( // Here are some standard tags and classes const ( - tagBoolean = 1; - tagInteger = 2; - tagBitString = 3; - tagOctetString = 4; - tagOID = 6; - tagSequence = 16; - tagSet = 17; - tagPrintableString = 19; - tagIA5String = 22; - tagUTCTime = 23; + tagBoolean = 1 + tagInteger = 2 + tagBitString = 3 + tagOctetString = 4 + tagOID = 6 + tagSequence = 16 + tagSet = 17 + tagPrintableString = 19 + tagIA5String = 22 + tagUTCTime = 23 ) const ( - classUniversal = 0; - classApplication = 1; - classContextSpecific = 2; - classPrivate = 3; + classUniversal = 0 + classApplication = 1 + classContextSpecific = 2 + classPrivate = 3 ) type tagAndLength struct { - class, tag, length int; - isCompound bool; + class, tag, length int + isCompound bool } // ASN.1 has IMPLICIT and EXPLICIT tags, which can be translated as "instead @@ -63,11 +63,11 @@ type tagAndLength struct { // fieldParameters is the parsed representation of tag string from a structure field. type fieldParameters struct { - optional bool; // true iff the field is OPTIONAL - explicit bool; // true iff and EXPLICIT tag is in use. - defaultValue *int64; // a default value for INTEGER typed fields (maybe nil). - tag *int; // the EXPLICIT or IMPLICIT tag (maybe nil). - stringType int; // the string tag to use when marshaling. + optional bool // true iff the field is OPTIONAL + explicit bool // true iff and EXPLICIT tag is in use. + defaultValue *int64 // a default value for INTEGER typed fields (maybe nil). + tag *int // the EXPLICIT or IMPLICIT tag (maybe nil). + stringType int // the string tag to use when marshaling. // Invariants: // if explicit is set, tag is non-nil. @@ -82,30 +82,30 @@ func parseFieldParameters(str string) (ret fieldParameters) { case part == "optional": ret.optional = true case part == "explicit": - ret.explicit = true; + ret.explicit = true if ret.tag == nil { - ret.tag = new(int); - *ret.tag = 0; + ret.tag = new(int) + *ret.tag = 0 } case part == "ia5": ret.stringType = tagIA5String case part == "printable": ret.stringType = tagPrintableString case strings.HasPrefix(part, "default:"): - i, err := strconv.Atoi64(part[8:]); + i, err := strconv.Atoi64(part[8:]) if err == nil { - ret.defaultValue = new(int64); - *ret.defaultValue = i; + ret.defaultValue = new(int64) + *ret.defaultValue = i } case strings.HasPrefix(part, "tag:"): - i, err := strconv.Atoi(part[4:]); + i, err := strconv.Atoi(part[4:]) if err == nil { - ret.tag = new(int); - *ret.tag = i; + ret.tag = new(int) + *ret.tag = i } } } - return; + return } // Given a reflected Go type, getUniversalType returns the default tag number @@ -132,9 +132,9 @@ func getUniversalType(t reflect.Type) (tagNumber int, isCompound, ok bool) { if _, ok := t.(*reflect.SliceType).Elem().(*reflect.Uint8Type); ok { return tagOctetString, false, true } - return tagSequence, true, true; + return tagSequence, true, true case *reflect.StringType: return tagPrintableString, false, true } - return 0, false, false; + return 0, false, false } diff --git a/src/pkg/asn1/marshal.go b/src/pkg/asn1/marshal.go index 2e9aa1439..eec0ee849 100644 --- a/src/pkg/asn1/marshal.go +++ b/src/pkg/asn1/marshal.go @@ -5,13 +5,13 @@ package asn1 import ( - "bytes"; - "fmt"; - "io"; - "os"; - "reflect"; - "strings"; - "time"; + "bytes" + "fmt" + "io" + "os" + "reflect" + "strings" + "time" ) // A forkableWriter is an in-memory buffer that can be @@ -20,8 +20,8 @@ import ( // pre, post := w.fork(); // the overall sequence of bytes represented is logically w+pre+post. type forkableWriter struct { - *bytes.Buffer; - pre, post *forkableWriter; + *bytes.Buffer + pre, post *forkableWriter } func newForkableWriter() *forkableWriter { @@ -29,65 +29,65 @@ func newForkableWriter() *forkableWriter { } func (f *forkableWriter) fork() (pre, post *forkableWriter) { - f.pre = newForkableWriter(); - f.post = newForkableWriter(); - return f.pre, f.post; + f.pre = newForkableWriter() + f.post = newForkableWriter() + return f.pre, f.post } func (f *forkableWriter) Len() (l int) { - l += f.Buffer.Len(); + l += f.Buffer.Len() if f.pre != nil { l += f.pre.Len() } if f.post != nil { l += f.post.Len() } - return; + return } func (f *forkableWriter) writeTo(out io.Writer) (n int, err os.Error) { - n, err = out.Write(f.Bytes()); + n, err = out.Write(f.Bytes()) if err != nil { return } - var nn int; + var nn int if f.pre != nil { - nn, err = f.pre.writeTo(out); - n += nn; + nn, err = f.pre.writeTo(out) + n += nn if err != nil { return } } if f.pre != nil { - nn, err = f.post.writeTo(out); - n += nn; + nn, err = f.post.writeTo(out) + n += nn } - return; + return } func marshalBase128Int(out *forkableWriter, i int64) (err os.Error) { if i == 0 { - err = out.WriteByte(0); - return; + err = out.WriteByte(0) + return } for i > 0 { - next := i >> 7; - o := byte(i & 0x7f); + next := i >> 7 + o := byte(i & 0x7f) if next > 0 { o |= 0x80 } - err = out.WriteByte(o); + err = out.WriteByte(o) if err != nil { return } - i = next; + i = next } - return nil; + return nil } func base128Length(i int) (numBytes int) { @@ -96,63 +96,63 @@ func base128Length(i int) (numBytes int) { } for i > 0 { - numBytes++; - i >>= 7; + numBytes++ + i >>= 7 } - return; + return } func marshalTagAndLength(out *forkableWriter, t tagAndLength) (err os.Error) { - b := uint8(t.class) << 6; + b := uint8(t.class) << 6 if t.isCompound { b |= 0x20 } if t.tag >= 31 { - b |= 0x1f; - err = out.WriteByte(b); + b |= 0x1f + err = out.WriteByte(b) if err != nil { return } - err = marshalBase128Int(out, int64(t.tag)); + err = marshalBase128Int(out, int64(t.tag)) if err != nil { return } } else { - b |= uint8(t.tag); - err = out.WriteByte(b); + b |= uint8(t.tag) + err = out.WriteByte(b) if err != nil { return } } if t.length >= 128 { - err = out.WriteByte(byte(base128Length(t.length))); + err = out.WriteByte(byte(base128Length(t.length))) if err != nil { return } - err = marshalBase128Int(out, int64(t.length)); + err = marshalBase128Int(out, int64(t.length)) if err != nil { return } } else { - err = out.WriteByte(byte(t.length)); + err = out.WriteByte(byte(t.length)) if err != nil { return } } - return nil; + return nil } func marshalBitString(out *forkableWriter, b BitString) (err os.Error) { - paddingBits := byte((8 - b.BitLength%8) % 8); - err = out.WriteByte(paddingBits); + paddingBits := byte((8 - b.BitLength%8) % 8) + err = out.WriteByte(paddingBits) if err != nil { return } - _, err = out.Write(b.Bytes); - return; + _, err = out.Write(b.Bytes) + return } func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) { @@ -160,50 +160,50 @@ func marshalObjectIdentifier(out *forkableWriter, oid []int) (err os.Error) { return StructuralError{"invalid object identifier"} } - err = out.WriteByte(byte(oid[0]*40 + oid[1])); + err = out.WriteByte(byte(oid[0]*40 + oid[1])) if err != nil { return } for i := 2; i < len(oid); i++ { - err = marshalBase128Int(out, int64(oid[i])); + err = marshalBase128Int(out, int64(oid[i])) if err != nil { return } } - return; + return } func marshalPrintableString(out *forkableWriter, s string) (err os.Error) { - b := strings.Bytes(s); + b := strings.Bytes(s) for _, c := range b { if !isPrintable(c) { return StructuralError{"PrintableString contains invalid character"} } } - _, err = out.Write(b); - return; + _, err = out.Write(b) + return } func marshalIA5String(out *forkableWriter, s string) (err os.Error) { - b := strings.Bytes(s); + b := strings.Bytes(s) for _, c := range b { if c > 127 { return StructuralError{"IA5String contains invalid character"} } } - _, err = out.Write(b); - return; + _, err = out.Write(b) + return } func marshalTwoDigits(out *forkableWriter, v int) (err os.Error) { - err = out.WriteByte(byte('0' + (v/10)%10)); + err = out.WriteByte(byte('0' + (v/10)%10)) if err != nil { return } - return out.WriteByte(byte('0' + v%10)); + return out.WriteByte(byte('0' + v%10)) } func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) { @@ -220,35 +220,35 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) { return } - err = marshalTwoDigits(out, t.Month); + err = marshalTwoDigits(out, t.Month) if err != nil { return } - err = marshalTwoDigits(out, t.Day); + err = marshalTwoDigits(out, t.Day) if err != nil { return } - err = marshalTwoDigits(out, t.Hour); + err = marshalTwoDigits(out, t.Hour) if err != nil { return } - err = marshalTwoDigits(out, t.Minute); + err = marshalTwoDigits(out, t.Minute) if err != nil { return } - err = marshalTwoDigits(out, t.Second); + err = marshalTwoDigits(out, t.Second) if err != nil { return } switch { case t.ZoneOffset/60 == 0: - err = out.WriteByte('Z'); - return; + err = out.WriteByte('Z') + return case t.ZoneOffset > 0: err = out.WriteByte('+') case t.ZoneOffset < 0: @@ -259,18 +259,18 @@ func marshalUTCTime(out *forkableWriter, t *time.Time) (err os.Error) { return } - offsetMinutes := t.ZoneOffset / 60; + offsetMinutes := t.ZoneOffset / 60 if offsetMinutes < 0 { offsetMinutes = -offsetMinutes } - err = marshalTwoDigits(out, offsetMinutes/60); + err = marshalTwoDigits(out, offsetMinutes/60) if err != nil { return } - err = marshalTwoDigits(out, offsetMinutes%60); - return; + err = marshalTwoDigits(out, offsetMinutes%60) + return } func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameters) (err os.Error) { @@ -295,81 +295,81 @@ func marshalBody(out *forkableWriter, value reflect.Value, params fieldParameter case *reflect.Int64Value: return marshalBase128Int(out, v.Get()) case *reflect.StructValue: - t := v.Type().(*reflect.StructType); + t := v.Type().(*reflect.StructType) for i := 0; i < t.NumField(); i++ { - err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag)); + err = marshalField(out, v.Field(i), parseFieldParameters(t.Field(i).Tag)) if err != nil { return } } - return; + return case *reflect.SliceValue: - sliceType := v.Type().(*reflect.SliceType); + sliceType := v.Type().(*reflect.SliceType) if _, ok := sliceType.Elem().(*reflect.Uint8Type); ok { - bytes := make([]byte, v.Len()); + bytes := make([]byte, v.Len()) for i := 0; i < v.Len(); i++ { bytes[i] = v.Elem(i).(*reflect.Uint8Value).Get() } - _, err = out.Write(bytes); - return; + _, err = out.Write(bytes) + return } - var params fieldParameters; + var params fieldParameters for i := 0; i < v.Len(); i++ { - err = marshalField(out, v.Elem(i), params); + err = marshalField(out, v.Elem(i), params) if err != nil { return } } - return; + return case *reflect.StringValue: if params.stringType == tagIA5String { return marshalIA5String(out, v.Get()) } else { return marshalPrintableString(out, v.Get()) } - return; + return } - return StructuralError{"unknown Go type"}; + return StructuralError{"unknown Go type"} } func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) (err os.Error) { - tag, isCompound, ok := getUniversalType(v.Type()); + tag, isCompound, ok := getUniversalType(v.Type()) if !ok { - err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())}; - return; + err = StructuralError{fmt.Sprintf("unknown Go type: %v", v.Type())} + return } - class := classUniversal; + class := classUniversal if params.stringType != 0 { if tag != tagPrintableString { return StructuralError{"Explicit string type given to non-string member"} } - tag = params.stringType; + tag = params.stringType } - tags, body := out.fork(); + tags, body := out.fork() - err = marshalBody(body, v, params); + err = marshalBody(body, v, params) if err != nil { return } - bodyLen := body.Len(); + bodyLen := body.Len() - var explicitTag *forkableWriter; + var explicitTag *forkableWriter if params.explicit { explicitTag, tags = tags.fork() } if !params.explicit && params.tag != nil { // implicit tag. - tag = *params.tag; - class = classContextSpecific; + tag = *params.tag + class = classContextSpecific } - err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound}); + err = marshalTagAndLength(tags, tagAndLength{class, tag, bodyLen, isCompound}) if err != nil { return } @@ -383,18 +383,18 @@ func marshalField(out *forkableWriter, v reflect.Value, params fieldParameters) }) } - return nil; + return nil } // Marshal serialises val as an ASN.1 structure and writes the result to out. // In the case of an error, no output is produced. func Marshal(out io.Writer, val interface{}) os.Error { - v := reflect.NewValue(val); - f := newForkableWriter(); - err := marshalField(f, v, fieldParameters{}); + v := reflect.NewValue(val) + f := newForkableWriter() + err := marshalField(f, v, fieldParameters{}) if err != nil { return err } - _, err = f.writeTo(out); - return err; + _, err = f.writeTo(out) + return err } diff --git a/src/pkg/asn1/marshal_test.go b/src/pkg/asn1/marshal_test.go index c2ce1e476..2bb8a28d9 100644 --- a/src/pkg/asn1/marshal_test.go +++ b/src/pkg/asn1/marshal_test.go @@ -5,44 +5,44 @@ package asn1 import ( - "bytes"; - "encoding/hex"; - "testing"; - "time"; + "bytes" + "encoding/hex" + "testing" + "time" ) type intStruct struct { - A int; + A int } type nestedStruct struct { - A intStruct; + A intStruct } type marshalTest struct { - in interface{}; - out string; // hex encoded + in interface{} + out string // hex encoded } type implicitTagTest struct { - A int "implicit,tag:5"; + A int "implicit,tag:5" } type explicitTagTest struct { - A int "explicit,tag:5"; + A int "explicit,tag:5" } type ia5StringTest struct { - A string "ia5"; + A string "ia5" } type printableStringTest struct { - A string "printable"; + A string "printable" } func setPST(t *time.Time) *time.Time { - t.ZoneOffset = -28800; - return t; + t.ZoneOffset = -28800 + return t } var marshalTests = []marshalTest{ @@ -65,12 +65,12 @@ var marshalTests = []marshalTest{ func TestMarshal(t *testing.T) { for i, test := range marshalTests { - buf := bytes.NewBuffer(nil); - err := Marshal(buf, test.in); + buf := bytes.NewBuffer(nil) + err := Marshal(buf, test.in) if err != nil { t.Errorf("#%d failed: %s", i, err) } - out, _ := hex.DecodeString(test.out); + out, _ := hex.DecodeString(test.out) if bytes.Compare(out, buf.Bytes()) != 0 { t.Errorf("#%d got: %x want %x", i, buf.Bytes(), out) } diff --git a/src/pkg/big/arith.go b/src/pkg/big/arith.go index 3dcbe637f..81ce23a3a 100644 --- a/src/pkg/big/arith.go +++ b/src/pkg/big/arith.go @@ -13,14 +13,14 @@ import "unsafe" type Word uintptr const ( - _S = uintptr(unsafe.Sizeof(Word(0))); // TODO(gri) should Sizeof return a uintptr? - _logW = (0x650 >> _S) & 7; - _W = 1 << _logW; - _B = 1 << _W; - _M = _B - 1; - _W2 = _W / 2; - _B2 = 1 << _W2; - _M2 = _B2 - 1; + _S = uintptr(unsafe.Sizeof(Word(0))) // TODO(gri) should Sizeof return a uintptr? + _logW = (0x650 >> _S) & 7 + _W = 1 << _logW + _B = 1 << _W + _M = _B - 1 + _W2 = _W / 2 + _B2 = 1 << _W2 + _M2 = _B2 - 1 ) @@ -31,23 +31,23 @@ const ( // z1<<_W + z0 = x+y+c, with c == 0 or 1 func addWW_g(x, y, c Word) (z1, z0 Word) { - yc := y + c; - z0 = x + yc; + yc := y + c + z0 = x + yc if z0 < x || yc < y { z1 = 1 } - return; + return } // z1<<_W + z0 = x-y-c, with c == 0 or 1 func subWW_g(x, y, c Word) (z1, z0 Word) { - yc := y + c; - z0 = x - yc; + yc := y + c + z0 = x - yc if z0 > x || yc < y { z1 = 1 } - return; + return } @@ -65,62 +65,62 @@ func mulWW_g(x, y Word) (z1, z0 Word) { // y < _B2 because y <= x // sub-digits of x and y are (0, x) and (0, y) // z = z[0] = x*y - z0 = x * y; - return; + z0 = x * y + return } if y < _B2 { // sub-digits of x and y are (x1, x0) and (0, y) // x = (x1*_B2 + x0) // y = (y1*_B2 + y0) - x1, x0 := x>>_W2, x&_M2; + x1, x0 := x>>_W2, x&_M2 // x*y = t2*_B2*_B2 + t1*_B2 + t0 - t0 := x0 * y; - t1 := x1 * y; + t0 := x0 * y + t1 := x1 * y // compute result digits but avoid overflow // z = z[1]*_B + z[0] = x*y - z0 = t1<<_W2 + t0; - z1 = (t1 + t0>>_W2) >> _W2; - return; + z0 = t1<<_W2 + t0 + z1 = (t1 + t0>>_W2) >> _W2 + return } // general case // sub-digits of x and y are (x1, x0) and (y1, y0) // x = (x1*_B2 + x0) // y = (y1*_B2 + y0) - x1, x0 := x>>_W2, x&_M2; - y1, y0 := y>>_W2, y&_M2; + x1, x0 := x>>_W2, x&_M2 + y1, y0 := y>>_W2, y&_M2 // x*y = t2*_B2*_B2 + t1*_B2 + t0 - t0 := x0 * y0; + t0 := x0 * y0 // t1 := x1*y0 + x0*y1; - var c Word; - t1 := x1 * y0; - t1a := t1; - t1 += x0 * y1; + var c Word + t1 := x1 * y0 + t1a := t1 + t1 += x0 * y1 if t1 < t1a { c++ } - t2 := x1*y1 + c*_B2; + t2 := x1*y1 + c*_B2 // compute result digits but avoid overflow // z = z[1]*_B + z[0] = x*y // This may overflow, but that's ok because we also sum t1 and t0 above // and we take care of the overflow there. - z0 = t1<<_W2 + t0; + z0 = t1<<_W2 + t0 // z1 = t2 + (t1 + t0>>_W2)>>_W2; - var c3 Word; - z1 = t1 + t0>>_W2; + var c3 Word + z1 = t1 + t0>>_W2 if z1 < t1 { c3++ } - z1 >>= _W2; - z1 += c3 * _B2; - z1 += t2; - return; + z1 >>= _W2 + z1 += c3 * _B2 + z1 += t2 + return } @@ -136,78 +136,78 @@ func mulAddWWW_g(x, y, c Word) (z1, z0 Word) { // sub-digits of x, y, and c are (x1, x0), (y1, y0), (c1, c0) // x = (x1*_B2 + x0) // y = (y1*_B2 + y0) - x1, x0 := x>>_W2, x&_M2; - y1, y0 := y>>_W2, y&_M2; - c1, c0 := c>>_W2, c&_M2; + x1, x0 := x>>_W2, x&_M2 + y1, y0 := y>>_W2, y&_M2 + c1, c0 := c>>_W2, c&_M2 // x*y + c = t2*_B2*_B2 + t1*_B2 + t0 // (1<<32-1)^2 == 1<<64 - 1<<33 + 1, so there's space to add c0 in here. - t0 := x0*y0 + c0; + t0 := x0*y0 + c0 // t1 := x1*y0 + x0*y1 + c1; - var c2 Word; // extra carry - t1 := x1*y0 + c1; - t1a := t1; - t1 += x0 * y1; - if t1 < t1a { // If the number got smaller then we overflowed. + var c2 Word // extra carry + t1 := x1*y0 + c1 + t1a := t1 + t1 += x0 * y1 + if t1 < t1a { // If the number got smaller then we overflowed. c2++ } - t2 := x1*y1 + c2*_B2; + t2 := x1*y1 + c2*_B2 // compute result digits but avoid overflow // z = z[1]*_B + z[0] = x*y // z0 = t1<<_W2 + t0; // This may overflow, but that's ok because we also sum t1 and t0 below // and we take care of the overflow there. - z0 = t1<<_W2 + t0; + z0 = t1<<_W2 + t0 - var c3 Word; - z1 = t1 + t0>>_W2; + var c3 Word + z1 = t1 + t0>>_W2 if z1 < t1 { c3++ } - z1 >>= _W2; - z1 += t2 + c3*_B2; + z1 >>= _W2 + z1 += t2 + c3*_B2 - return; + return } // q = (x1<<_W + x0 - r)/y // The most significant bit of y must be 1. func divStep(x1, x0, y Word) (q, r Word) { - d1, d0 := y>>_W2, y&_M2; - q1, r1 := x1/d1, x1%d1; - m := q1 * d0; - r1 = r1*_B2 | x0>>_W2; + d1, d0 := y>>_W2, y&_M2 + q1, r1 := x1/d1, x1%d1 + m := q1 * d0 + r1 = r1*_B2 | x0>>_W2 if r1 < m { - q1--; - r1 += y; + q1-- + r1 += y if r1 >= y && r1 < m { - q1--; - r1 += y; + q1-- + r1 += y } } - r1 -= m; + r1 -= m - r0 := r1 % d1; - q0 := r1 / d1; - m = q0 * d0; - r0 = r0*_B2 | x0&_M2; + r0 := r1 % d1 + q0 := r1 / d1 + m = q0 * d0 + r0 = r0*_B2 | x0&_M2 if r0 < m { - q0--; - r0 += y; + q0-- + r0 += y if r0 >= y && r0 < m { - q0--; - r0 += y; + q0-- + r0 += y } } - r0 -= m; + r0 -= m - q = q1*_B2 | q0; - r = r0; - return; + q = q1*_B2 | q0 + r = r0 + return } @@ -217,53 +217,53 @@ func leadingZeros(x Word) (n uint) { return _W } for x&(1<<(_W-1)) == 0 { - n++; - x <<= 1; + n++ + x <<= 1 } - return; + return } // q = (x1<<_W + x0 - r)/y func divWW_g(x1, x0, y Word) (q, r Word) { if x1 == 0 { - q, r = x0/y, x0%y; - return; + q, r = x0/y, x0%y + return } - var q0, q1 Word; - z := leadingZeros(y); + var q0, q1 Word + z := leadingZeros(y) if y > x1 { if z != 0 { - y <<= z; - x1 = (x1 << z) | (x0 >> (_W - z)); - x0 <<= z; + y <<= z + x1 = (x1 << z) | (x0 >> (_W - z)) + x0 <<= z } - q0, x0 = divStep(x1, x0, y); - q1 = 0; + q0, x0 = divStep(x1, x0, y) + q1 = 0 } else { if z == 0 { - x1 -= y; - q1 = 1; + x1 -= y + q1 = 1 } else { - z1 := _W - z; - y <<= z; - x2 := x1 >> z1; - x1 = (x1 << z) | (x0 >> z1); - x0 <<= z; - q1, x1 = divStep(x2, x1, y); + z1 := _W - z + y <<= z + x2 := x1 >> z1 + x1 = (x1 << z) | (x0 >> z1) + x0 <<= z + q1, x1 = divStep(x2, x1, y) } - q0, x0 = divStep(x1, x0, y); + q0, x0 = divStep(x1, x0, y) } - r = x0 >> z; + r = x0 >> z if q1 != 0 { panic("div out of range") } - return q0, r; + return q0, r } @@ -276,25 +276,25 @@ func divWW_g(x1, x0, y Word) (q, r Word) { // f_s should be installed if they exist. var ( // addVV sets z and returns c such that z+c = x+y. - addVV func(z, x, y *Word, n int) (c Word) = addVV_g; + addVV func(z, x, y *Word, n int) (c Word) = addVV_g // subVV sets z and returns c such that z-c = x-y. - subVV func(z, x, y *Word, n int) (c Word) = subVV_g; + subVV func(z, x, y *Word, n int) (c Word) = subVV_g // addVW sets z and returns c such that z+c = x-y. - addVW func(z, x *Word, y Word, n int) (c Word) = addVW_g; + addVW func(z, x *Word, y Word, n int) (c Word) = addVW_g // subVW sets z and returns c such that z-c = x-y. - subVW func(z, x *Word, y Word, n int) (c Word) = subVW_g; + subVW func(z, x *Word, y Word, n int) (c Word) = subVW_g // mulAddVWW sets z and returns c such that z+c = x*y + r. - mulAddVWW func(z, x *Word, y, r Word, n int) (c Word) = mulAddVWW_g; + mulAddVWW func(z, x *Word, y, r Word, n int) (c Word) = mulAddVWW_g // addMulVVW sets z and returns c such that z+c = z + x*y. - addMulVVW func(z, x *Word, y Word, n int) (c Word) = addMulVVW_g; + addMulVVW func(z, x *Word, y Word, n int) (c Word) = addMulVVW_g // divWVW sets z and returns r such that z-r = (xn<<(n*_W) + x) / y. - divWVW func(z *Word, xn Word, x *Word, y Word, n int) (r Word) = divWVW_g; + divWVW func(z *Word, xn Word, x *Word, y Word, n int) (r Word) = divWVW_g ) @@ -303,13 +303,13 @@ func init() { //return; // Install assembly routines. - addVV = addVV_s; - subVV = subVV_s; - addVW = addVW_s; - subVW = subVW_s; - mulAddVWW = mulAddVWW_s; - addMulVVW = addMulVVW_s; - divWVW = divWVW_s; + addVV = addVV_s + subVV = subVV_s + addVW = addVW_s + subVW = subVW_s + mulAddVWW = mulAddVWW_s + addMulVVW = addMulVVW_s + divWVW = divWVW_s } @@ -323,7 +323,7 @@ func addVV_g(z, x, y *Word, n int) (c Word) { for i := 0; i < n; i++ { c, *z.at(i) = addWW_g(*x.at(i), *y.at(i), c) } - return; + return } @@ -332,56 +332,56 @@ func subVV_g(z, x, y *Word, n int) (c Word) { for i := 0; i < n; i++ { c, *z.at(i) = subWW_g(*x.at(i), *y.at(i), c) } - return; + return } func addVW_s(z, x *Word, y Word, n int) (c Word) func addVW_g(z, x *Word, y Word, n int) (c Word) { - c = y; + c = y for i := 0; i < n; i++ { c, *z.at(i) = addWW_g(*x.at(i), c, 0) } - return; + return } func subVW_s(z, x *Word, y Word, n int) (c Word) func subVW_g(z, x *Word, y Word, n int) (c Word) { - c = y; + c = y for i := 0; i < n; i++ { c, *z.at(i) = subWW_g(*x.at(i), c, 0) } - return; + return } func mulAddVWW_s(z, x *Word, y, r Word, n int) (c Word) func mulAddVWW_g(z, x *Word, y, r Word, n int) (c Word) { - c = r; + c = r for i := 0; i < n; i++ { c, *z.at(i) = mulAddWWW_g(*x.at(i), y, c) } - return; + return } func addMulVVW_s(z, x *Word, y Word, n int) (c Word) func addMulVVW_g(z, x *Word, y Word, n int) (c Word) { for i := 0; i < n; i++ { - z1, z0 := mulAddWWW_g(*x.at(i), y, *z.at(i)); - c, *z.at(i) = addWW_g(z0, c, 0); - c += z1; + z1, z0 := mulAddWWW_g(*x.at(i), y, *z.at(i)) + c, *z.at(i) = addWW_g(z0, c, 0) + c += z1 } - return; + return } func divWVW_s(z *Word, xn Word, x *Word, y Word, n int) (r Word) func divWVW_g(z *Word, xn Word, x *Word, y Word, n int) (r Word) { - r = xn; + r = xn for i := n - 1; i >= 0; i-- { *z.at(i), r = divWW_g(r, *x.at(i), y) } - return; + return } diff --git a/src/pkg/big/arith_test.go b/src/pkg/big/arith_test.go index 41b91626a..b0f6bf6f1 100644 --- a/src/pkg/big/arith_test.go +++ b/src/pkg/big/arith_test.go @@ -9,7 +9,7 @@ import "testing" type funWW func(x, y, c Word) (z1, z0 Word) type argWW struct { - x, y, c, z1, z0 Word; + x, y, c, z1, z0 Word } var sumWW = []argWW{ @@ -28,7 +28,7 @@ var sumWW = []argWW{ func testFunWW(t *testing.T, msg string, f funWW, a argWW) { - z1, z0 := f(a.x, a.y, a.c); + z1, z0 := f(a.x, a.y, a.c) if z1 != a.z1 || z0 != a.z0 { t.Errorf("%s%+v\n\tgot z1:z0 = %#x:%#x; want %#x:%#x", msg, a, z1, z0, a.z1, a.z0) } @@ -37,17 +37,17 @@ func testFunWW(t *testing.T, msg string, f funWW, a argWW) { func TestFunWW(t *testing.T) { for _, a := range sumWW { - arg := a; - testFunWW(t, "addWW_g", addWW_g, arg); + arg := a + testFunWW(t, "addWW_g", addWW_g, arg) - arg = argWW{a.y, a.x, a.c, a.z1, a.z0}; - testFunWW(t, "addWW_g symmetric", addWW_g, arg); + arg = argWW{a.y, a.x, a.c, a.z1, a.z0} + testFunWW(t, "addWW_g symmetric", addWW_g, arg) - arg = argWW{a.z0, a.x, a.c, a.z1, a.y}; - testFunWW(t, "subWW_g", subWW_g, arg); + arg = argWW{a.z0, a.x, a.c, a.z1, a.y} + testFunWW(t, "subWW_g", subWW_g, arg) - arg = argWW{a.z0, a.y, a.c, a.z1, a.x}; - testFunWW(t, "subWW_g symmetric", subWW_g, arg); + arg = argWW{a.z0, a.y, a.c, a.z1, a.x} + testFunWW(t, "subWW_g symmetric", subWW_g, arg) } } @@ -56,14 +56,14 @@ func addr(x []Word) *Word { if len(x) == 0 { return nil } - return &x[0]; + return &x[0] } type funVV func(z, x, y *Word, n int) (c Word) type argVV struct { - z, x, y []Word; - c Word; + z, x, y []Word + c Word } var sumVV = []argVV{ @@ -80,13 +80,13 @@ var sumVV = []argVV{ func testFunVV(t *testing.T, msg string, f funVV, a argVV) { - n := len(a.z); - z := make([]Word, n); - c := f(addr(z), addr(a.x), addr(a.y), n); + n := len(a.z) + z := make([]Word, n) + c := f(addr(z), addr(a.x), addr(a.y), n) for i, zi := range z { if zi != a.z[i] { - t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]); - break; + t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]) + break } } if c != a.c { @@ -97,30 +97,30 @@ func testFunVV(t *testing.T, msg string, f funVV, a argVV) { func TestFunVV(t *testing.T) { for _, a := range sumVV { - arg := a; - testFunVV(t, "addVV_g", addVV_g, arg); - testFunVV(t, "addVV", addVV, arg); + arg := a + testFunVV(t, "addVV_g", addVV_g, arg) + testFunVV(t, "addVV", addVV, arg) - arg = argVV{a.z, a.y, a.x, a.c}; - testFunVV(t, "addVV_g symmetric", addVV_g, arg); - testFunVV(t, "addVV symmetric", addVV, arg); + arg = argVV{a.z, a.y, a.x, a.c} + testFunVV(t, "addVV_g symmetric", addVV_g, arg) + testFunVV(t, "addVV symmetric", addVV, arg) - arg = argVV{a.x, a.z, a.y, a.c}; - testFunVV(t, "subVV_g", subVV_g, arg); - testFunVV(t, "subVV", subVV, arg); + arg = argVV{a.x, a.z, a.y, a.c} + testFunVV(t, "subVV_g", subVV_g, arg) + testFunVV(t, "subVV", subVV, arg) - arg = argVV{a.y, a.z, a.x, a.c}; - testFunVV(t, "subVV_g symmetric", subVV_g, arg); - testFunVV(t, "subVV symmetric", subVV, arg); + arg = argVV{a.y, a.z, a.x, a.c} + testFunVV(t, "subVV_g symmetric", subVV_g, arg) + testFunVV(t, "subVV symmetric", subVV, arg) } } type funVW func(z, x *Word, y Word, n int) (c Word) type argVW struct { - z, x []Word; - y Word; - c Word; + z, x []Word + y Word + c Word } var sumVW = []argVW{ @@ -149,13 +149,13 @@ var prodVW = []argVW{ func testFunVW(t *testing.T, msg string, f funVW, a argVW) { - n := len(a.z); - z := make([]Word, n); - c := f(addr(z), addr(a.x), a.y, n); + n := len(a.z) + z := make([]Word, n) + c := f(addr(z), addr(a.x), a.y, n) for i, zi := range z { if zi != a.z[i] { - t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]); - break; + t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]) + break } } if c != a.c { @@ -166,22 +166,22 @@ func testFunVW(t *testing.T, msg string, f funVW, a argVW) { func TestFunVW(t *testing.T) { for _, a := range sumVW { - arg := a; - testFunVW(t, "addVW_g", addVW_g, arg); - testFunVW(t, "addVW", addVW, arg); + arg := a + testFunVW(t, "addVW_g", addVW_g, arg) + testFunVW(t, "addVW", addVW, arg) - arg = argVW{a.x, a.z, a.y, a.c}; - testFunVW(t, "subVW_g", subVW_g, arg); - testFunVW(t, "subVW", subVW, arg); + arg = argVW{a.x, a.z, a.y, a.c} + testFunVW(t, "subVW_g", subVW_g, arg) + testFunVW(t, "subVW", subVW, arg) } } type funVWW func(z, x *Word, y, r Word, n int) (c Word) type argVWW struct { - z, x []Word; - y, r Word; - c Word; + z, x []Word + y, r Word + c Word } var prodVWW = []argVWW{ @@ -212,13 +212,13 @@ var prodVWW = []argVWW{ func testFunVWW(t *testing.T, msg string, f funVWW, a argVWW) { - n := len(a.z); - z := make([]Word, n); - c := f(addr(z), addr(a.x), a.y, a.r, n); + n := len(a.z) + z := make([]Word, n) + c := f(addr(z), addr(a.x), a.y, a.r, n) for i, zi := range z { if zi != a.z[i] { - t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]); - break; + t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]) + break } } if c != a.c { @@ -232,21 +232,21 @@ func testFunVWW(t *testing.T, msg string, f funVWW, a argVWW) { type funWVW func(z *Word, xn Word, x *Word, y Word, n int) (r Word) type argWVW struct { - z []Word; - xn Word; - x []Word; - y Word; - r Word; + z []Word + xn Word + x []Word + y Word + r Word } func testFunWVW(t *testing.T, msg string, f funWVW, a argWVW) { - n := len(a.z); - z := make([]Word, n); - r := f(addr(z), a.xn, addr(a.x), a.y, n); + n := len(a.z) + z := make([]Word, n) + r := f(addr(z), a.xn, addr(a.x), a.y, n) for i, zi := range z { if zi != a.z[i] { - t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]); - break; + t.Errorf("%s%+v\n\tgot z[%d] = %#x; want %#x", msg, a, i, zi, a.z[i]) + break } } if r != a.r { @@ -257,22 +257,22 @@ func testFunWVW(t *testing.T, msg string, f funWVW, a argWVW) { func TestFunVWW(t *testing.T) { for _, a := range prodVWW { - arg := a; - testFunVWW(t, "mulAddVWW_g", mulAddVWW_g, arg); - testFunVWW(t, "mulAddVWW", mulAddVWW, arg); + arg := a + testFunVWW(t, "mulAddVWW_g", mulAddVWW_g, arg) + testFunVWW(t, "mulAddVWW", mulAddVWW, arg) if a.y != 0 && a.r < a.y { - arg := argWVW{a.x, a.c, a.z, a.y, a.r}; - testFunWVW(t, "divWVW_g", divWVW_g, arg); - testFunWVW(t, "divWVW", divWVW, arg); + arg := argWVW{a.x, a.c, a.z, a.y, a.r} + testFunWVW(t, "divWVW_g", divWVW_g, arg) + testFunWVW(t, "divWVW", divWVW, arg) } } } type mulWWTest struct { - x, y Word; - q, r Word; + x, y Word + q, r Word } @@ -284,7 +284,7 @@ var mulWWTests = []mulWWTest{ func TestMulWW(t *testing.T) { for i, test := range mulWWTests { - q, r := mulWW_g(test.x, test.y); + q, r := mulWW_g(test.x, test.y) if q != test.q || r != test.r { t.Errorf("#%d got (%x, %x) want (%x, %x)", i, q, r, test.q, test.r) } @@ -293,8 +293,8 @@ func TestMulWW(t *testing.T) { type mulAddWWWTest struct { - x, y, c Word; - q, r Word; + x, y, c Word + q, r Word } @@ -309,7 +309,7 @@ var mulAddWWWTests = []mulAddWWWTest{ func TestMulAddWWW(t *testing.T) { for i, test := range mulAddWWWTests { - q, r := mulAddWWW_g(test.x, test.y, test.c); + q, r := mulAddWWW_g(test.x, test.y, test.c) if q != test.q || r != test.r { t.Errorf("#%d got (%x, %x) want (%x, %x)", i, q, r, test.q, test.r) } diff --git a/src/pkg/big/int.go b/src/pkg/big/int.go index 22c0eddff..5a0f7c0df 100644 --- a/src/pkg/big/int.go +++ b/src/pkg/big/int.go @@ -9,32 +9,32 @@ package big // An Int represents a signed multi-precision integer. // The zero value for an Int represents the value 0. type Int struct { - neg bool; // sign - abs []Word; // absolute value of the integer + neg bool // sign + abs []Word // absolute value of the integer } // New allocates and returns a new Int set to x. func (z *Int) New(x int64) *Int { - z.neg = false; + z.neg = false if x < 0 { - z.neg = true; - x = -x; + z.neg = true + x = -x } - z.abs = newN(z.abs, uint64(x)); - return z; + z.abs = newN(z.abs, uint64(x)) + return z } // NewInt allocates and returns a new Int set to x. -func NewInt(x int64) *Int { return new(Int).New(x) } +func NewInt(x int64) *Int { return new(Int).New(x) } // Set sets z to x. func (z *Int) Set(x *Int) *Int { - z.neg = x.neg; - z.abs = setN(z.abs, x.abs); - return z; + z.neg = x.neg + z.abs = setN(z.abs, x.abs) + return z } @@ -43,23 +43,23 @@ func (z *Int) Add(x, y *Int) *Int { if x.neg == y.neg { // x + y == x + y // (-x) + (-y) == -(x + y) - z.neg = x.neg; - z.abs = addNN(z.abs, x.abs, y.abs); + z.neg = x.neg + z.abs = addNN(z.abs, x.abs, y.abs) } else { // x + (-y) == x - y == -(y - x) // (-x) + y == y - x == -(x - y) if cmpNN(x.abs, y.abs) >= 0 { - z.neg = x.neg; - z.abs = subNN(z.abs, x.abs, y.abs); + z.neg = x.neg + z.abs = subNN(z.abs, x.abs, y.abs) } else { - z.neg = !x.neg; - z.abs = subNN(z.abs, y.abs, x.abs); + z.neg = !x.neg + z.abs = subNN(z.abs, y.abs, x.abs) } } if len(z.abs) == 0 { - z.neg = false // 0 has no sign + z.neg = false // 0 has no sign } - return z; + return z } @@ -68,23 +68,23 @@ func (z *Int) Sub(x, y *Int) *Int { if x.neg != y.neg { // x - (-y) == x + y // (-x) - y == -(x + y) - z.neg = x.neg; - z.abs = addNN(z.abs, x.abs, y.abs); + z.neg = x.neg + z.abs = addNN(z.abs, x.abs, y.abs) } else { // x - y == x - y == -(y - x) // (-x) - (-y) == y - x == -(x - y) if cmpNN(x.abs, y.abs) >= 0 { - z.neg = x.neg; - z.abs = subNN(z.abs, x.abs, y.abs); + z.neg = x.neg + z.abs = subNN(z.abs, x.abs, y.abs) } else { - z.neg = !x.neg; - z.abs = subNN(z.abs, y.abs, x.abs); + z.neg = !x.neg + z.abs = subNN(z.abs, y.abs, x.abs) } } if len(z.abs) == 0 { - z.neg = false // 0 has no sign + z.neg = false // 0 has no sign } - return z; + return z } @@ -94,43 +94,43 @@ func (z *Int) Mul(x, y *Int) *Int { // x * (-y) == -(x * y) // (-x) * y == -(x * y) // (-x) * (-y) == x * y - z.abs = mulNN(z.abs, x.abs, y.abs); - z.neg = len(z.abs) > 0 && x.neg != y.neg; // 0 has no sign - return z; + z.abs = mulNN(z.abs, x.abs, y.abs) + z.neg = len(z.abs) > 0 && x.neg != y.neg // 0 has no sign + return z } // Div calculates q = (x-r)/y where 0 <= r < y. The receiver is set to q. func (z *Int) Div(x, y *Int) (q, r *Int) { - q = z; - r = new(Int); - div(q, r, x, y); - return; + q = z + r = new(Int) + div(q, r, x, y) + return } // Mod calculates q = (x-r)/y and returns r. func (z *Int) Mod(x, y *Int) (r *Int) { - q := new(Int); - r = z; - div(q, r, x, y); - return; + q := new(Int) + r = z + div(q, r, x, y) + return } func div(q, r, x, y *Int) { - q.neg = x.neg != y.neg; - r.neg = x.neg; - q.abs, r.abs = divNN(q.abs, r.abs, x.abs, y.abs); - return; + q.neg = x.neg != y.neg + r.neg = x.neg + q.abs, r.abs = divNN(q.abs, r.abs, x.abs, y.abs) + return } // Neg computes z = -x. func (z *Int) Neg(x *Int) *Int { - z.abs = setN(z.abs, x.abs); - z.neg = len(z.abs) > 0 && !x.neg; // 0 has no sign - return z; + z.abs = setN(z.abs, x.abs) + z.neg = len(z.abs) > 0 && !x.neg // 0 has no sign + return z } @@ -147,7 +147,7 @@ func (x *Int) Cmp(y *Int) (r int) { // (-x) cmp (-y) == -(x cmp y) switch { case x.neg == y.neg: - r = cmpNN(x.abs, y.abs); + r = cmpNN(x.abs, y.abs) if x.neg { r = -r } @@ -156,16 +156,16 @@ func (x *Int) Cmp(y *Int) (r int) { default: r = 1 } - return; + return } func (z *Int) String() string { - s := ""; + s := "" if z.neg { s = "-" } - return s + stringN(z.abs, 10); + return s + stringN(z.abs, 10) } @@ -173,7 +173,7 @@ func (z *Int) String() string { // If base is 0 then SetString attempts to detect the base by at the prefix of // s. '0x' implies base 16, '0' implies base 8. Otherwise base 10 is assumed. func (z *Int) SetString(s string, base int) (*Int, bool) { - var scanned int; + var scanned int if base == 1 || base > 16 { goto Error @@ -184,83 +184,83 @@ func (z *Int) SetString(s string, base int) (*Int, bool) { } if s[0] == '-' { - z.neg = true; - s = s[1:]; + z.neg = true + s = s[1:] } else { z.neg = false } - z.abs, _, scanned = scanN(z.abs, s, base); + z.abs, _, scanned = scanN(z.abs, s, base) if scanned != len(s) { goto Error } - return z, true; + return z, true Error: - z.neg = false; - z.abs = nil; - return nil, false; + z.neg = false + z.abs = nil + return nil, false } // SetBytes interprets b as the bytes of a big-endian, unsigned integer and // sets x to that value. func (z *Int) SetBytes(b []byte) *Int { - s := int(_S); - z.abs = makeN(z.abs, (len(b)+s-1)/s, false); - z.neg = false; + s := int(_S) + z.abs = makeN(z.abs, (len(b)+s-1)/s, false) + z.neg = false - j := 0; + j := 0 for len(b) >= s { - var w Word; + var w Word for i := s; i > 0; i-- { - w <<= 8; - w |= Word(b[len(b)-i]); + w <<= 8 + w |= Word(b[len(b)-i]) } - z.abs[j] = w; - j++; - b = b[0 : len(b)-s]; + z.abs[j] = w + j++ + b = b[0 : len(b)-s] } if len(b) > 0 { - var w Word; + var w Word for i := len(b); i > 0; i-- { - w <<= 8; - w |= Word(b[len(b)-i]); + w <<= 8 + w |= Word(b[len(b)-i]) } - z.abs[j] = w; + z.abs[j] = w } - z.abs = normN(z.abs); + z.abs = normN(z.abs) - return z; + return z } // Bytes returns the absolute value of x as a big-endian byte array. func (z *Int) Bytes() []byte { - s := int(_S); - b := make([]byte, len(z.abs)*s); + s := int(_S) + b := make([]byte, len(z.abs)*s) for i, w := range z.abs { - wordBytes := b[(len(z.abs)-i-1)*s : (len(z.abs)-i)*s]; + wordBytes := b[(len(z.abs)-i-1)*s : (len(z.abs)-i)*s] for j := s - 1; j >= 0; j-- { - wordBytes[j] = byte(w); - w >>= 8; + wordBytes[j] = byte(w) + w >>= 8 } } - i := 0; + i := 0 for i < len(b) && b[i] == 0 { i++ } - return b[i:]; + return b[i:] } @@ -271,7 +271,7 @@ func (z *Int) Len() int { return 0 } - return len(z.abs)*_W - int(leadingZeros(z.abs[len(z.abs)-1])); + return len(z.abs)*_W - int(leadingZeros(z.abs[len(z.abs)-1])) } @@ -279,19 +279,19 @@ func (z *Int) Len() int { // See Knuth, volume 2, section 4.6.3. func (z *Int) Exp(x, y, m *Int) *Int { if y.neg || len(y.abs) == 0 { - z.New(1); - z.neg = x.neg; - return z; + z.New(1) + z.neg = x.neg + return z } - var mWords []Word; + var mWords []Word if m != nil { mWords = m.abs } - z.abs = expNNN(z.abs, x.abs, y.abs, mWords); - z.neg = x.neg && y.abs[0]&1 == 1; - return z; + z.abs = expNNN(z.abs, x.abs, y.abs, mWords) + z.neg = x.neg && y.abs[0]&1 == 1 + return z } @@ -301,44 +301,44 @@ func (z *Int) Exp(x, y, m *Int) *Int { // If either a or b is not positive, GcdInt sets d = x = y = 0. func GcdInt(d, x, y, a, b *Int) { if a.neg || b.neg { - d.New(0); + d.New(0) if x != nil { x.New(0) } if y != nil { y.New(0) } - return; + return } - A := new(Int).Set(a); - B := new(Int).Set(b); + A := new(Int).Set(a) + B := new(Int).Set(b) - X := new(Int); - Y := new(Int).New(1); + X := new(Int) + Y := new(Int).New(1) - lastX := new(Int).New(1); - lastY := new(Int); + lastX := new(Int).New(1) + lastY := new(Int) - q := new(Int); - temp := new(Int); + q := new(Int) + temp := new(Int) for len(B.abs) > 0 { - q, r := q.Div(A, B); + q, r := q.Div(A, B) - A, B = B, r; + A, B = B, r - temp.Set(X); - X.Mul(X, q); - X.neg = !X.neg; - X.Add(X, lastX); - lastX.Set(temp); + temp.Set(X) + X.Mul(X, q) + X.neg = !X.neg + X.Add(X, lastX) + lastX.Set(temp) - temp.Set(Y); - Y.Mul(Y, q); - Y.neg = !Y.neg; - Y.Add(Y, lastY); - lastY.Set(temp); + temp.Set(Y) + Y.Mul(Y, q) + Y.neg = !Y.neg + Y.Add(Y, lastY) + lastY.Set(temp) } if x != nil { @@ -349,22 +349,22 @@ func GcdInt(d, x, y, a, b *Int) { *y = *lastY } - *d = *A; + *d = *A } // ProbablyPrime performs n Miller-Rabin tests to check whether z is prime. // If it returns true, z is prime with probability 1 - 1/4^n. // If it returns false, z is not prime. -func ProbablyPrime(z *Int, reps int) bool { return !z.neg && probablyPrime(z.abs, reps) } +func ProbablyPrime(z *Int, reps int) bool { return !z.neg && probablyPrime(z.abs, reps) } // Rsh sets z = x >> s and returns z. func (z *Int) Rsh(x *Int, n int) *Int { - removedWords := n / _W; - z.abs = makeN(z.abs, len(x.abs)-removedWords, false); - z.neg = x.neg; - shiftRight(z.abs, x.abs[removedWords:], n%_W); - z.abs = normN(z.abs); - return z; + removedWords := n / _W + z.abs = makeN(z.abs, len(x.abs)-removedWords, false) + z.neg = x.neg + shiftRight(z.abs, x.abs[removedWords:], n%_W) + z.abs = normN(z.abs) + return z } diff --git a/src/pkg/big/int_test.go b/src/pkg/big/int_test.go index e5ed221af..b2c33fcc4 100644 --- a/src/pkg/big/int_test.go +++ b/src/pkg/big/int_test.go @@ -5,21 +5,21 @@ package big import ( - "bytes"; - "encoding/hex"; - "testing"; - "testing/quick"; + "bytes" + "encoding/hex" + "testing" + "testing/quick" ) func newZ(x int64) *Int { - var z Int; - return z.New(x); + var z Int + return z.New(x) } type funZZ func(z, x, y *Int) *Int type argZZ struct { - z, x, y *Int; + z, x, y *Int } @@ -44,8 +44,8 @@ var prodZZ = []argZZ{ func TestSetZ(t *testing.T) { for _, a := range sumZZ { - var z Int; - z.Set(a.z); + var z Int + z.Set(a.z) if (&z).Cmp(a.z) != 0 { t.Errorf("got z = %v; want %v", z, a.z) } @@ -54,8 +54,8 @@ func TestSetZ(t *testing.T) { func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) { - var z Int; - f(&z, a.x, a.y); + var z Int + f(&z, a.x, a.y) if (&z).Cmp(a.z) != 0 { t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, &z, a.z) } @@ -63,32 +63,32 @@ func testFunZZ(t *testing.T, msg string, f funZZ, a argZZ) { func TestSumZZ(t *testing.T) { - AddZZ := func(z, x, y *Int) *Int { return z.Add(x, y) }; - SubZZ := func(z, x, y *Int) *Int { return z.Sub(x, y) }; + AddZZ := func(z, x, y *Int) *Int { return z.Add(x, y) } + SubZZ := func(z, x, y *Int) *Int { return z.Sub(x, y) } for _, a := range sumZZ { - arg := a; - testFunZZ(t, "AddZZ", AddZZ, arg); + arg := a + testFunZZ(t, "AddZZ", AddZZ, arg) - arg = argZZ{a.z, a.y, a.x}; - testFunZZ(t, "AddZZ symmetric", AddZZ, arg); + arg = argZZ{a.z, a.y, a.x} + testFunZZ(t, "AddZZ symmetric", AddZZ, arg) - arg = argZZ{a.x, a.z, a.y}; - testFunZZ(t, "SubZZ", SubZZ, arg); + arg = argZZ{a.x, a.z, a.y} + testFunZZ(t, "SubZZ", SubZZ, arg) - arg = argZZ{a.y, a.z, a.x}; - testFunZZ(t, "SubZZ symmetric", SubZZ, arg); + arg = argZZ{a.y, a.z, a.x} + testFunZZ(t, "SubZZ symmetric", SubZZ, arg) } } func TestProdZZ(t *testing.T) { - MulZZ := func(z, x, y *Int) *Int { return z.Mul(x, y) }; + MulZZ := func(z, x, y *Int) *Int { return z.Mul(x, y) } for _, a := range prodZZ { - arg := a; - testFunZZ(t, "MulZZ", MulZZ, arg); + arg := a + testFunZZ(t, "MulZZ", MulZZ, arg) - arg = argZZ{a.z, a.y, a.x}; - testFunZZ(t, "MulZZ symmetric", MulZZ, arg); + arg = argZZ{a.z, a.y, a.x} + testFunZZ(t, "MulZZ symmetric", MulZZ, arg) } } @@ -106,20 +106,20 @@ var facts = map[int]string{ func fact(n int) *Int { - var z Int; - z.New(1); + var z Int + z.New(1) for i := 2; i <= n; i++ { - var t Int; - t.New(int64(i)); - z.Mul(&z, &t); + var t Int + t.New(int64(i)) + z.Mul(&z, &t) } - return &z; + return &z } func TestFact(t *testing.T) { for n, s := range facts { - f := fact(n).String(); + f := fact(n).String() if f != s { t.Errorf("%d! = %s; want %s", n, f, s) } @@ -128,10 +128,10 @@ func TestFact(t *testing.T) { type fromStringTest struct { - in string; - base int; - out int64; - ok bool; + in string + base int + out int64 + ok bool } @@ -156,10 +156,10 @@ var fromStringTests = []fromStringTest{ func TestSetString(t *testing.T) { for i, test := range fromStringTests { - n, ok := new(Int).SetString(test.in, test.base); + n, ok := new(Int).SetString(test.in, test.base) if ok != test.ok { - t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok); - continue; + t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok) + continue } if !ok { continue @@ -173,8 +173,8 @@ func TestSetString(t *testing.T) { type divSignsTest struct { - x, y int64; - q, r int64; + x, y int64 + q, r int64 } @@ -190,11 +190,11 @@ var divSignsTests = []divSignsTest{ func TestDivSigns(t *testing.T) { for i, test := range divSignsTests { - x := new(Int).New(test.x); - y := new(Int).New(test.y); - q, r := new(Int).Div(x, y); - expectedQ := new(Int).New(test.q); - expectedR := new(Int).New(test.r); + x := new(Int).New(test.x) + y := new(Int).New(test.y) + q, r := new(Int).Div(x, y) + expectedQ := new(Int).New(test.q) + expectedR := new(Int).New(test.r) if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 { t.Errorf("#%d: got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR) @@ -204,8 +204,8 @@ func TestDivSigns(t *testing.T) { func checkSetBytes(b []byte) bool { - hex1 := hex.EncodeToString(new(Int).SetBytes(b).Bytes()); - hex2 := hex.EncodeToString(b); + hex1 := hex.EncodeToString(new(Int).SetBytes(b).Bytes()) + hex2 := hex.EncodeToString(b) for len(hex1) < len(hex2) { hex1 = "0" + hex1 @@ -215,12 +215,12 @@ func checkSetBytes(b []byte) bool { hex2 = "0" + hex2 } - return hex1 == hex2; + return hex1 == hex2 } func TestSetBytes(t *testing.T) { - err := quick.Check(checkSetBytes, nil); + err := quick.Check(checkSetBytes, nil) if err != nil { t.Error(err) } @@ -228,13 +228,13 @@ func TestSetBytes(t *testing.T) { func checkBytes(b []byte) bool { - b2 := new(Int).SetBytes(b).Bytes(); - return bytes.Compare(b, b2) == 0; + b2 := new(Int).SetBytes(b).Bytes() + return bytes.Compare(b, b2) == 0 } func TestBytes(t *testing.T) { - err := quick.Check(checkSetBytes, nil); + err := quick.Check(checkSetBytes, nil) if err != nil { t.Error(err) } @@ -242,30 +242,30 @@ func TestBytes(t *testing.T) { func checkDiv(x, y []byte) bool { - u := new(Int).SetBytes(x); - v := new(Int).SetBytes(y); + u := new(Int).SetBytes(x) + v := new(Int).SetBytes(y) if len(v.abs) == 0 { return true } - q, r := new(Int).Div(u, v); + q, r := new(Int).Div(u, v) if r.Cmp(v) >= 0 { return false } - uprime := new(Int).Set(q); - uprime.Mul(uprime, v); - uprime.Add(uprime, r); + uprime := new(Int).Set(q) + uprime.Mul(uprime, v) + uprime.Add(uprime, r) - return uprime.Cmp(u) == 0; + return uprime.Cmp(u) == 0 } type divTest struct { - x, y string; - q, r string; + x, y string + q, r string } @@ -286,18 +286,18 @@ var divTests = []divTest{ func TestDiv(t *testing.T) { - err := quick.Check(checkDiv, nil); + err := quick.Check(checkDiv, nil) if err != nil { t.Error(err) } for i, test := range divTests { - x, _ := new(Int).SetString(test.x, 10); - y, _ := new(Int).SetString(test.y, 10); - expectedQ, _ := new(Int).SetString(test.q, 10); - expectedR, _ := new(Int).SetString(test.r, 10); + x, _ := new(Int).SetString(test.x, 10) + y, _ := new(Int).SetString(test.y, 10) + expectedQ, _ := new(Int).SetString(test.q, 10) + expectedR, _ := new(Int).SetString(test.r, 10) - q, r := new(Int).Div(x, y); + q, r := new(Int).Div(x, y) if q.Cmp(expectedQ) != 0 || r.Cmp(expectedR) != 0 { t.Errorf("#%d got (%s, %s) want (%s, %s)", i, q, r, expectedQ, expectedR) @@ -310,14 +310,14 @@ func TestDivStepD6(t *testing.T) { // See Knuth, Volume 2, section 4.3.1, exercise 21. This code exercises // a code path which only triggers 1 in 10^{-19} cases. - u := &Int{false, []Word{0, 0, 1 + 1<<(_W-1), _M ^ (1 << (_W - 1))}}; - v := &Int{false, []Word{5, 2 + 1<<(_W-1), 1 << (_W - 1)}}; + u := &Int{false, []Word{0, 0, 1 + 1<<(_W-1), _M ^ (1 << (_W - 1))}} + v := &Int{false, []Word{5, 2 + 1<<(_W-1), 1 << (_W - 1)}} - q, r := new(Int).Div(u, v); - const expectedQ64 = "18446744073709551613"; - const expectedR64 = "3138550867693340382088035895064302439801311770021610913807"; - const expectedQ32 = "4294967293"; - const expectedR32 = "39614081266355540837921718287"; + q, r := new(Int).Div(u, v) + const expectedQ64 = "18446744073709551613" + const expectedR64 = "3138550867693340382088035895064302439801311770021610913807" + const expectedQ32 = "4294967293" + const expectedR32 = "39614081266355540837921718287" if q.String() != expectedQ64 && q.String() != expectedQ32 || r.String() != expectedR64 && r.String() != expectedR32 { t.Errorf("got (%s, %s) want (%s, %s) or (%s, %s)", q, r, expectedQ64, expectedR64, expectedQ32, expectedR32) @@ -326,8 +326,8 @@ func TestDivStepD6(t *testing.T) { type lenTest struct { - in string; - out int; + in string + out int } @@ -346,10 +346,10 @@ var lenTests = []lenTest{ func TestLen(t *testing.T) { for i, test := range lenTests { - n, ok := new(Int).SetString(test.in, 0); + n, ok := new(Int).SetString(test.in, 0) if !ok { - t.Errorf("#%d test input invalid: %s", i, test.in); - continue; + t.Errorf("#%d test input invalid: %s", i, test.in) + continue } if n.Len() != test.out { @@ -360,8 +360,8 @@ func TestLen(t *testing.T) { type expTest struct { - x, y, m string; - out string; + x, y, m string + out string } @@ -388,12 +388,12 @@ var expTests = []expTest{ func TestExp(t *testing.T) { for i, test := range expTests { - x, ok1 := new(Int).SetString(test.x, 0); - y, ok2 := new(Int).SetString(test.y, 0); - out, ok3 := new(Int).SetString(test.out, 0); + x, ok1 := new(Int).SetString(test.x, 0) + y, ok2 := new(Int).SetString(test.y, 0) + out, ok3 := new(Int).SetString(test.out, 0) - var ok4 bool; - var m *Int; + var ok4 bool + var m *Int if len(test.m) == 0 { m, ok4 = nil, true @@ -402,11 +402,11 @@ func TestExp(t *testing.T) { } if !ok1 || !ok2 || !ok3 || !ok4 { - t.Errorf("#%d error in input", i); - continue; + t.Errorf("#%d error in input", i) + continue } - z := new(Int).Exp(x, y, m); + z := new(Int).Exp(x, y, m) if z.Cmp(out) != 0 { t.Errorf("#%d got %s want %s", i, z, out) } @@ -415,25 +415,25 @@ func TestExp(t *testing.T) { func checkGcd(aBytes, bBytes []byte) bool { - a := new(Int).SetBytes(aBytes); - b := new(Int).SetBytes(bBytes); + a := new(Int).SetBytes(aBytes) + b := new(Int).SetBytes(bBytes) - x := new(Int); - y := new(Int); - d := new(Int); + x := new(Int) + y := new(Int) + d := new(Int) - GcdInt(d, x, y, a, b); - x.Mul(x, a); - y.Mul(y, b); - x.Add(x, y); + GcdInt(d, x, y, a, b) + x.Mul(x, a) + y.Mul(y, b) + x.Add(x, y) - return x.Cmp(d) == 0; + return x.Cmp(d) == 0 } type gcdTest struct { - a, b int64; - d, x, y int64; + a, b int64 + d, x, y int64 } @@ -444,18 +444,18 @@ var gcdTests = []gcdTest{ func TestGcd(t *testing.T) { for i, test := range gcdTests { - a := new(Int).New(test.a); - b := new(Int).New(test.b); + a := new(Int).New(test.a) + b := new(Int).New(test.b) - x := new(Int); - y := new(Int); - d := new(Int); + x := new(Int) + y := new(Int) + d := new(Int) - expectedX := new(Int).New(test.x); - expectedY := new(Int).New(test.y); - expectedD := new(Int).New(test.d); + expectedX := new(Int).New(test.x) + expectedY := new(Int).New(test.y) + expectedD := new(Int).New(test.d) - GcdInt(d, x, y, a, b); + GcdInt(d, x, y, a, b) if expectedX.Cmp(x) != 0 || expectedY.Cmp(y) != 0 || @@ -464,7 +464,7 @@ func TestGcd(t *testing.T) { } } - quick.Check(checkGcd, nil); + quick.Check(checkGcd, nil) } @@ -494,14 +494,14 @@ var composites = []string{ func TestProbablyPrime(t *testing.T) { for i, s := range primes { - p, _ := new(Int).SetString(s, 10); + p, _ := new(Int).SetString(s, 10) if !ProbablyPrime(p, 20) { t.Errorf("#%d prime found to be non-prime", i) } } for i, s := range composites { - c, _ := new(Int).SetString(s, 10); + c, _ := new(Int).SetString(s, 10) if ProbablyPrime(c, 20) { t.Errorf("#%d composite found to be prime", i) } @@ -510,9 +510,9 @@ func TestProbablyPrime(t *testing.T) { type rshTest struct { - in string; - shift int; - out string; + in string + shift int + out string } @@ -540,9 +540,9 @@ var rshTests = []rshTest{ func TestRsh(t *testing.T) { for i, test := range rshTests { - in, _ := new(Int).SetString(test.in, 10); - expected, _ := new(Int).SetString(test.out, 10); - out := new(Int).Rsh(in, test.shift); + in, _ := new(Int).SetString(test.in, 10) + expected, _ := new(Int).SetString(test.out, 10) + out := new(Int).Rsh(in, test.shift) if out.Cmp(expected) != 0 { t.Errorf("#%d got %s want %s", i, out, expected) diff --git a/src/pkg/big/nat.go b/src/pkg/big/nat.go index 0b7c18428..877bc9811 100644 --- a/src/pkg/big/nat.go +++ b/src/pkg/big/nat.go @@ -38,31 +38,31 @@ import "rand" // - decide if type 'nat' should be exported func normN(z []Word) []Word { - i := len(z); + i := len(z) for i > 0 && z[i-1] == 0 { i-- } - z = z[0:i]; - return z; + z = z[0:i] + return z } func makeN(z []Word, m int, clear bool) []Word { if len(z) > m { - z = z[0:m]; // reuse z - has at least one extra word for a carry, if any + z = z[0:m] // reuse z - has at least one extra word for a carry, if any if clear { for i := range z { z[i] = 0 } } - return z; + return z } - c := 4; // minimum capacity + c := 4 // minimum capacity if m > c { c = m } - return make([]Word, m, c+1); // +1: extra word for a carry, if any + return make([]Word, m, c+1) // +1: extra word for a carry, if any } @@ -73,40 +73,40 @@ func newN(z []Word, x uint64) []Word { // single-digit values if x == uint64(Word(x)) { - z = makeN(z, 1, false); - z[0] = Word(x); - return z; + z = makeN(z, 1, false) + z[0] = Word(x) + return z } // compute number of words n required to represent x - n := 0; + n := 0 for t := x; t > 0; t >>= _W { n++ } // split x into n words - z = makeN(z, n, false); + z = makeN(z, n, false) for i := 0; i < n; i++ { - z[i] = Word(x & _M); - x >>= _W; + z[i] = Word(x & _M) + x >>= _W } - return z; + return z } func setN(z, x []Word) []Word { - z = makeN(z, len(x), false); + z = makeN(z, len(x), false) for i, d := range x { z[i] = d } - return z; + return z } func addNN(z, x, y []Word) []Word { - m := len(x); - n := len(y); + m := len(x) + n := len(y) switch { case m < n: @@ -120,23 +120,23 @@ func addNN(z, x, y []Word) []Word { } // m > 0 - z = makeN(z, m, false); - c := addVV(&z[0], &x[0], &y[0], n); + z = makeN(z, m, false) + c := addVV(&z[0], &x[0], &y[0], n) if m > n { c = addVW(&z[n], &x[n], c, m-n) } if c > 0 { - z = z[0 : m+1]; - z[m] = c; + z = z[0 : m+1] + z[m] = c } - return z; + return z } func subNN(z, x, y []Word) []Word { - m := len(x); - n := len(y); + m := len(x) + n := len(y) switch { case m < n: @@ -150,23 +150,23 @@ func subNN(z, x, y []Word) []Word { } // m > 0 - z = makeN(z, m, false); - c := subVV(&z[0], &x[0], &y[0], n); + z = makeN(z, m, false) + c := subVV(&z[0], &x[0], &y[0], n) if m > n { c = subVW(&z[n], &x[n], c, m-n) } if c != 0 { panic("underflow") } - z = normN(z); + z = normN(z) - return z; + return z } func cmpNN(x, y []Word) (r int) { - m := len(x); - n := len(y); + m := len(x) + n := len(y) if m != n || m == 0 { switch { case m < n: @@ -174,10 +174,10 @@ func cmpNN(x, y []Word) (r int) { case m > n: r = 1 } - return; + return } - i := m - 1; + i := m - 1 for i > 0 && x[i] == y[i] { i-- } @@ -188,31 +188,31 @@ func cmpNN(x, y []Word) (r int) { case x[i] > y[i]: r = 1 } - return; + return } func mulAddNWW(z, x []Word, y, r Word) []Word { - m := len(x); + m := len(x) if m == 0 || y == 0 { - return newN(z, uint64(r)) // result is r + return newN(z, uint64(r)) // result is r } // m > 0 - z = makeN(z, m, false); - c := mulAddVWW(&z[0], &x[0], y, r, m); + z = makeN(z, m, false) + c := mulAddVWW(&z[0], &x[0], y, r, m) if c > 0 { - z = z[0 : m+1]; - z[m] = c; + z = z[0 : m+1] + z[m] = c } - return z; + return z } func mulNN(z, x, y []Word) []Word { - m := len(x); - n := len(y); + m := len(x) + n := len(y) switch { case m < n: @@ -224,39 +224,39 @@ func mulNN(z, x, y []Word) []Word { } // m >= n && m > 1 && n > 1 - z = makeN(z, m+n, true); + z = makeN(z, m+n, true) if &z[0] == &x[0] || &z[0] == &y[0] { - z = makeN(nil, m+n, true) // z is an alias for x or y - cannot reuse + z = makeN(nil, m+n, true) // z is an alias for x or y - cannot reuse } for i := 0; i < n; i++ { if f := y[i]; f != 0 { z[m+i] = addMulVVW(&z[i], &x[0], f, m) } } - z = normN(z); + z = normN(z) - return z; + return z } // q = (x-r)/y, with 0 <= r < y func divNW(z, x []Word, y Word) (q []Word, r Word) { - m := len(x); + m := len(x) switch { case y == 0: panic("division by zero") case y == 1: - q = setN(z, x); // result is x - return; + q = setN(z, x) // result is x + return case m == 0: - q = setN(z, nil); // result is 0 - return; + q = setN(z, nil) // result is 0 + return } // m > 0 - z = makeN(z, m, false); - r = divWVW(&z[0], 0, &x[0], y, m); - q = normN(z); - return; + z = makeN(z, m, false) + r = divWVW(&z[0], 0, &x[0], y, m) + q = normN(z) + return } @@ -266,25 +266,25 @@ func divNN(z, z2, u, v []Word) (q, r []Word) { } if cmpNN(u, v) < 0 { - q = makeN(z, 0, false); - r = setN(z2, u); - return; + q = makeN(z, 0, false) + r = setN(z2, u) + return } if len(v) == 1 { - var rprime Word; - q, rprime = divNW(z, u, v[0]); + var rprime Word + q, rprime = divNW(z, u, v[0]) if rprime > 0 { - r = makeN(z2, 1, false); - r[0] = rprime; + r = makeN(z2, 1, false) + r[0] = rprime } else { r = makeN(z2, 0, false) } - return; + return } - q, r = divLargeNN(z, z2, u, v); - return; + q, r = divLargeNN(z, z2, u, v) + return } @@ -294,63 +294,63 @@ func divNN(z, z2, u, v []Word) (q, r []Word) { // len(v) >= 2 // len(uIn) >= len(v) func divLargeNN(z, z2, uIn, v []Word) (q, r []Word) { - n := len(v); - m := len(uIn) - len(v); + n := len(v) + m := len(uIn) - len(v) - u := makeN(z2, len(uIn)+1, false); - qhatv := make([]Word, len(v)+1); - q = makeN(z, m+1, false); + u := makeN(z2, len(uIn)+1, false) + qhatv := make([]Word, len(v)+1) + q = makeN(z, m+1, false) // D1. - shift := leadingZeroBits(v[n-1]); - shiftLeft(v, v, shift); - shiftLeft(u, uIn, shift); - u[len(uIn)] = uIn[len(uIn)-1] >> (_W - uint(shift)); + shift := leadingZeroBits(v[n-1]) + shiftLeft(v, v, shift) + shiftLeft(u, uIn, shift) + u[len(uIn)] = uIn[len(uIn)-1] >> (_W - uint(shift)) // D2. for j := m; j >= 0; j-- { // D3. - var qhat Word; + var qhat Word if u[j+n] == v[n-1] { qhat = _B - 1 } else { - var rhat Word; - qhat, rhat = divWW_g(u[j+n], u[j+n-1], v[n-1]); + var rhat Word + qhat, rhat = divWW_g(u[j+n], u[j+n-1], v[n-1]) // x1 | x2 = q̂v_{n-2} - x1, x2 := mulWW_g(qhat, v[n-2]); + x1, x2 := mulWW_g(qhat, v[n-2]) // test if q̂v_{n-2} > br̂ + u_{j+n-2} for greaterThan(x1, x2, rhat, u[j+n-2]) { - qhat--; - prevRhat := rhat; - rhat += v[n-1]; + qhat-- + prevRhat := rhat + rhat += v[n-1] // v[n-1] >= 0, so this tests for overflow. if rhat < prevRhat { break } - x1, x2 = mulWW_g(qhat, v[n-2]); + x1, x2 = mulWW_g(qhat, v[n-2]) } } // D4. - qhatv[len(v)] = mulAddVWW(&qhatv[0], &v[0], qhat, 0, len(v)); + qhatv[len(v)] = mulAddVWW(&qhatv[0], &v[0], qhat, 0, len(v)) - c := subVV(&u[j], &u[j], &qhatv[0], len(qhatv)); + c := subVV(&u[j], &u[j], &qhatv[0], len(qhatv)) if c != 0 { - c := addVV(&u[j], &u[j], &v[0], len(v)); - u[j+len(v)] += c; - qhat--; + c := addVV(&u[j], &u[j], &v[0], len(v)) + u[j+len(v)] += c + qhat-- } - q[j] = qhat; + q[j] = qhat } - q = normN(q); - shiftRight(u, u, shift); - shiftRight(v, v, shift); - r = normN(u); + q = normN(q) + shiftRight(u, u, shift) + shiftRight(v, v, shift) + r = normN(u) - return q, r; + return q, r } @@ -358,11 +358,11 @@ func divLargeNN(z, z2, uIn, v []Word) (q, r []Word) { // The result is the integer n for which 2^n <= x < 2^(n+1). // If x == 0, the result is -1. func log2(x Word) int { - n := 0; + n := 0 for ; x > 0; x >>= 1 { n++ } - return n - 1; + return n - 1 } @@ -370,16 +370,16 @@ func log2(x Word) int { // The result is the integer n for which 2^n <= x < 2^(n+1). // If x == 0, the result is -1. func log2N(x []Word) int { - m := len(x); + m := len(x) if m > 0 { return (m-1)*_W + log2(x[m-1]) } - return -1; + return -1 } func hexValue(ch byte) int { - var d byte; + var d byte switch { case '0' <= ch && ch <= '9': d = ch - '0' @@ -390,7 +390,7 @@ func hexValue(ch byte) int { default: return -1 } - return int(d); + return int(d) } @@ -406,16 +406,16 @@ func hexValue(ch byte) int { // func scanN(z []Word, s string, base int) ([]Word, int, int) { // determine base if necessary - i, n := 0, len(s); + i, n := 0, len(s) if base == 0 { - base = 10; + base = 10 if n > 0 && s[0] == '0' { if n > 1 && (s[1] == 'x' || s[1] == 'X') { if n == 2 { // Reject a string which is just '0x' as nonsense. return nil, 0, 0 } - base, i = 16, 2; + base, i = 16, 2 } else { base, i = 8, 1 } @@ -426,9 +426,9 @@ func scanN(z []Word, s string, base int) ([]Word, int, int) { } // convert string - z = makeN(z, len(z), false); + z = makeN(z, len(z), false) for ; i < n; i++ { - d := hexValue(s[i]); + d := hexValue(s[i]) if 0 <= d && d < base { z = mulAddNWW(z, z, Word(base), Word(d)) } else { @@ -436,7 +436,7 @@ func scanN(z []Word, s string, base int) ([]Word, int, int) { } } - return z, base, i; + return z, base, i } @@ -453,40 +453,40 @@ func stringN(x []Word, base int) string { } // allocate buffer for conversion - i := (log2N(x)+1)/log2(Word(base)) + 1; // +1: round up - s := make([]byte, i); + i := (log2N(x)+1)/log2(Word(base)) + 1 // +1: round up + s := make([]byte, i) // don't destroy x - q := setN(nil, x); + q := setN(nil, x) // convert for len(q) > 0 { - i--; - var r Word; - q, r = divNW(q, q, Word(base)); - s[i] = "0123456789abcdef"[r]; + i-- + var r Word + q, r = divNW(q, q, Word(base)) + s[i] = "0123456789abcdef"[r] } - return string(s[i:]); + return string(s[i:]) } // leadingZeroBits returns the number of leading zero bits in x. func leadingZeroBits(x Word) int { - c := 0; + c := 0 if x < 1<<(_W/2) { - x <<= _W / 2; - c = _W / 2; + x <<= _W / 2 + c = _W / 2 } for i := 0; x != 0; i++ { if x&(1<<(_W-1)) != 0 { return i + c } - x <<= 1; + x <<= 1 } - return _W; + return _W } const deBruijn32 = 0x077CB531 @@ -526,7 +526,7 @@ func trailingZeroBits(x Word) int { panic("Unknown word size") } - return 0; + return 0 } @@ -535,12 +535,12 @@ func shiftLeft(dst, src []Word, n int) { return } - ñ := _W - uint(n); + ñ := _W - uint(n) for i := len(src) - 1; i >= 1; i-- { - dst[i] = src[i] << uint(n); - dst[i] |= src[i-1] >> ñ; + dst[i] = src[i] << uint(n) + dst[i] |= src[i-1] >> ñ } - dst[0] = src[0] << uint(n); + dst[0] = src[0] << uint(n) } @@ -549,24 +549,24 @@ func shiftRight(dst, src []Word, n int) { return } - ñ := _W - uint(n); + ñ := _W - uint(n) for i := 0; i < len(src)-1; i++ { - dst[i] = src[i] >> uint(n); - dst[i] |= src[i+1] << ñ; + dst[i] = src[i] >> uint(n) + dst[i] |= src[i+1] << ñ } - dst[len(src)-1] = src[len(src)-1] >> uint(n); + dst[len(src)-1] = src[len(src)-1] >> uint(n) } // greaterThan returns true iff (x1<<_W + x2) > (y1<<_W + y2) -func greaterThan(x1, x2, y1, y2 Word) bool { return x1 > y1 || x1 == y1 && x2 > y2 } +func greaterThan(x1, x2, y1, y2 Word) bool { return x1 > y1 || x1 == y1 && x2 > y2 } // modNW returns x % d. func modNW(x []Word, d Word) (r Word) { // TODO(agl): we don't actually need to store the q value. - q := makeN(nil, len(x), false); - return divWVW(&q[0], 0, &x[0], d, len(x)); + q := makeN(nil, len(x), false) + return divWVW(&q[0], 0, &x[0], d, len(x)) } @@ -576,28 +576,28 @@ func powersOfTwoDecompose(n []Word) (q []Word, k Word) { return n, 0 } - zeroWords := 0; + zeroWords := 0 for n[zeroWords] == 0 { zeroWords++ } // One of the words must be non-zero by invariant, therefore // zeroWords < len(n). - x := trailingZeroBits(n[zeroWords]); + x := trailingZeroBits(n[zeroWords]) - q = makeN(nil, len(n)-zeroWords, false); - shiftRight(q, n[zeroWords:], x); + q = makeN(nil, len(n)-zeroWords, false) + shiftRight(q, n[zeroWords:], x) - k = Word(_W*zeroWords + x); - return; + k = Word(_W*zeroWords + x) + return } // randomN creates a random integer in [0..limit), using the space in z if // possible. n is the bit length of limit. func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word { - bitLengthOfMSW := uint(n % _W); - mask := Word((1 << bitLengthOfMSW) - 1); - z = makeN(z, len(limit), false); + bitLengthOfMSW := uint(n % _W) + mask := Word((1 << bitLengthOfMSW) - 1) + z = makeN(z, len(limit), false) for { for i := range z { @@ -609,14 +609,14 @@ func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word { } } - z[len(limit)-1] &= mask; + z[len(limit)-1] &= mask if cmpNN(z, limit) < 0 { break } } - return z; + return z } @@ -624,32 +624,32 @@ func randomN(z []Word, rand *rand.Rand, limit []Word, n int) []Word { // reuses the storage of z if possible. func expNNN(z, x, y, m []Word) []Word { if len(y) == 0 { - z = makeN(z, 1, false); - z[0] = 1; - return z; + z = makeN(z, 1, false) + z[0] = 1 + return z } if m != nil { // We likely end up being as long as the modulus. z = makeN(z, len(m), false) } - z = setN(z, x); - v := y[len(y)-1]; + z = setN(z, x) + v := y[len(y)-1] // It's invalid for the most significant word to be zero, therefore we // will find a one bit. - shift := leadingZeros(v) + 1; - v <<= shift; - var q []Word; + shift := leadingZeros(v) + 1 + v <<= shift + var q []Word - const mask = 1 << (_W - 1); + const mask = 1 << (_W - 1) // We walk through the bits of the exponent one by one. Each time we // see a bit, we square, thus doubling the power. If the bit is a one, // we also multiply by x, thus adding one to the power. - w := _W - int(shift); + w := _W - int(shift) for j := 0; j < w; j++ { - z = mulNN(z, z, z); + z = mulNN(z, z, z) if v&mask != 0 { z = mulNN(z, z, x) @@ -659,14 +659,14 @@ func expNNN(z, x, y, m []Word) []Word { q, z = divNN(q, z, z, m) } - v <<= 1; + v <<= 1 } for i := len(y) - 2; i >= 0; i-- { - v = y[i]; + v = y[i] for j := 0; j < _W; j++ { - z = mulNN(z, z, z); + z = mulNN(z, z, z) if v&mask != 0 { z = mulNN(z, z, x) @@ -676,11 +676,11 @@ func expNNN(z, x, y, m []Word) []Word { q, z = divNN(q, z, z, m) } - v <<= 1; + v <<= 1 } } - return z; + return z } @@ -690,13 +690,13 @@ func lenN(z []Word) int { return 0 } - return (len(z)-1)*_W + (_W - leadingZeroBits(z[len(z)-1])); + return (len(z)-1)*_W + (_W - leadingZeroBits(z[len(z)-1])) } const ( - primesProduct32 = 0xC0CFD797; // Π {p ∈ primes, 2 < p <= 29} - primesProduct64 = 0xE221F97C30E94E1D; // Π {p ∈ primes, 2 < p <= 53} + primesProduct32 = 0xC0CFD797 // Π {p ∈ primes, 2 < p <= 29} + primesProduct64 = 0xE221F97C30E94E1D // Π {p ∈ primes, 2 < p <= 53} ) var bigOne = []Word{1} @@ -725,7 +725,7 @@ func probablyPrime(n []Word, reps int) bool { } } - var r Word; + var r Word switch _W { case 32: r = modNW(n, primesProduct32) @@ -745,27 +745,27 @@ func probablyPrime(n []Word, reps int) bool { return false } - nm1 := subNN(nil, n, bigOne); + nm1 := subNN(nil, n, bigOne) // 1<<k * q = nm1; - q, k := powersOfTwoDecompose(nm1); + q, k := powersOfTwoDecompose(nm1) - nm3 := subNN(nil, nm1, bigTwo); - rand := rand.New(rand.NewSource(int64(n[0]))); + nm3 := subNN(nil, nm1, bigTwo) + rand := rand.New(rand.NewSource(int64(n[0]))) - var x, y, quotient []Word; - nm3Len := lenN(nm3); + var x, y, quotient []Word + nm3Len := lenN(nm3) NextRandom: for i := 0; i < reps; i++ { - x = randomN(x, rand, nm3, nm3Len); - addNN(x, x, bigTwo); - y = expNNN(y, x, q, n); + x = randomN(x, rand, nm3, nm3Len) + addNN(x, x, bigTwo) + y = expNNN(y, x, q, n) if cmpNN(y, bigOne) == 0 || cmpNN(y, nm1) == 0 { continue } for j := Word(1); j < k; j++ { - y = mulNN(y, y, y); - quotient, y = divNN(quotient, y, y, n); + y = mulNN(y, y, y) + quotient, y = divNN(quotient, y, y, n) if cmpNN(y, nm1) == 0 { continue NextRandom } @@ -773,8 +773,8 @@ NextRandom: return false } } - return false; + return false } - return true; + return true } diff --git a/src/pkg/big/nat_test.go b/src/pkg/big/nat_test.go index b1c9c1a10..1c993bad1 100644 --- a/src/pkg/big/nat_test.go +++ b/src/pkg/big/nat_test.go @@ -13,7 +13,7 @@ func TestCmpNN(t *testing.T) { type funNN func(z, x, y []Word) []Word type argNN struct { - z, x, y []Word; + z, x, y []Word } @@ -41,7 +41,7 @@ var prodNN = []argNN{ func TestSetN(t *testing.T) { for _, a := range sumNN { - z := setN(nil, a.z); + z := setN(nil, a.z) if cmpNN(z, a.z) != 0 { t.Errorf("got z = %v; want %v", z, a.z) } @@ -50,7 +50,7 @@ func TestSetN(t *testing.T) { func testFunNN(t *testing.T, msg string, f funNN, a argNN) { - z := f(nil, a.x, a.y); + z := f(nil, a.x, a.y) if cmpNN(z, a.z) != 0 { t.Errorf("%s%+v\n\tgot z = %v; want %v", msg, a, z, a.z) } @@ -59,33 +59,33 @@ func testFunNN(t *testing.T, msg string, f funNN, a argNN) { func TestFunNN(t *testing.T) { for _, a := range sumNN { - arg := a; - testFunNN(t, "addNN", addNN, arg); + arg := a + testFunNN(t, "addNN", addNN, arg) - arg = argNN{a.z, a.y, a.x}; - testFunNN(t, "addNN symmetric", addNN, arg); + arg = argNN{a.z, a.y, a.x} + testFunNN(t, "addNN symmetric", addNN, arg) - arg = argNN{a.x, a.z, a.y}; - testFunNN(t, "subNN", subNN, arg); + arg = argNN{a.x, a.z, a.y} + testFunNN(t, "subNN", subNN, arg) - arg = argNN{a.y, a.z, a.x}; - testFunNN(t, "subNN symmetric", subNN, arg); + arg = argNN{a.y, a.z, a.x} + testFunNN(t, "subNN symmetric", subNN, arg) } for _, a := range prodNN { - arg := a; - testFunNN(t, "mulNN", mulNN, arg); + arg := a + testFunNN(t, "mulNN", mulNN, arg) - arg = argNN{a.z, a.y, a.x}; - testFunNN(t, "mulNN symmetric", mulNN, arg); + arg = argNN{a.z, a.y, a.x} + testFunNN(t, "mulNN symmetric", mulNN, arg) } } type strN struct { - x []Word; - b int; - s string; + x []Word + b int + s string } @@ -99,12 +99,12 @@ var tabN = []strN{ func TestStringN(t *testing.T) { for _, a := range tabN { - s := stringN(a.x, a.b); + s := stringN(a.x, a.b) if s != a.s { t.Errorf("stringN%+v\n\tgot s = %s; want %s", a, s, a.s) } - x, b, n := scanN(nil, a.s, a.b); + x, b, n := scanN(nil, a.s, a.b) if cmpNN(x, a.x) != 0 { t.Errorf("scanN%+v\n\tgot z = %v; want %v", a, x, a.x) } @@ -119,20 +119,20 @@ func TestStringN(t *testing.T) { func TestLeadingZeroBits(t *testing.T) { - var x Word = 1 << (_W - 1); + var x Word = 1 << (_W - 1) for i := 0; i <= _W; i++ { if leadingZeroBits(x) != i { t.Errorf("failed at %x: got %d want %d", x, leadingZeroBits(x), i) } - x >>= 1; + x >>= 1 } } type shiftTest struct { - in []Word; - shift int; - out []Word; + in []Word + shift int + out []Word } @@ -149,12 +149,12 @@ var leftShiftTests = []shiftTest{ func TestShiftLeft(t *testing.T) { for i, test := range leftShiftTests { - dst := make([]Word, len(test.out)); - shiftLeft(dst, test.in, test.shift); + dst := make([]Word, len(test.out)) + shiftLeft(dst, test.in, test.shift) for j, v := range dst { if test.out[j] != v { - t.Errorf("#%d: got: %v want: %v", i, dst, test.out); - break; + t.Errorf("#%d: got: %v want: %v", i, dst, test.out) + break } } } @@ -175,12 +175,12 @@ var rightShiftTests = []shiftTest{ func TestShiftRight(t *testing.T) { for i, test := range rightShiftTests { - dst := make([]Word, len(test.out)); - shiftRight(dst, test.in, test.shift); + dst := make([]Word, len(test.out)) + shiftRight(dst, test.in, test.shift) for j, v := range dst { if test.out[j] != v { - t.Errorf("#%d: got: %v want: %v", i, dst, test.out); - break; + t.Errorf("#%d: got: %v want: %v", i, dst, test.out) + break } } } @@ -188,9 +188,9 @@ func TestShiftRight(t *testing.T) { type modNWTest struct { - in string; - dividend string; - out string; + in string + dividend string + out string } @@ -206,11 +206,11 @@ var modNWTests64 = []modNWTest{ func runModNWTests(t *testing.T, tests []modNWTest) { for i, test := range tests { - in, _ := new(Int).SetString(test.in, 10); - d, _ := new(Int).SetString(test.dividend, 10); - out, _ := new(Int).SetString(test.out, 10); + in, _ := new(Int).SetString(test.in, 10) + d, _ := new(Int).SetString(test.dividend, 10) + out, _ := new(Int).SetString(test.out, 10) - r := modNW(in.abs, d.abs[0]); + r := modNW(in.abs, d.abs[0]) if r != out.abs[0] { t.Errorf("#%d failed: got %s want %s\n", i, r, out) } @@ -229,20 +229,20 @@ func TestModNW(t *testing.T) { func TestTrailingZeroBits(t *testing.T) { - var x Word; - x--; + var x Word + x-- for i := 0; i < _W; i++ { if trailingZeroBits(x) != i { t.Errorf("Failed at step %d: x: %x got: %d\n", i, x, trailingZeroBits(x)) } - x <<= 1; + x <<= 1 } } type expNNNTest struct { - x, y, m string; - out string; + x, y, m string + out string } @@ -263,17 +263,17 @@ var expNNNTests = []expNNNTest{ func TestExpNNN(t *testing.T) { for i, test := range expNNNTests { - x, _, _ := scanN(nil, test.x, 0); - y, _, _ := scanN(nil, test.y, 0); - out, _, _ := scanN(nil, test.out, 0); + x, _, _ := scanN(nil, test.x, 0) + y, _, _ := scanN(nil, test.y, 0) + out, _, _ := scanN(nil, test.out, 0) - var m []Word; + var m []Word if len(test.m) > 0 { m, _, _ = scanN(nil, test.m, 0) } - z := expNNN(nil, x, y, m); + z := expNNN(nil, x, y, m) if cmpNN(z, out) != 0 { t.Errorf("#%d got %v want %v", i, z, out) } diff --git a/src/pkg/bignum/arith.go b/src/pkg/bignum/arith.go index 243e34b9c..aa65dbd7a 100644 --- a/src/pkg/bignum/arith.go +++ b/src/pkg/bignum/arith.go @@ -18,10 +18,10 @@ func Mul128(x, y uint64) (z1, z0 uint64) { // and return the product as 2 words. const ( - W = uint(unsafe.Sizeof(x)) * 8; - W2 = W / 2; - B2 = 1 << W2; - M2 = B2 - 1; + W = uint(unsafe.Sizeof(x)) * 8 + W2 = W / 2 + B2 = 1 << W2 + M2 = B2 - 1 ) if x < y { @@ -32,44 +32,44 @@ func Mul128(x, y uint64) (z1, z0 uint64) { // y < B2 because y <= x // sub-digits of x and y are (0, x) and (0, y) // z = z[0] = x*y - z0 = x * y; - return; + z0 = x * y + return } if y < B2 { // sub-digits of x and y are (x1, x0) and (0, y) // x = (x1*B2 + x0) // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2; + x1, x0 := x>>W2, x&M2 // x*y = t2*B2*B2 + t1*B2 + t0 - t0 := x0 * y; - t1 := x1 * y; + t0 := x0 * y + t1 := x1 * y // compute result digits but avoid overflow // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0; - z1 = (t1 + t0>>W2) >> W2; - return; + z0 = t1<<W2 + t0 + z1 = (t1 + t0>>W2) >> W2 + return } // general case // sub-digits of x and y are (x1, x0) and (y1, y0) // x = (x1*B2 + x0) // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2; - y1, y0 := y>>W2, y&M2; + x1, x0 := x>>W2, x&M2 + y1, y0 := y>>W2, y&M2 // x*y = t2*B2*B2 + t1*B2 + t0 - t0 := x0 * y0; - t1 := x1*y0 + x0*y1; - t2 := x1 * y1; + t0 := x0 * y0 + t1 := x1*y0 + x0*y1 + t2 := x1 * y1 // compute result digits but avoid overflow // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0; - z1 = t2 + (t1+t0>>W2)>>W2; - return; + z0 = t1<<W2 + t0 + z1 = t2 + (t1+t0>>W2)>>W2 + return } @@ -80,10 +80,10 @@ func MulAdd128(x, y, c uint64) (z1, z0 uint64) { // and return the product as 2 words. const ( - W = uint(unsafe.Sizeof(x)) * 8; - W2 = W / 2; - B2 = 1 << W2; - M2 = B2 - 1; + W = uint(unsafe.Sizeof(x)) * 8 + W2 = W / 2 + B2 = 1 << W2 + M2 = B2 - 1 ) // TODO(gri) Should implement special cases for faster execution. @@ -92,30 +92,30 @@ func MulAdd128(x, y, c uint64) (z1, z0 uint64) { // sub-digits of x, y, and c are (x1, x0), (y1, y0), (c1, c0) // x = (x1*B2 + x0) // y = (y1*B2 + y0) - x1, x0 := x>>W2, x&M2; - y1, y0 := y>>W2, y&M2; - c1, c0 := c>>W2, c&M2; + x1, x0 := x>>W2, x&M2 + y1, y0 := y>>W2, y&M2 + c1, c0 := c>>W2, c&M2 // x*y + c = t2*B2*B2 + t1*B2 + t0 - t0 := x0*y0 + c0; - t1 := x1*y0 + x0*y1 + c1; - t2 := x1 * y1; + t0 := x0*y0 + c0 + t1 := x1*y0 + x0*y1 + c1 + t2 := x1 * y1 // compute result digits but avoid overflow // z = z[1]*B + z[0] = x*y - z0 = t1<<W2 + t0; - z1 = t2 + (t1+t0>>W2)>>W2; - return; + z0 = t1<<W2 + t0 + z1 = t2 + (t1+t0>>W2)>>W2 + return } // q = (x1<<64 + x0)/y + r func Div128(x1, x0, y uint64) (q, r uint64) { if x1 == 0 { - q, r = x0/y, x0%y; - return; + q, r = x0/y, x0%y + return } // TODO(gri) Implement general case. - panic("Div128 not implemented for x > 1<<64-1"); + panic("Div128 not implemented for x > 1<<64-1") } diff --git a/src/pkg/bignum/bignum.go b/src/pkg/bignum/bignum.go index 8106a2664..ee7d45ba6 100644 --- a/src/pkg/bignum/bignum.go +++ b/src/pkg/bignum/bignum.go @@ -16,7 +16,7 @@ package bignum import ( - "fmt"; + "fmt" ) // TODO(gri) Complete the set of in-place operations. @@ -60,25 +60,25 @@ import ( // in bits must be even. type ( - digit uint64; - digit2 uint32; // half-digits for division + digit uint64 + digit2 uint32 // half-digits for division ) const ( - logW = 64; // word width - logH = 4; // bits for a hex digit (= small number) - logB = logW - logH; // largest bit-width available + logW = 64 // word width + logH = 4 // bits for a hex digit (= small number) + logB = logW - logH // largest bit-width available // half-digits - _W2 = logB / 2; // width - _B2 = 1 << _W2; // base - _M2 = _B2 - 1; // mask + _W2 = logB / 2 // width + _B2 = 1 << _W2 // base + _M2 = _B2 - 1 // mask // full digits - _W = _W2 * 2; // width - _B = 1 << _W; // base - _M = _B - 1; // mask + _W = _W2 * 2 // width + _B = 1 << _W // base + _M = _B - 1 // mask ) @@ -92,7 +92,7 @@ func assert(p bool) { } -func isSmall(x digit) bool { return x < 1<<logH } +func isSmall(x digit) bool { return x < 1<<logH } // For debugging. Keep around. @@ -119,7 +119,7 @@ type Natural []digit // func Nat(x uint64) Natural { if x == 0 { - return nil // len == 0 + return nil // len == 0 } // single-digit values @@ -132,19 +132,19 @@ func Nat(x uint64) Natural { // compute number of digits required to represent x // (this is usually 1 or 2, but the algorithm works // for any base) - n := 0; + n := 0 for t := x; t > 0; t >>= _W { n++ } // split x into digits - z := make(Natural, n); + z := make(Natural, n) for i := 0; i < n; i++ { - z[i] = digit(x & _M); - x >>= _W; + z[i] = digit(x & _M) + x >>= _W } - return z; + return z } @@ -152,7 +152,7 @@ func Nat(x uint64) Natural { // func (x Natural) Value() uint64 { // single-digit values - n := len(x); + n := len(x) switch n { case 0: return 0 @@ -163,14 +163,14 @@ func (x Natural) Value() uint64 { // multi-digit values // (this is usually 1 or 2, but the algorithm works // for any base) - z := uint64(0); - s := uint(0); + z := uint64(0) + s := uint(0) for i := 0; i < n && s < 64; i++ { - z += uint64(x[i]) << s; - s += _W; + z += uint64(x[i]) << s + s += _W } - return z; + return z } @@ -178,17 +178,17 @@ func (x Natural) Value() uint64 { // IsEven returns true iff x is divisible by 2. // -func (x Natural) IsEven() bool { return len(x) == 0 || x[0]&1 == 0 } +func (x Natural) IsEven() bool { return len(x) == 0 || x[0]&1 == 0 } // IsOdd returns true iff x is not divisible by 2. // -func (x Natural) IsOdd() bool { return len(x) > 0 && x[0]&1 != 0 } +func (x Natural) IsOdd() bool { return len(x) > 0 && x[0]&1 != 0 } // IsZero returns true iff x == 0. // -func (x Natural) IsZero() bool { return len(x) == 0 } +func (x Natural) IsZero() bool { return len(x) == 0 } // Operations @@ -201,11 +201,11 @@ func (x Natural) IsZero() bool { return len(x) == 0 } // n, m len(x), len(y) func normalize(x Natural) Natural { - n := len(x); + n := len(x) for n > 0 && x[n-1] == 0 { n-- } - return x[0:n]; + return x[0:n] } @@ -214,14 +214,14 @@ func normalize(x Natural) Natural { // Natural is allocated. // func nalloc(z Natural, n int) Natural { - size := n; + size := n if size <= 0 { size = 4 } if size <= cap(z) { return z[0:n] } - return make(Natural, n, size); + return make(Natural, n, size) } @@ -229,40 +229,40 @@ func nalloc(z Natural, n int) Natural { // *zp may be x or y. // func Nadd(zp *Natural, x, y Natural) { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { - Nadd(zp, y, x); - return; + Nadd(zp, y, x) + return } - z := nalloc(*zp, n+1); - c := digit(0); - i := 0; + z := nalloc(*zp, n+1) + c := digit(0) + i := 0 for i < m { - t := c + x[i] + y[i]; - c, z[i] = t>>_W, t&_M; - i++; + t := c + x[i] + y[i] + c, z[i] = t>>_W, t&_M + i++ } for i < n { - t := c + x[i]; - c, z[i] = t>>_W, t&_M; - i++; + t := c + x[i] + c, z[i] = t>>_W, t&_M + i++ } if c != 0 { - z[i] = c; - i++; + z[i] = c + i++ } - *zp = z[0:i]; + *zp = z[0:i] } // Add returns the sum z = x + y. // func (x Natural) Add(y Natural) Natural { - var z Natural; - Nadd(&z, x, y); - return z; + var z Natural + Nadd(&z, x, y) + return z } @@ -271,29 +271,29 @@ func (x Natural) Add(y Natural) Natural { // *zp may be x or y. // func Nsub(zp *Natural, x, y Natural) { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { panic("underflow") } - z := nalloc(*zp, n); - c := digit(0); - i := 0; + z := nalloc(*zp, n) + c := digit(0) + i := 0 for i < m { - t := c + x[i] - y[i]; - c, z[i] = digit(int64(t)>>_W), t&_M; // requires arithmetic shift! - i++; + t := c + x[i] - y[i] + c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift! + i++ } for i < n { - t := c + x[i]; - c, z[i] = digit(int64(t)>>_W), t&_M; // requires arithmetic shift! - i++; + t := c + x[i] + c, z[i] = digit(int64(t)>>_W), t&_M // requires arithmetic shift! + i++ } if int64(c) < 0 { panic("underflow") } - *zp = normalize(z); + *zp = normalize(z) } @@ -301,17 +301,17 @@ func Nsub(zp *Natural, x, y Natural) { // If x < y, an underflow run-time error occurs (use Cmp to test if x >= y). // func (x Natural) Sub(y Natural) Natural { - var z Natural; - Nsub(&z, x, y); - return z; + var z Natural + Nsub(&z, x, y) + return z } // Returns z1 = (x*y + c) div B, z0 = (x*y + c) mod B. // func muladd11(x, y, c digit) (digit, digit) { - z1, z0 := MulAdd128(uint64(x), uint64(y), uint64(c)); - return digit(z1<<(64-logB) | z0>>logB), digit(z0 & _M); + z1, z0 := MulAdd128(uint64(x), uint64(y), uint64(c)) + return digit(z1<<(64-logB) | z0>>logB), digit(z0 & _M) } @@ -319,7 +319,7 @@ func mul1(z, x Natural, y digit) (c digit) { for i := 0; i < len(x); i++ { c, z[i] = muladd11(x[i], y, c) } - return; + return } @@ -328,29 +328,29 @@ func mul1(z, x Natural, y digit) (c digit) { func Nscale(z *Natural, d uint64) { switch { case d == 0: - *z = Nat(0); - return; + *z = Nat(0) + return case d == 1: return case d >= _B: - *z = z.Mul1(d); - return; + *z = z.Mul1(d) + return } - c := mul1(*z, *z, digit(d)); + c := mul1(*z, *z, digit(d)) if c != 0 { - n := len(*z); + n := len(*z) if n >= cap(*z) { - zz := make(Natural, n+1); + zz := make(Natural, n+1) for i, d := range *z { zz[i] = d } - *z = zz; + *z = zz } else { *z = (*z)[0 : n+1] } - (*z)[n] = c; + (*z)[n] = c } } @@ -358,17 +358,17 @@ func Nscale(z *Natural, d uint64) { // Computes x = x*d + c for small d's. // func muladd1(x Natural, d, c digit) Natural { - assert(isSmall(d-1) && isSmall(c)); - n := len(x); - z := make(Natural, n+1); + assert(isSmall(d-1) && isSmall(c)) + n := len(x) + z := make(Natural, n+1) for i := 0; i < n; i++ { - t := c + x[i]*d; - c, z[i] = t>>_W, t&_M; + t := c + x[i]*d + c, z[i] = t>>_W, t&_M } - z[n] = c; + z[n] = c - return normalize(z); + return normalize(z) } @@ -386,18 +386,18 @@ func (x Natural) Mul1(d uint64) Natural { return x.Mul(Nat(d)) } - z := make(Natural, len(x)+1); - c := mul1(z, x, digit(d)); - z[len(x)] = c; - return normalize(z); + z := make(Natural, len(x)+1) + c := mul1(z, x, digit(d)) + z[len(x)] = c + return normalize(z) } // Mul returns the product x * y. // func (x Natural) Mul(y Natural) Natural { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { return y.Mul(x) } @@ -410,19 +410,19 @@ func (x Natural) Mul(y Natural) Natural { return x.Mul1(uint64(y[0])) } - z := make(Natural, n+m); + z := make(Natural, n+m) for j := 0; j < m; j++ { - d := y[j]; + d := y[j] if d != 0 { - c := digit(0); + c := digit(0) for i := 0; i < n; i++ { c, z[i+j] = muladd11(x[i], d, z[i+j]+c) } - z[n+j] = c; + z[n+j] = c } } - return normalize(z); + return normalize(z) } @@ -432,57 +432,57 @@ func (x Natural) Mul(y Natural) Natural { // DivMod, and then pack the results again. func unpack(x Natural) []digit2 { - n := len(x); - z := make([]digit2, n*2+1); // add space for extra digit (used by DivMod) + n := len(x) + z := make([]digit2, n*2+1) // add space for extra digit (used by DivMod) for i := 0; i < n; i++ { - t := x[i]; - z[i*2] = digit2(t & _M2); - z[i*2+1] = digit2(t >> _W2 & _M2); + t := x[i] + z[i*2] = digit2(t & _M2) + z[i*2+1] = digit2(t >> _W2 & _M2) } // normalize result - k := 2 * n; + k := 2 * n for k > 0 && z[k-1] == 0 { k-- } - return z[0:k]; // trim leading 0's + return z[0:k] // trim leading 0's } func pack(x []digit2) Natural { - n := (len(x) + 1) / 2; - z := make(Natural, n); + n := (len(x) + 1) / 2 + z := make(Natural, n) if len(x)&1 == 1 { // handle odd len(x) - n--; - z[n] = digit(x[n*2]); + n-- + z[n] = digit(x[n*2]) } for i := 0; i < n; i++ { z[i] = digit(x[i*2+1])<<_W2 | digit(x[i*2]) } - return normalize(z); + return normalize(z) } func mul21(z, x []digit2, y digit2) digit2 { - c := digit(0); - f := digit(y); + c := digit(0) + f := digit(y) for i := 0; i < len(x); i++ { - t := c + digit(x[i])*f; - c, z[i] = t>>_W2, digit2(t&_M2); + t := c + digit(x[i])*f + c, z[i] = t>>_W2, digit2(t&_M2) } - return digit2(c); + return digit2(c) } func div21(z, x []digit2, y digit2) digit2 { - c := digit(0); - d := digit(y); + c := digit(0) + d := digit(y) for i := len(x) - 1; i >= 0; i-- { - t := c<<_W2 + digit(x[i]); - c, z[i] = t%d, digit2(t/d); + t := c<<_W2 + digit(x[i]) + c, z[i] = t%d, digit2(t/d) } - return digit2(c); + return digit2(c) } @@ -507,14 +507,14 @@ func div21(z, x []digit2, y digit2) digit2 { // 579-601. John Wiley & Sons, Ltd. func divmod(x, y []digit2) ([]digit2, []digit2) { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if m == 0 { panic("division by zero") } - assert(n+1 <= cap(x)); // space for one extra digit - x = x[0 : n+1]; - assert(x[n] == 0); + assert(n+1 <= cap(x)) // space for one extra digit + x = x[0 : n+1] + assert(x[n] == 0) if m == 1 { // division by single digit @@ -528,27 +528,27 @@ func divmod(x, y []digit2) ([]digit2, []digit2) { } else { // general case - assert(2 <= m && m <= n); + assert(2 <= m && m <= n) // normalize x and y // TODO Instead of multiplying, it would be sufficient to // shift y such that the normalization condition is // satisfied (as done in Hacker's Delight). - f := _B2 / (digit(y[m-1]) + 1); + f := _B2 / (digit(y[m-1]) + 1) if f != 1 { - mul21(x, x, digit2(f)); - mul21(y, y, digit2(f)); + mul21(x, x, digit2(f)) + mul21(y, y, digit2(f)) } - assert(_B2/2 <= y[m-1] && y[m-1] < _B2); // incorrect scaling + assert(_B2/2 <= y[m-1] && y[m-1] < _B2) // incorrect scaling - y1, y2 := digit(y[m-1]), digit(y[m-2]); + y1, y2 := digit(y[m-1]), digit(y[m-2]) for i := n - m; i >= 0; i-- { - k := i + m; + k := i + m // compute trial digit (Knuth) - var q digit; + var q digit { - x0, x1, x2 := digit(x[k]), digit(x[k-1]), digit(x[k-2]); + x0, x1, x2 := digit(x[k]), digit(x[k-1]), digit(x[k-2]) if x0 != y1 { q = (x0<<_W2 + x1) / y1 } else { @@ -560,36 +560,36 @@ func divmod(x, y []digit2) ([]digit2, []digit2) { } // subtract y*q - c := digit(0); + c := digit(0) for j := 0; j < m; j++ { - t := c + digit(x[i+j]) - digit(y[j])*q; - c, x[i+j] = digit(int64(t)>>_W2), digit2(t&_M2); // requires arithmetic shift! + t := c + digit(x[i+j]) - digit(y[j])*q + c, x[i+j] = digit(int64(t)>>_W2), digit2(t&_M2) // requires arithmetic shift! } // correct if trial digit was too large if c+digit(x[k]) != 0 { // add y - c := digit(0); + c := digit(0) for j := 0; j < m; j++ { - t := c + digit(x[i+j]) + digit(y[j]); - c, x[i+j] = t>>_W2, digit2(t&_M2); + t := c + digit(x[i+j]) + digit(y[j]) + c, x[i+j] = t>>_W2, digit2(t&_M2) } - assert(c+digit(x[k]) == 0); + assert(c+digit(x[k]) == 0) // correct trial digit - q--; + q-- } - x[k] = digit2(q); + x[k] = digit2(q) } // undo normalization for remainder if f != 1 { - c := div21(x[0:m], x[0:m], digit2(f)); - assert(c == 0); + c := div21(x[0:m], x[0:m], digit2(f)) + assert(c == 0) } } - return x[m : n+1], x[0:m]; + return x[m : n+1], x[0:m] } @@ -598,8 +598,8 @@ func divmod(x, y []digit2) ([]digit2, []digit2) { // If y == 0, a division-by-zero run-time error occurs. // func (x Natural) Div(y Natural) Natural { - q, _ := divmod(unpack(x), unpack(y)); - return pack(q); + q, _ := divmod(unpack(x), unpack(y)) + return pack(q) } @@ -608,8 +608,8 @@ func (x Natural) Div(y Natural) Natural { // If y == 0, a division-by-zero run-time error occurs. // func (x Natural) Mod(y Natural) Natural { - _, r := divmod(unpack(x), unpack(y)); - return pack(r); + _, r := divmod(unpack(x), unpack(y)) + return pack(r) } @@ -617,78 +617,78 @@ func (x Natural) Mod(y Natural) Natural { // If y == 0, a division-by-zero run-time error occurs. // func (x Natural) DivMod(y Natural) (Natural, Natural) { - q, r := divmod(unpack(x), unpack(y)); - return pack(q), pack(r); + q, r := divmod(unpack(x), unpack(y)) + return pack(q), pack(r) } func shl(z, x Natural, s uint) digit { - assert(s <= _W); - n := len(x); - c := digit(0); + assert(s <= _W) + n := len(x) + c := digit(0) for i := 0; i < n; i++ { c, z[i] = x[i]>>(_W-s), x[i]<<s&_M|c } - return c; + return c } // Shl implements ``shift left'' x << s. It returns x * 2^s. // func (x Natural) Shl(s uint) Natural { - n := uint(len(x)); - m := n + s/_W; - z := make(Natural, m+1); + n := uint(len(x)) + m := n + s/_W + z := make(Natural, m+1) - z[m] = shl(z[m-n:m], x, s%_W); + z[m] = shl(z[m-n:m], x, s%_W) - return normalize(z); + return normalize(z) } func shr(z, x Natural, s uint) digit { - assert(s <= _W); - n := len(x); - c := digit(0); + assert(s <= _W) + n := len(x) + c := digit(0) for i := n - 1; i >= 0; i-- { c, z[i] = x[i]<<(_W-s)&_M, x[i]>>s|c } - return c; + return c } // Shr implements ``shift right'' x >> s. It returns x / 2^s. // func (x Natural) Shr(s uint) Natural { - n := uint(len(x)); - m := n - s/_W; - if m > n { // check for underflow + n := uint(len(x)) + m := n - s/_W + if m > n { // check for underflow m = 0 } - z := make(Natural, m); + z := make(Natural, m) - shr(z, x[n-m:n], s%_W); + shr(z, x[n-m:n], s%_W) - return normalize(z); + return normalize(z) } // And returns the ``bitwise and'' x & y for the 2's-complement representation of x and y. // func (x Natural) And(y Natural) Natural { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { return y.And(x) } - z := make(Natural, m); + z := make(Natural, m) for i := 0; i < m; i++ { z[i] = x[i] & y[i] } // upper bits are 0 - return normalize(z); + return normalize(z) } @@ -702,57 +702,57 @@ func copy(z, x Natural) { // AndNot returns the ``bitwise clear'' x &^ y for the 2's-complement representation of x and y. // func (x Natural) AndNot(y Natural) Natural { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { m = n } - z := make(Natural, n); + z := make(Natural, n) for i := 0; i < m; i++ { z[i] = x[i] &^ y[i] } - copy(z[m:n], x[m:n]); + copy(z[m:n], x[m:n]) - return normalize(z); + return normalize(z) } // Or returns the ``bitwise or'' x | y for the 2's-complement representation of x and y. // func (x Natural) Or(y Natural) Natural { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { return y.Or(x) } - z := make(Natural, n); + z := make(Natural, n) for i := 0; i < m; i++ { z[i] = x[i] | y[i] } - copy(z[m:n], x[m:n]); + copy(z[m:n], x[m:n]) - return z; + return z } // Xor returns the ``bitwise exclusive or'' x ^ y for the 2's-complement representation of x and y. // func (x Natural) Xor(y Natural) Natural { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n < m { return y.Xor(x) } - z := make(Natural, n); + z := make(Natural, n) for i := 0; i < m; i++ { z[i] = x[i] ^ y[i] } - copy(z[m:n], x[m:n]); + copy(z[m:n], x[m:n]) - return normalize(z); + return normalize(z) } @@ -763,19 +763,19 @@ func (x Natural) Xor(y Natural) Natural { // > 0 if x > y // func (x Natural) Cmp(y Natural) int { - n := len(x); - m := len(y); + n := len(x) + m := len(y) if n != m || n == 0 { return n - m } - i := n - 1; + i := n - 1 for i > 0 && x[i] == y[i] { i-- } - d := 0; + d := 0 switch { case x[i] < y[i]: d = -1 @@ -783,7 +783,7 @@ func (x Natural) Cmp(y Natural) int { d = 1 } - return d; + return d } @@ -792,13 +792,13 @@ func (x Natural) Cmp(y Natural) int { // If x == 0 a run-time error occurs. // func log2(x uint64) uint { - assert(x > 0); - n := uint(0); + assert(x > 0) + n := uint(0) for x > 0 { - x >>= 1; - n++; + x >>= 1 + n++ } - return n - 1; + return n - 1 } @@ -807,11 +807,11 @@ func log2(x uint64) uint { // If x == 0 a run-time error occurs. // func (x Natural) Log2() uint { - n := len(x); + n := len(x) if n > 0 { return (uint(n)-1)*_W + log2(uint64(x[n-1])) } - panic("Log2(0)"); + panic("Log2(0)") } @@ -819,15 +819,15 @@ func (x Natural) Log2() uint { // Returns updated x and x mod d. // func divmod1(x Natural, d digit) (Natural, digit) { - assert(0 < d && isSmall(d-1)); + assert(0 < d && isSmall(d-1)) - c := digit(0); + c := digit(0) for i := len(x) - 1; i >= 0; i-- { - t := c<<_W + x[i]; - c, x[i] = t%d, t/d; + t := c<<_W + x[i] + c, x[i] = t%d, t/d } - return normalize(x), c; + return normalize(x), c } @@ -839,31 +839,31 @@ func (x Natural) ToString(base uint) string { } // allocate buffer for conversion - assert(2 <= base && base <= 16); - n := (x.Log2()+1)/log2(uint64(base)) + 1; // +1: round up - s := make([]byte, n); + assert(2 <= base && base <= 16) + n := (x.Log2()+1)/log2(uint64(base)) + 1 // +1: round up + s := make([]byte, n) // don't destroy x - t := make(Natural, len(x)); - copy(t, x); + t := make(Natural, len(x)) + copy(t, x) // convert - i := n; + i := n for !t.IsZero() { - i--; - var d digit; - t, d = divmod1(t, digit(base)); - s[i] = "0123456789abcdef"[d]; + i-- + var d digit + t, d = divmod1(t, digit(base)) + s[i] = "0123456789abcdef"[d] } - return string(s[i:n]); + return string(s[i:n]) } // String converts x to its decimal string representation. // x.String() is the same as x.ToString(10). // -func (x Natural) String() string { return x.ToString(10) } +func (x Natural) String() string { return x.ToString(10) } func fmtbase(c int) uint { @@ -875,18 +875,18 @@ func fmtbase(c int) uint { case 'x': return 16 } - return 10; + return 10 } // Format is a support routine for fmt.Formatter. It accepts // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). // -func (x Natural) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } +func (x Natural) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } func hexvalue(ch byte) uint { - d := uint(1 << logH); + d := uint(1 << logH) switch { case '0' <= ch && ch <= '9': d = uint(ch - '0') @@ -895,7 +895,7 @@ func hexvalue(ch byte) uint { case 'A' <= ch && ch <= 'F': d = uint(ch-'A') + 10 } - return d; + return d } @@ -911,9 +911,9 @@ func hexvalue(ch byte) uint { // func NatFromString(s string, base uint) (Natural, uint, int) { // determine base if necessary - i, n := 0, len(s); + i, n := 0, len(s) if base == 0 { - base = 10; + base = 10 if n > 0 && s[0] == '0' { if n > 1 && (s[1] == 'x' || s[1] == 'X') { base, i = 16, 2 @@ -924,10 +924,10 @@ func NatFromString(s string, base uint) (Natural, uint, int) { } // convert string - assert(2 <= base && base <= 16); - x := Nat(0); + assert(2 <= base && base <= 16) + x := Nat(0) for ; i < n; i++ { - d := hexvalue(s[i]); + d := hexvalue(s[i]) if d < base { x = muladd1(x, digit(base), digit(d)) } else { @@ -935,46 +935,46 @@ func NatFromString(s string, base uint) (Natural, uint, int) { } } - return x, base, i; + return x, base, i } // Natural number functions func pop1(x digit) uint { - n := uint(0); + n := uint(0) for x != 0 { - x &= x - 1; - n++; + x &= x - 1 + n++ } - return n; + return n } // Pop computes the ``population count'' of (the number of 1 bits in) x. // func (x Natural) Pop() uint { - n := uint(0); + n := uint(0) for i := len(x) - 1; i >= 0; i-- { n += pop1(x[i]) } - return n; + return n } // Pow computes x to the power of n. // func (xp Natural) Pow(n uint) Natural { - z := Nat(1); - x := xp; + z := Nat(1) + x := xp for n > 0 { // z * x^n == x^n0 if n&1 == 1 { z = z.Mul(x) } - x, n = x.Mul(x), n/2; + x, n = x.Mul(x), n/2 } - return z; + return z } @@ -990,9 +990,9 @@ func MulRange(a, b uint) Natural { case a+1 == b: return Nat(uint64(a)).Mul(Nat(uint64(b))) } - m := (a + b) >> 1; - assert(a <= m && m < b); - return MulRange(a, m).Mul(MulRange(m+1, b)); + m := (a + b) >> 1 + assert(a <= m && m < b) + return MulRange(a, m).Mul(MulRange(m+1, b)) } @@ -1007,16 +1007,16 @@ func Fact(n uint) Natural { // Binomial computes the binomial coefficient of (n, k). // -func Binomial(n, k uint) Natural { return MulRange(n-k+1, n).Div(MulRange(1, k)) } +func Binomial(n, k uint) Natural { return MulRange(n-k+1, n).Div(MulRange(1, k)) } // Gcd computes the gcd of x and y. // func (x Natural) Gcd(y Natural) Natural { // Euclidean algorithm. - a, b := x, y; + a, b := x, y for !b.IsZero() { a, b = b, a.Mod(b) } - return a; + return a } diff --git a/src/pkg/bignum/bignum_test.go b/src/pkg/bignum/bignum_test.go index 73edc9345..532fc9740 100644 --- a/src/pkg/bignum/bignum_test.go +++ b/src/pkg/bignum/bignum_test.go @@ -5,62 +5,62 @@ package bignum import ( - "fmt"; - "testing"; + "fmt" + "testing" ) const ( - sa = "991"; - sb = "2432902008176640000"; // 20! - sc = "933262154439441526816992388562667004907159682643816214685929" + + sa = "991" + sb = "2432902008176640000" // 20! + sc = "933262154439441526816992388562667004907159682643816214685929" + "638952175999932299156089414639761565182862536979208272237582" + - "51185210916864000000000000000000000000"; // 100! - sp = "170141183460469231731687303715884105727"; // prime + "51185210916864000000000000000000000000" // 100! + sp = "170141183460469231731687303715884105727" // prime ) func natFromString(s string, base uint, slen *int) Natural { - x, _, len := NatFromString(s, base); + x, _, len := NatFromString(s, base) if slen != nil { *slen = len } - return x; + return x } func intFromString(s string, base uint, slen *int) *Integer { - x, _, len := IntFromString(s, base); + x, _, len := IntFromString(s, base) if slen != nil { *slen = len } - return x; + return x } func ratFromString(s string, base uint, slen *int) *Rational { - x, _, len := RatFromString(s, base); + x, _, len := RatFromString(s, base) if slen != nil { *slen = len } - return x; + return x } var ( - nat_zero = Nat(0); - nat_one = Nat(1); - nat_two = Nat(2); - a = natFromString(sa, 10, nil); - b = natFromString(sb, 10, nil); - c = natFromString(sc, 10, nil); - p = natFromString(sp, 10, nil); - int_zero = Int(0); - int_one = Int(1); - int_two = Int(2); - ip = intFromString(sp, 10, nil); - rat_zero = Rat(0, 1); - rat_half = Rat(1, 2); - rat_one = Rat(1, 1); - rat_two = Rat(2, 1); + nat_zero = Nat(0) + nat_one = Nat(1) + nat_two = Nat(2) + a = natFromString(sa, 10, nil) + b = natFromString(sb, 10, nil) + c = natFromString(sc, 10, nil) + p = natFromString(sp, 10, nil) + int_zero = Int(0) + int_one = Int(1) + int_two = Int(2) + ip = intFromString(sp, 10, nil) + rat_zero = Rat(0, 1) + rat_half = Rat(1, 2) + rat_one = Rat(1, 1) + rat_two = Rat(2, 1) ) @@ -96,11 +96,11 @@ func rat_eq(n uint, x, y *Rational) { func TestNatConv(t *testing.T) { - tester = t; - test_msg = "NatConvA"; + tester = t + test_msg = "NatConvA" type entry1 struct { - x uint64; - s string; + x uint64 + s string } tab := []entry1{ entry1{0, "0"}, @@ -108,51 +108,51 @@ func TestNatConv(t *testing.T) { entry1{65535, "65535"}, entry1{4294967295, "4294967295"}, entry1{18446744073709551615, "18446744073709551615"}, - }; + } for i, e := range tab { - test(100+uint(i), Nat(e.x).String() == e.s); - test(200+uint(i), natFromString(e.s, 0, nil).Value() == e.x); + test(100+uint(i), Nat(e.x).String() == e.s) + test(200+uint(i), natFromString(e.s, 0, nil).Value() == e.x) } - test_msg = "NatConvB"; + test_msg = "NatConvB" for i := uint(0); i < 100; i++ { test(i, Nat(uint64(i)).String() == fmt.Sprintf("%d", i)) } - test_msg = "NatConvC"; - z := uint64(7); + test_msg = "NatConvC" + z := uint64(7) for i := uint(0); i <= 64; i++ { - test(i, Nat(z).Value() == z); - z <<= 1; - } - - test_msg = "NatConvD"; - nat_eq(0, a, Nat(991)); - nat_eq(1, b, Fact(20)); - nat_eq(2, c, Fact(100)); - test(3, a.String() == sa); - test(4, b.String() == sb); - test(5, c.String() == sc); - - test_msg = "NatConvE"; - var slen int; - nat_eq(10, natFromString("0", 0, nil), nat_zero); - nat_eq(11, natFromString("123", 0, nil), Nat(123)); - nat_eq(12, natFromString("077", 0, nil), Nat(7*8+7)); - nat_eq(13, natFromString("0x1f", 0, nil), Nat(1*16+15)); - nat_eq(14, natFromString("0x1fg", 0, &slen), Nat(1*16+15)); - test(4, slen == 4); - - test_msg = "NatConvF"; - tmp := c.Mul(c); + test(i, Nat(z).Value() == z) + z <<= 1 + } + + test_msg = "NatConvD" + nat_eq(0, a, Nat(991)) + nat_eq(1, b, Fact(20)) + nat_eq(2, c, Fact(100)) + test(3, a.String() == sa) + test(4, b.String() == sb) + test(5, c.String() == sc) + + test_msg = "NatConvE" + var slen int + nat_eq(10, natFromString("0", 0, nil), nat_zero) + nat_eq(11, natFromString("123", 0, nil), Nat(123)) + nat_eq(12, natFromString("077", 0, nil), Nat(7*8+7)) + nat_eq(13, natFromString("0x1f", 0, nil), Nat(1*16+15)) + nat_eq(14, natFromString("0x1fg", 0, &slen), Nat(1*16+15)) + test(4, slen == 4) + + test_msg = "NatConvF" + tmp := c.Mul(c) for base := uint(2); base <= 16; base++ { nat_eq(base, natFromString(tmp.ToString(base), base, nil), tmp) } - test_msg = "NatConvG"; - x := Nat(100); - y, _, _ := NatFromString(fmt.Sprintf("%b", &x), 2); - nat_eq(100, y, x); + test_msg = "NatConvG" + x := Nat(100) + y, _, _ := NatFromString(fmt.Sprintf("%b", &x), 2) + nat_eq(100, y, x) } @@ -160,16 +160,16 @@ func abs(x int64) uint64 { if x < 0 { x = -x } - return uint64(x); + return uint64(x) } func TestIntConv(t *testing.T) { - tester = t; - test_msg = "IntConvA"; + tester = t + test_msg = "IntConvA" type entry2 struct { - x int64; - s string; + x int64 + s string } tab := []entry2{ entry2{0, "0"}, @@ -181,92 +181,92 @@ func TestIntConv(t *testing.T) { entry2{2147483647, "2147483647"}, entry2{-9223372036854775808, "-9223372036854775808"}, entry2{9223372036854775807, "9223372036854775807"}, - }; + } for i, e := range tab { - test(100+uint(i), Int(e.x).String() == e.s); - test(200+uint(i), intFromString(e.s, 0, nil).Value() == e.x); - test(300+uint(i), Int(e.x).Abs().Value() == abs(e.x)); - } - - test_msg = "IntConvB"; - var slen int; - int_eq(0, intFromString("0", 0, nil), int_zero); - int_eq(1, intFromString("-0", 0, nil), int_zero); - int_eq(2, intFromString("123", 0, nil), Int(123)); - int_eq(3, intFromString("-123", 0, nil), Int(-123)); - int_eq(4, intFromString("077", 0, nil), Int(7*8+7)); - int_eq(5, intFromString("-077", 0, nil), Int(-(7*8 + 7))); - int_eq(6, intFromString("0x1f", 0, nil), Int(1*16+15)); - int_eq(7, intFromString("-0x1f", 0, &slen), Int(-(1*16 + 15))); - test(7, slen == 5); - int_eq(8, intFromString("+0x1f", 0, &slen), Int(+(1*16 + 15))); - test(8, slen == 5); - int_eq(9, intFromString("0x1fg", 0, &slen), Int(1*16+15)); - test(9, slen == 4); - int_eq(10, intFromString("-0x1fg", 0, &slen), Int(-(1*16 + 15))); - test(10, slen == 5); + test(100+uint(i), Int(e.x).String() == e.s) + test(200+uint(i), intFromString(e.s, 0, nil).Value() == e.x) + test(300+uint(i), Int(e.x).Abs().Value() == abs(e.x)) + } + + test_msg = "IntConvB" + var slen int + int_eq(0, intFromString("0", 0, nil), int_zero) + int_eq(1, intFromString("-0", 0, nil), int_zero) + int_eq(2, intFromString("123", 0, nil), Int(123)) + int_eq(3, intFromString("-123", 0, nil), Int(-123)) + int_eq(4, intFromString("077", 0, nil), Int(7*8+7)) + int_eq(5, intFromString("-077", 0, nil), Int(-(7*8 + 7))) + int_eq(6, intFromString("0x1f", 0, nil), Int(1*16+15)) + int_eq(7, intFromString("-0x1f", 0, &slen), Int(-(1*16 + 15))) + test(7, slen == 5) + int_eq(8, intFromString("+0x1f", 0, &slen), Int(+(1*16 + 15))) + test(8, slen == 5) + int_eq(9, intFromString("0x1fg", 0, &slen), Int(1*16+15)) + test(9, slen == 4) + int_eq(10, intFromString("-0x1fg", 0, &slen), Int(-(1*16 + 15))) + test(10, slen == 5) } func TestRatConv(t *testing.T) { - tester = t; - test_msg = "RatConv"; - var slen int; - rat_eq(0, ratFromString("0", 0, nil), rat_zero); - rat_eq(1, ratFromString("0/1", 0, nil), rat_zero); - rat_eq(2, ratFromString("0/01", 0, nil), rat_zero); - rat_eq(3, ratFromString("0x14/10", 0, &slen), rat_two); - test(4, slen == 7); - rat_eq(5, ratFromString("0.", 0, nil), rat_zero); - rat_eq(6, ratFromString("0.001f", 10, nil), Rat(1, 1000)); - rat_eq(7, ratFromString(".1", 0, nil), Rat(1, 10)); - rat_eq(8, ratFromString("10101.0101", 2, nil), Rat(0x155, 1<<4)); - rat_eq(9, ratFromString("-0003.145926", 10, &slen), Rat(-3145926, 1000000)); - test(10, slen == 12); - rat_eq(11, ratFromString("1e2", 0, nil), Rat(100, 1)); - rat_eq(12, ratFromString("1e-2", 0, nil), Rat(1, 100)); - rat_eq(13, ratFromString("1.1e2", 0, nil), Rat(110, 1)); - rat_eq(14, ratFromString(".1e2x", 0, &slen), Rat(10, 1)); - test(15, slen == 4); + tester = t + test_msg = "RatConv" + var slen int + rat_eq(0, ratFromString("0", 0, nil), rat_zero) + rat_eq(1, ratFromString("0/1", 0, nil), rat_zero) + rat_eq(2, ratFromString("0/01", 0, nil), rat_zero) + rat_eq(3, ratFromString("0x14/10", 0, &slen), rat_two) + test(4, slen == 7) + rat_eq(5, ratFromString("0.", 0, nil), rat_zero) + rat_eq(6, ratFromString("0.001f", 10, nil), Rat(1, 1000)) + rat_eq(7, ratFromString(".1", 0, nil), Rat(1, 10)) + rat_eq(8, ratFromString("10101.0101", 2, nil), Rat(0x155, 1<<4)) + rat_eq(9, ratFromString("-0003.145926", 10, &slen), Rat(-3145926, 1000000)) + test(10, slen == 12) + rat_eq(11, ratFromString("1e2", 0, nil), Rat(100, 1)) + rat_eq(12, ratFromString("1e-2", 0, nil), Rat(1, 100)) + rat_eq(13, ratFromString("1.1e2", 0, nil), Rat(110, 1)) + rat_eq(14, ratFromString(".1e2x", 0, &slen), Rat(10, 1)) + test(15, slen == 4) } func add(x, y Natural) Natural { - z1 := x.Add(y); - z2 := y.Add(x); + z1 := x.Add(y) + z2 := y.Add(x) if z1.Cmp(z2) != 0 { tester.Fatalf("addition not symmetric:\n\tx = %v\n\ty = %t", x, y) } - return z1; + return z1 } func sum(n uint64, scale Natural) Natural { - s := nat_zero; + s := nat_zero for ; n > 0; n-- { s = add(s, Nat(n).Mul(scale)) } - return s; + return s } func TestNatAdd(t *testing.T) { - tester = t; - test_msg = "NatAddA"; - nat_eq(0, add(nat_zero, nat_zero), nat_zero); - nat_eq(1, add(nat_zero, c), c); + tester = t + test_msg = "NatAddA" + nat_eq(0, add(nat_zero, nat_zero), nat_zero) + nat_eq(1, add(nat_zero, c), c) - test_msg = "NatAddB"; + test_msg = "NatAddB" for i := uint64(0); i < 100; i++ { - t := Nat(i); - nat_eq(uint(i), sum(i, c), t.Mul(t).Add(t).Shr(1).Mul(c)); + t := Nat(i) + nat_eq(uint(i), sum(i, c), t.Mul(t).Add(t).Shr(1).Mul(c)) } } func mul(x, y Natural) Natural { - z1 := x.Mul(y); - z2 := y.Mul(x); + z1 := x.Mul(y) + z2 := y.Mul(x) if z1.Cmp(z2) != 0 { tester.Fatalf("multiplication not symmetric:\n\tx = %v\n\ty = %t", x, y) } @@ -276,40 +276,40 @@ func mul(x, y Natural) Natural { if !y.IsZero() && z1.Div(y).Cmp(x) != 0 { tester.Fatalf("multiplication/division not inverse (B):\n\tx = %v\n\ty = %t", x, y) } - return z1; + return z1 } func TestNatSub(t *testing.T) { - tester = t; - test_msg = "NatSubA"; - nat_eq(0, nat_zero.Sub(nat_zero), nat_zero); - nat_eq(1, c.Sub(nat_zero), c); + tester = t + test_msg = "NatSubA" + nat_eq(0, nat_zero.Sub(nat_zero), nat_zero) + nat_eq(1, c.Sub(nat_zero), c) - test_msg = "NatSubB"; + test_msg = "NatSubB" for i := uint64(0); i < 100; i++ { - t := sum(i, c); + t := sum(i, c) for j := uint64(0); j <= i; j++ { t = t.Sub(mul(Nat(j), c)) } - nat_eq(uint(i), t, nat_zero); + nat_eq(uint(i), t, nat_zero) } } func TestNatMul(t *testing.T) { - tester = t; - test_msg = "NatMulA"; - nat_eq(0, mul(c, nat_zero), nat_zero); - nat_eq(1, mul(c, nat_one), c); - - test_msg = "NatMulB"; - nat_eq(0, b.Mul(MulRange(0, 100)), nat_zero); - nat_eq(1, b.Mul(MulRange(21, 100)), c); - - test_msg = "NatMulC"; - const n = 100; - p := b.Mul(c).Shl(n); + tester = t + test_msg = "NatMulA" + nat_eq(0, mul(c, nat_zero), nat_zero) + nat_eq(1, mul(c, nat_one), c) + + test_msg = "NatMulB" + nat_eq(0, b.Mul(MulRange(0, 100)), nat_zero) + nat_eq(1, b.Mul(MulRange(21, 100)), c) + + test_msg = "NatMulC" + const n = 100 + p := b.Mul(c).Shl(n) for i := uint(0); i < n; i++ { nat_eq(i, mul(b.Shl(i), c.Shl(n-i)), p) } @@ -317,17 +317,17 @@ func TestNatMul(t *testing.T) { func TestNatDiv(t *testing.T) { - tester = t; - test_msg = "NatDivA"; - nat_eq(0, c.Div(nat_one), c); - nat_eq(1, c.Div(Nat(100)), Fact(99)); - nat_eq(2, b.Div(c), nat_zero); - nat_eq(4, nat_one.Shl(100).Div(nat_one.Shl(90)), nat_one.Shl(10)); - nat_eq(5, c.Div(b), MulRange(21, 100)); - - test_msg = "NatDivB"; - const n = 100; - p := Fact(n); + tester = t + test_msg = "NatDivA" + nat_eq(0, c.Div(nat_one), c) + nat_eq(1, c.Div(Nat(100)), Fact(99)) + nat_eq(2, b.Div(c), nat_zero) + nat_eq(4, nat_one.Shl(100).Div(nat_one.Shl(90)), nat_one.Shl(10)) + nat_eq(5, c.Div(b), MulRange(21, 100)) + + test_msg = "NatDivB" + const n = 100 + p := Fact(n) for i := uint(0); i < n; i++ { nat_eq(100+i, p.Div(MulRange(1, i)), MulRange(i+1, n)) } @@ -335,10 +335,10 @@ func TestNatDiv(t *testing.T) { func TestIntQuoRem(t *testing.T) { - tester = t; - test_msg = "IntQuoRem"; + tester = t + test_msg = "IntQuoRem" type T struct { - x, y, q, r int64; + x, y, q, r int64 } a := []T{ T{+8, +3, +2, +2}, @@ -349,25 +349,25 @@ func TestIntQuoRem(t *testing.T) { T{+1, -2, 0, +1}, T{-1, +2, 0, -1}, T{-1, -2, 0, -1}, - }; + } for i := uint(0); i < uint(len(a)); i++ { - e := &a[i]; - x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip); - q, r := Int(e.q), Int(e.r).Mul(ip); - qq, rr := x.QuoRem(y); - int_eq(4*i+0, x.Quo(y), q); - int_eq(4*i+1, x.Rem(y), r); - int_eq(4*i+2, qq, q); - int_eq(4*i+3, rr, r); + e := &a[i] + x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip) + q, r := Int(e.q), Int(e.r).Mul(ip) + qq, rr := x.QuoRem(y) + int_eq(4*i+0, x.Quo(y), q) + int_eq(4*i+1, x.Rem(y), r) + int_eq(4*i+2, qq, q) + int_eq(4*i+3, rr, r) } } func TestIntDivMod(t *testing.T) { - tester = t; - test_msg = "IntDivMod"; + tester = t + test_msg = "IntDivMod" type T struct { - x, y, q, r int64; + x, y, q, r int64 } a := []T{ T{+8, +3, +2, +2}, @@ -378,144 +378,144 @@ func TestIntDivMod(t *testing.T) { T{+1, -2, 0, +1}, T{-1, +2, -1, +1}, T{-1, -2, +1, +1}, - }; + } for i := uint(0); i < uint(len(a)); i++ { - e := &a[i]; - x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip); - q, r := Int(e.q), Int(e.r).Mul(ip); - qq, rr := x.DivMod(y); - int_eq(4*i+0, x.Div(y), q); - int_eq(4*i+1, x.Mod(y), r); - int_eq(4*i+2, qq, q); - int_eq(4*i+3, rr, r); + e := &a[i] + x, y := Int(e.x).Mul(ip), Int(e.y).Mul(ip) + q, r := Int(e.q), Int(e.r).Mul(ip) + qq, rr := x.DivMod(y) + int_eq(4*i+0, x.Div(y), q) + int_eq(4*i+1, x.Mod(y), r) + int_eq(4*i+2, qq, q) + int_eq(4*i+3, rr, r) } } func TestNatMod(t *testing.T) { - tester = t; - test_msg = "NatModA"; + tester = t + test_msg = "NatModA" for i := uint(0); ; i++ { - d := nat_one.Shl(i); + d := nat_one.Shl(i) if d.Cmp(c) < 0 { nat_eq(i, c.Add(d).Mod(c), d) } else { - nat_eq(i, c.Add(d).Div(c), nat_two); - nat_eq(i, c.Add(d).Mod(c), d.Sub(c)); - break; + nat_eq(i, c.Add(d).Div(c), nat_two) + nat_eq(i, c.Add(d).Mod(c), d.Sub(c)) + break } } } func TestNatShift(t *testing.T) { - tester = t; - test_msg = "NatShift1L"; - test(0, b.Shl(0).Cmp(b) == 0); - test(1, c.Shl(1).Cmp(c) > 0); + tester = t + test_msg = "NatShift1L" + test(0, b.Shl(0).Cmp(b) == 0) + test(1, c.Shl(1).Cmp(c) > 0) - test_msg = "NatShift1R"; - test(3, b.Shr(0).Cmp(b) == 0); - test(4, c.Shr(1).Cmp(c) < 0); + test_msg = "NatShift1R" + test(3, b.Shr(0).Cmp(b) == 0) + test(4, c.Shr(1).Cmp(c) < 0) - test_msg = "NatShift2"; + test_msg = "NatShift2" for i := uint(0); i < 100; i++ { test(i, c.Shl(i).Shr(i).Cmp(c) == 0) } - test_msg = "NatShift3L"; + test_msg = "NatShift3L" { - const m = 3; - p := b; - f := Nat(1 << m); + const m = 3 + p := b + f := Nat(1 << m) for i := uint(0); i < 100; i++ { - nat_eq(i, b.Shl(i*m), p); - p = mul(p, f); + nat_eq(i, b.Shl(i*m), p) + p = mul(p, f) } } - test_msg = "NatShift3R"; + test_msg = "NatShift3R" { - p := c; + p := c for i := uint(0); !p.IsZero(); i++ { - nat_eq(i, c.Shr(i), p); - p = p.Shr(1); + nat_eq(i, c.Shr(i), p) + p = p.Shr(1) } } } func TestIntShift(t *testing.T) { - tester = t; - test_msg = "IntShift1L"; - test(0, ip.Shl(0).Cmp(ip) == 0); - test(1, ip.Shl(1).Cmp(ip) > 0); + tester = t + test_msg = "IntShift1L" + test(0, ip.Shl(0).Cmp(ip) == 0) + test(1, ip.Shl(1).Cmp(ip) > 0) - test_msg = "IntShift1R"; - test(0, ip.Shr(0).Cmp(ip) == 0); - test(1, ip.Shr(1).Cmp(ip) < 0); + test_msg = "IntShift1R" + test(0, ip.Shr(0).Cmp(ip) == 0) + test(1, ip.Shr(1).Cmp(ip) < 0) - test_msg = "IntShift2"; + test_msg = "IntShift2" for i := uint(0); i < 100; i++ { test(i, ip.Shl(i).Shr(i).Cmp(ip) == 0) } - test_msg = "IntShift3L"; + test_msg = "IntShift3L" { - const m = 3; - p := ip; - f := Int(1 << m); + const m = 3 + p := ip + f := Int(1 << m) for i := uint(0); i < 100; i++ { - int_eq(i, ip.Shl(i*m), p); - p = p.Mul(f); + int_eq(i, ip.Shl(i*m), p) + p = p.Mul(f) } } - test_msg = "IntShift3R"; + test_msg = "IntShift3R" { - p := ip; + p := ip for i := uint(0); p.IsPos(); i++ { - int_eq(i, ip.Shr(i), p); - p = p.Shr(1); + int_eq(i, ip.Shr(i), p) + p = p.Shr(1) } } - test_msg = "IntShift4R"; - int_eq(0, Int(-43).Shr(1), Int(-43>>1)); - int_eq(0, Int(-1024).Shr(100), Int(-1)); - int_eq(1, ip.Neg().Shr(10), ip.Neg().Div(Int(1).Shl(10))); + test_msg = "IntShift4R" + int_eq(0, Int(-43).Shr(1), Int(-43>>1)) + int_eq(0, Int(-1024).Shr(100), Int(-1)) + int_eq(1, ip.Neg().Shr(10), ip.Neg().Div(Int(1).Shl(10))) } func TestNatBitOps(t *testing.T) { - tester = t; + tester = t - x := uint64(0xf08e6f56bd8c3941); - y := uint64(0x3984ef67834bc); + x := uint64(0xf08e6f56bd8c3941) + y := uint64(0x3984ef67834bc) - bx := Nat(x); - by := Nat(y); + bx := Nat(x) + by := Nat(y) - test_msg = "NatAnd"; - bz := Nat(x & y); + test_msg = "NatAnd" + bz := Nat(x & y) for i := uint(0); i < 100; i++ { nat_eq(i, bx.Shl(i).And(by.Shl(i)), bz.Shl(i)) } - test_msg = "NatAndNot"; - bz = Nat(x &^ y); + test_msg = "NatAndNot" + bz = Nat(x &^ y) for i := uint(0); i < 100; i++ { nat_eq(i, bx.Shl(i).AndNot(by.Shl(i)), bz.Shl(i)) } - test_msg = "NatOr"; - bz = Nat(x | y); + test_msg = "NatOr" + bz = Nat(x | y) for i := uint(0); i < 100; i++ { nat_eq(i, bx.Shl(i).Or(by.Shl(i)), bz.Shl(i)) } - test_msg = "NatXor"; - bz = Nat(x ^ y); + test_msg = "NatXor" + bz = Nat(x ^ y) for i := uint(0); i < 100; i++ { nat_eq(i, bx.Shl(i).Xor(by.Shl(i)), bz.Shl(i)) } @@ -523,77 +523,77 @@ func TestNatBitOps(t *testing.T) { func TestIntBitOps1(t *testing.T) { - tester = t; - test_msg = "IntBitOps1"; + tester = t + test_msg = "IntBitOps1" type T struct { - x, y int64; + x, y int64 } a := []T{ T{+7, +3}, T{+7, -3}, T{-7, +3}, T{-7, -3}, - }; + } for i := uint(0); i < uint(len(a)); i++ { - e := &a[i]; - int_eq(4*i+0, Int(e.x).And(Int(e.y)), Int(e.x&e.y)); - int_eq(4*i+1, Int(e.x).AndNot(Int(e.y)), Int(e.x&^e.y)); - int_eq(4*i+2, Int(e.x).Or(Int(e.y)), Int(e.x|e.y)); - int_eq(4*i+3, Int(e.x).Xor(Int(e.y)), Int(e.x^e.y)); + e := &a[i] + int_eq(4*i+0, Int(e.x).And(Int(e.y)), Int(e.x&e.y)) + int_eq(4*i+1, Int(e.x).AndNot(Int(e.y)), Int(e.x&^e.y)) + int_eq(4*i+2, Int(e.x).Or(Int(e.y)), Int(e.x|e.y)) + int_eq(4*i+3, Int(e.x).Xor(Int(e.y)), Int(e.x^e.y)) } } func TestIntBitOps2(t *testing.T) { - tester = t; + tester = t - test_msg = "IntNot"; - int_eq(0, Int(-2).Not(), Int(1)); - int_eq(0, Int(-1).Not(), Int(0)); - int_eq(0, Int(0).Not(), Int(-1)); - int_eq(0, Int(1).Not(), Int(-2)); - int_eq(0, Int(2).Not(), Int(-3)); + test_msg = "IntNot" + int_eq(0, Int(-2).Not(), Int(1)) + int_eq(0, Int(-1).Not(), Int(0)) + int_eq(0, Int(0).Not(), Int(-1)) + int_eq(0, Int(1).Not(), Int(-2)) + int_eq(0, Int(2).Not(), Int(-3)) - test_msg = "IntAnd"; + test_msg = "IntAnd" for x := int64(-15); x < 5; x++ { - bx := Int(x); + bx := Int(x) for y := int64(-5); y < 15; y++ { - by := Int(y); - for i := uint(50); i < 70; i++ { // shift across 64bit boundary + by := Int(y) + for i := uint(50); i < 70; i++ { // shift across 64bit boundary int_eq(i, bx.Shl(i).And(by.Shl(i)), Int(x&y).Shl(i)) } } } - test_msg = "IntAndNot"; + test_msg = "IntAndNot" for x := int64(-15); x < 5; x++ { - bx := Int(x); + bx := Int(x) for y := int64(-5); y < 15; y++ { - by := Int(y); - for i := uint(50); i < 70; i++ { // shift across 64bit boundary - int_eq(2*i+0, bx.Shl(i).AndNot(by.Shl(i)), Int(x&^y).Shl(i)); - int_eq(2*i+1, bx.Shl(i).And(by.Shl(i).Not()), Int(x&^y).Shl(i)); + by := Int(y) + for i := uint(50); i < 70; i++ { // shift across 64bit boundary + int_eq(2*i+0, bx.Shl(i).AndNot(by.Shl(i)), Int(x&^y).Shl(i)) + int_eq(2*i+1, bx.Shl(i).And(by.Shl(i).Not()), Int(x&^y).Shl(i)) } } } - test_msg = "IntOr"; + test_msg = "IntOr" for x := int64(-15); x < 5; x++ { - bx := Int(x); + bx := Int(x) for y := int64(-5); y < 15; y++ { - by := Int(y); - for i := uint(50); i < 70; i++ { // shift across 64bit boundary + by := Int(y) + for i := uint(50); i < 70; i++ { // shift across 64bit boundary int_eq(i, bx.Shl(i).Or(by.Shl(i)), Int(x|y).Shl(i)) } } } - test_msg = "IntXor"; + test_msg = "IntXor" for x := int64(-15); x < 5; x++ { - bx := Int(x); + bx := Int(x) for y := int64(-5); y < 15; y++ { - by := Int(y); - for i := uint(50); i < 70; i++ { // shift across 64bit boundary + by := Int(y) + for i := uint(50); i < 70; i++ { // shift across 64bit boundary int_eq(i, bx.Shl(i).Xor(by.Shl(i)), Int(x^y).Shl(i)) } } @@ -602,27 +602,27 @@ func TestIntBitOps2(t *testing.T) { func TestNatCmp(t *testing.T) { - tester = t; - test_msg = "NatCmp"; - test(0, a.Cmp(a) == 0); - test(1, a.Cmp(b) < 0); - test(2, b.Cmp(a) > 0); - test(3, a.Cmp(c) < 0); - d := c.Add(b); - test(4, c.Cmp(d) < 0); - test(5, d.Cmp(c) > 0); + tester = t + test_msg = "NatCmp" + test(0, a.Cmp(a) == 0) + test(1, a.Cmp(b) < 0) + test(2, b.Cmp(a) > 0) + test(3, a.Cmp(c) < 0) + d := c.Add(b) + test(4, c.Cmp(d) < 0) + test(5, d.Cmp(c) > 0) } func TestNatLog2(t *testing.T) { - tester = t; - test_msg = "NatLog2A"; - test(0, nat_one.Log2() == 0); - test(1, nat_two.Log2() == 1); - test(2, Nat(3).Log2() == 1); - test(3, Nat(4).Log2() == 2); - - test_msg = "NatLog2B"; + tester = t + test_msg = "NatLog2A" + test(0, nat_one.Log2() == 0) + test(1, nat_two.Log2() == 1) + test(2, Nat(3).Log2() == 1) + test(3, Nat(4).Log2() == 2) + + test_msg = "NatLog2B" for i := uint(0); i < 100; i++ { test(i, nat_one.Shl(i).Log2() == i) } @@ -630,19 +630,19 @@ func TestNatLog2(t *testing.T) { func TestNatGcd(t *testing.T) { - tester = t; - test_msg = "NatGcdA"; - f := Nat(99991); - nat_eq(0, b.Mul(f).Gcd(c.Mul(f)), MulRange(1, 20).Mul(f)); + tester = t + test_msg = "NatGcdA" + f := Nat(99991) + nat_eq(0, b.Mul(f).Gcd(c.Mul(f)), MulRange(1, 20).Mul(f)) } func TestNatPow(t *testing.T) { - tester = t; - test_msg = "NatPowA"; - nat_eq(0, nat_two.Pow(0), nat_one); + tester = t + test_msg = "NatPowA" + nat_eq(0, nat_two.Pow(0), nat_one) - test_msg = "NatPowB"; + test_msg = "NatPowB" for i := uint(0); i < 100; i++ { nat_eq(i, nat_two.Pow(i), nat_one.Shl(i)) } @@ -650,15 +650,15 @@ func TestNatPow(t *testing.T) { func TestNatPop(t *testing.T) { - tester = t; - test_msg = "NatPopA"; - test(0, nat_zero.Pop() == 0); - test(1, nat_one.Pop() == 1); - test(2, Nat(10).Pop() == 2); - test(3, Nat(30).Pop() == 4); - test(4, Nat(0x1248f).Shl(33).Pop() == 8); - - test_msg = "NatPopB"; + tester = t + test_msg = "NatPopA" + test(0, nat_zero.Pop() == 0) + test(1, nat_one.Pop() == 1) + test(2, Nat(10).Pop() == 2) + test(3, Nat(30).Pop() == 4) + test(4, Nat(0x1248f).Shl(33).Pop() == 8) + + test_msg = "NatPopB" for i := uint(0); i < 100; i++ { test(i, nat_one.Shl(i).Sub(nat_one).Pop() == i) } diff --git a/src/pkg/bignum/integer.go b/src/pkg/bignum/integer.go index 3d382473e..873b2664a 100644 --- a/src/pkg/bignum/integer.go +++ b/src/pkg/bignum/integer.go @@ -10,7 +10,7 @@ package bignum import ( - "fmt"; + "fmt" ) // TODO(gri) Complete the set of in-place operations. @@ -18,8 +18,8 @@ import ( // Integer represents a signed integer value of arbitrary precision. // type Integer struct { - sign bool; - mant Natural; + sign bool + mant Natural } @@ -29,16 +29,16 @@ type Integer struct { // func MakeInt(sign bool, mant Natural) *Integer { if mant.IsZero() { - sign = false // normalize + sign = false // normalize } - return &Integer{sign, mant}; + return &Integer{sign, mant} } // Int creates a small integer with value x. // func Int(x int64) *Integer { - var ux uint64; + var ux uint64 if x < 0 { // For the most negative x, -x == x, and // the bit pattern has the correct value. @@ -46,7 +46,7 @@ func Int(x int64) *Integer { } else { ux = uint64(x) } - return MakeInt(x < 0, Nat(ux)); + return MakeInt(x < 0, Nat(ux)) } @@ -54,51 +54,51 @@ func Int(x int64) *Integer { // otherwise the result is undefined. // func (x *Integer) Value() int64 { - z := int64(x.mant.Value()); + z := int64(x.mant.Value()) if x.sign { z = -z } - return z; + return z } // Abs returns the absolute value of x. // -func (x *Integer) Abs() Natural { return x.mant } +func (x *Integer) Abs() Natural { return x.mant } // Predicates // IsEven returns true iff x is divisible by 2. // -func (x *Integer) IsEven() bool { return x.mant.IsEven() } +func (x *Integer) IsEven() bool { return x.mant.IsEven() } // IsOdd returns true iff x is not divisible by 2. // -func (x *Integer) IsOdd() bool { return x.mant.IsOdd() } +func (x *Integer) IsOdd() bool { return x.mant.IsOdd() } // IsZero returns true iff x == 0. // -func (x *Integer) IsZero() bool { return x.mant.IsZero() } +func (x *Integer) IsZero() bool { return x.mant.IsZero() } // IsNeg returns true iff x < 0. // -func (x *Integer) IsNeg() bool { return x.sign && !x.mant.IsZero() } +func (x *Integer) IsNeg() bool { return x.sign && !x.mant.IsZero() } // IsPos returns true iff x >= 0. // -func (x *Integer) IsPos() bool { return !x.sign && !x.mant.IsZero() } +func (x *Integer) IsPos() bool { return !x.sign && !x.mant.IsZero() } // Operations // Neg returns the negated value of x. // -func (x *Integer) Neg() *Integer { return MakeInt(!x.sign, x.mant) } +func (x *Integer) Neg() *Integer { return MakeInt(!x.sign, x.mant) } // Iadd sets z to the sum x + y. @@ -108,17 +108,17 @@ func Iadd(z, x, y *Integer) { if x.sign == y.sign { // x + y == x + y // (-x) + (-y) == -(x + y) - z.sign = x.sign; - Nadd(&z.mant, x.mant, y.mant); + z.sign = x.sign + Nadd(&z.mant, x.mant, y.mant) } else { // x + (-y) == x - y == -(y - x) // (-x) + y == y - x == -(x - y) if x.mant.Cmp(y.mant) >= 0 { - z.sign = x.sign; - Nsub(&z.mant, x.mant, y.mant); + z.sign = x.sign + Nsub(&z.mant, x.mant, y.mant) } else { - z.sign = !x.sign; - Nsub(&z.mant, y.mant, x.mant); + z.sign = !x.sign + Nsub(&z.mant, y.mant, x.mant) } } } @@ -127,9 +127,9 @@ func Iadd(z, x, y *Integer) { // Add returns the sum x + y. // func (x *Integer) Add(y *Integer) *Integer { - var z Integer; - Iadd(&z, x, y); - return &z; + var z Integer + Iadd(&z, x, y) + return &z } @@ -137,17 +137,17 @@ func Isub(z, x, y *Integer) { if x.sign != y.sign { // x - (-y) == x + y // (-x) - y == -(x + y) - z.sign = x.sign; - Nadd(&z.mant, x.mant, y.mant); + z.sign = x.sign + Nadd(&z.mant, x.mant, y.mant) } else { // x - y == x - y == -(y - x) // (-x) - (-y) == y - x == -(x - y) if x.mant.Cmp(y.mant) >= 0 { - z.sign = x.sign; - Nsub(&z.mant, x.mant, y.mant); + z.sign = x.sign + Nsub(&z.mant, x.mant, y.mant) } else { - z.sign = !x.sign; - Nsub(&z.mant, y.mant, x.mant); + z.sign = !x.sign + Nsub(&z.mant, y.mant, x.mant) } } } @@ -156,32 +156,32 @@ func Isub(z, x, y *Integer) { // Sub returns the difference x - y. // func (x *Integer) Sub(y *Integer) *Integer { - var z Integer; - Isub(&z, x, y); - return &z; + var z Integer + Isub(&z, x, y) + return &z } // Nscale sets *z to the scaled value (*z) * d. // func Iscale(z *Integer, d int64) { - f := uint64(d); + f := uint64(d) if d < 0 { f = uint64(-d) } - z.sign = z.sign != (d < 0); - Nscale(&z.mant, f); + z.sign = z.sign != (d < 0) + Nscale(&z.mant, f) } // Mul1 returns the product x * d. // func (x *Integer) Mul1(d int64) *Integer { - f := uint64(d); + f := uint64(d) if d < 0 { f = uint64(-d) } - return MakeInt(x.sign != (d < 0), x.mant.Mul1(f)); + return MakeInt(x.sign != (d < 0), x.mant.Mul1(f)) } @@ -242,8 +242,8 @@ func (x *Integer) Rem(y *Integer) *Integer { // If y == 0, a division-by-zero run-time error occurs. // func (x *Integer) QuoRem(y *Integer) (*Integer, *Integer) { - q, r := x.mant.DivMod(y.mant); - return MakeInt(x.sign != y.sign, q), MakeInt(x.sign, r); + q, r := x.mant.DivMod(y.mant) + return MakeInt(x.sign != y.sign, q), MakeInt(x.sign, r) } @@ -261,7 +261,7 @@ func (x *Integer) QuoRem(y *Integer) (*Integer, *Integer) { // ACM press.) // func (x *Integer) Div(y *Integer) *Integer { - q, r := x.QuoRem(y); + q, r := x.QuoRem(y) if r.IsNeg() { if y.IsPos() { q = q.Sub(Int(1)) @@ -269,7 +269,7 @@ func (x *Integer) Div(y *Integer) *Integer { q = q.Add(Int(1)) } } - return q; + return q } @@ -278,7 +278,7 @@ func (x *Integer) Div(y *Integer) *Integer { // If y == 0, a division-by-zero run-time error occurs. // func (x *Integer) Mod(y *Integer) *Integer { - r := x.Rem(y); + r := x.Rem(y) if r.IsNeg() { if y.IsPos() { r = r.Add(y) @@ -286,30 +286,30 @@ func (x *Integer) Mod(y *Integer) *Integer { r = r.Sub(y) } } - return r; + return r } // DivMod returns the pair (x.Div(y), x.Mod(y)). // func (x *Integer) DivMod(y *Integer) (*Integer, *Integer) { - q, r := x.QuoRem(y); + q, r := x.QuoRem(y) if r.IsNeg() { if y.IsPos() { - q = q.Sub(Int(1)); - r = r.Add(y); + q = q.Sub(Int(1)) + r = r.Add(y) } else { - q = q.Add(Int(1)); - r = r.Sub(y); + q = q.Add(Int(1)) + r = r.Sub(y) } } - return q, r; + return q, r } // Shl implements ``shift left'' x << s. It returns x * 2^s. // -func (x *Integer) Shl(s uint) *Integer { return MakeInt(x.sign, x.mant.Shl(s)) } +func (x *Integer) Shl(s uint) *Integer { return MakeInt(x.sign, x.mant.Shl(s)) } // The bitwise operations on integers are defined on the 2's-complement @@ -336,7 +336,7 @@ func (x *Integer) Shr(s uint) *Integer { return MakeInt(true, x.mant.Sub(Nat(1)).Shr(s).Add(Nat(1))) } - return MakeInt(false, x.mant.Shr(s)); + return MakeInt(false, x.mant.Shr(s)) } @@ -348,7 +348,7 @@ func (x *Integer) Not() *Integer { } // ^x == -x-1 == -(x+1) - return MakeInt(true, x.mant.Add(Nat(1))); + return MakeInt(true, x.mant.Add(Nat(1))) } @@ -362,16 +362,16 @@ func (x *Integer) And(y *Integer) *Integer { } // x & y == x & y - return MakeInt(false, x.mant.And(y.mant)); + return MakeInt(false, x.mant.And(y.mant)) } // x.sign != y.sign if x.sign { - x, y = y, x // & is symmetric + x, y = y, x // & is symmetric } // x & (-y) == x & ^(y-1) == x &^ (y-1) - return MakeInt(false, x.mant.AndNot(y.mant.Sub(Nat(1)))); + return MakeInt(false, x.mant.AndNot(y.mant.Sub(Nat(1)))) } @@ -385,7 +385,7 @@ func (x *Integer) AndNot(y *Integer) *Integer { } // x &^ y == x &^ y - return MakeInt(false, x.mant.AndNot(y.mant)); + return MakeInt(false, x.mant.AndNot(y.mant)) } if x.sign { @@ -394,7 +394,7 @@ func (x *Integer) AndNot(y *Integer) *Integer { } // x &^ (-y) == x &^ ^(y-1) == x & (y-1) - return MakeInt(false, x.mant.And(y.mant.Sub(Nat(1)))); + return MakeInt(false, x.mant.And(y.mant.Sub(Nat(1)))) } @@ -408,16 +408,16 @@ func (x *Integer) Or(y *Integer) *Integer { } // x | y == x | y - return MakeInt(false, x.mant.Or(y.mant)); + return MakeInt(false, x.mant.Or(y.mant)) } // x.sign != y.sign if x.sign { - x, y = y, x // | or symmetric + x, y = y, x // | or symmetric } // x | (-y) == x | ^(y-1) == ^((y-1) &^ x) == -(^((y-1) &^ x) + 1) - return MakeInt(true, y.mant.Sub(Nat(1)).AndNot(x.mant).Add(Nat(1))); + return MakeInt(true, y.mant.Sub(Nat(1)).AndNot(x.mant).Add(Nat(1))) } @@ -431,16 +431,16 @@ func (x *Integer) Xor(y *Integer) *Integer { } // x ^ y == x ^ y - return MakeInt(false, x.mant.Xor(y.mant)); + return MakeInt(false, x.mant.Xor(y.mant)) } // x.sign != y.sign if x.sign { - x, y = y, x // ^ is symmetric + x, y = y, x // ^ is symmetric } // x ^ (-y) == x ^ ^(y-1) == ^(x ^ (y-1)) == -((x ^ (y-1)) + 1) - return MakeInt(true, x.mant.Xor(y.mant.Sub(Nat(1))).Add(Nat(1))); + return MakeInt(true, x.mant.Xor(y.mant.Sub(Nat(1))).Add(Nat(1))) } @@ -455,10 +455,10 @@ func (x *Integer) Cmp(y *Integer) int { // x cmp (-y) == x // (-x) cmp y == y // (-x) cmp (-y) == -(x cmp y) - var r int; + var r int switch { case x.sign == y.sign: - r = x.mant.Cmp(y.mant); + r = x.mant.Cmp(y.mant) if x.sign { r = -r } @@ -467,7 +467,7 @@ func (x *Integer) Cmp(y *Integer) int { case y.sign: r = 1 } - return r; + return r } @@ -477,24 +477,24 @@ func (x *Integer) ToString(base uint) string { if x.mant.IsZero() { return "0" } - var s string; + var s string if x.sign { s = "-" } - return s + x.mant.ToString(base); + return s + x.mant.ToString(base) } // String converts x to its decimal string representation. // x.String() is the same as x.ToString(10). // -func (x *Integer) String() string { return x.ToString(10) } +func (x *Integer) String() string { return x.ToString(10) } // Format is a support routine for fmt.Formatter. It accepts // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). // -func (x *Integer) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } +func (x *Integer) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } // IntFromString returns the integer corresponding to the @@ -509,12 +509,12 @@ func (x *Integer) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(f // func IntFromString(s string, base uint) (*Integer, uint, int) { // skip sign, if any - i0 := 0; + i0 := 0 if len(s) > 0 && (s[0] == '-' || s[0] == '+') { i0 = 1 } - mant, base, slen := NatFromString(s[i0:], base); + mant, base, slen := NatFromString(s[i0:], base) - return MakeInt(i0 > 0 && s[0] == '-', mant), base, i0 + slen; + return MakeInt(i0 > 0 && s[0] == '-', mant), base, i0 + slen } diff --git a/src/pkg/bignum/nrdiv_test.go b/src/pkg/bignum/nrdiv_test.go index 724eecec3..725b1acea 100644 --- a/src/pkg/bignum/nrdiv_test.go +++ b/src/pkg/bignum/nrdiv_test.go @@ -21,8 +21,8 @@ import "testing" // value of an fpNat x is x.m * 2^x.e . // type fpNat struct { - m Natural; - e int; + m Natural + e int } @@ -34,16 +34,16 @@ func (x fpNat) sub(y fpNat) fpNat { case d > 0: return fpNat{x.m.Shl(uint(d)).Sub(y.m), y.e} } - return fpNat{x.m.Sub(y.m), x.e}; + return fpNat{x.m.Sub(y.m), x.e} } // mul2 computes x*2. -func (x fpNat) mul2() fpNat { return fpNat{x.m, x.e + 1} } +func (x fpNat) mul2() fpNat { return fpNat{x.m, x.e + 1} } // mul computes x*y. -func (x fpNat) mul(y fpNat) fpNat { return fpNat{x.m.Mul(y.m), x.e + y.e} } +func (x fpNat) mul(y fpNat) fpNat { return fpNat{x.m.Mul(y.m), x.e + y.e} } // mant computes the (possibly truncated) Natural representation @@ -56,7 +56,7 @@ func (x fpNat) mant() Natural { case x.e < 0: return x.m.Shr(uint(-x.e)) } - return x.m; + return x.m } @@ -65,8 +65,8 @@ func (x fpNat) mant() Natural { // func nrDivEst(x0, y0 Natural) Natural { if y0.IsZero() { - panic("division by zero"); - return nil; + panic("division by zero") + return nil } // y0 > 0 @@ -84,78 +84,78 @@ func nrDivEst(x0, y0 Natural) Natural { // x0 > y0 > 1 // Determine maximum result length. - maxLen := int(x0.Log2() - y0.Log2() + 1); + maxLen := int(x0.Log2() - y0.Log2() + 1) // In the following, each number x is represented // as a mantissa x.m and an exponent x.e such that // x = xm * 2^x.e. - x := fpNat{x0, 0}; - y := fpNat{y0, 0}; + x := fpNat{x0, 0} + y := fpNat{y0, 0} // Determine a scale factor f = 2^e such that // 0.5 <= y/f == y*(2^-e) < 1.0 // and scale y accordingly. - e := int(y.m.Log2()) + 1; - y.e -= e; + e := int(y.m.Log2()) + 1 + y.e -= e // t1 - var c = 2.9142; - const n = 14; - t1 := fpNat{Nat(uint64(c * (1 << n))), -n}; + var c = 2.9142 + const n = 14 + t1 := fpNat{Nat(uint64(c * (1 << n))), -n} // Compute initial value r0 for the reciprocal of y/f. // r0 = t1 - 2*y - r := t1.sub(y.mul2()); - two := fpNat{Nat(2), 0}; + r := t1.sub(y.mul2()) + two := fpNat{Nat(2), 0} // Newton-Raphson iteration - p := Nat(0); + p := Nat(0) for i := 0; ; i++ { // check if we are done // TODO: Need to come up with a better test here // as it will reduce computation time significantly. // q = x*r/f - q := x.mul(r); - q.e -= e; - res := q.mant(); + q := x.mul(r) + q.e -= e + res := q.mant() if res.Cmp(p) == 0 { return res } - p = res; + p = res // r' = r*(2 - y*r) - r = r.mul(two.sub(y.mul(r))); + r = r.mul(two.sub(y.mul(r))) // reduce mantissa size // TODO: Find smaller bound as it will reduce // computation time massively. - d := int(r.m.Log2()+1) - maxLen; + d := int(r.m.Log2()+1) - maxLen if d > 0 { r = fpNat{r.m.Shr(uint(d)), r.e + d} } } - panic("unreachable"); - return nil; + panic("unreachable") + return nil } func nrdiv(x, y Natural) (q, r Natural) { - q = nrDivEst(x, y); - r = x.Sub(y.Mul(q)); + q = nrDivEst(x, y) + r = x.Sub(y.Mul(q)) // if r is too large, correct q and r // (usually one iteration) for r.Cmp(y) >= 0 { - q = q.Add(Nat(1)); - r = r.Sub(y); + q = q.Add(Nat(1)) + r = r.Sub(y) } - return; + return } func div(t *testing.T, x, y Natural) { - q, r := nrdiv(x, y); - qx, rx := x.DivMod(y); + q, r := nrdiv(x, y) + qx, rx := x.DivMod(y) if q.Cmp(qx) != 0 { t.Errorf("x = %s, y = %s, got q = %s, want q = %s", x, y, q, qx) } @@ -165,24 +165,24 @@ func div(t *testing.T, x, y Natural) { } -func idiv(t *testing.T, x0, y0 uint64) { div(t, Nat(x0), Nat(y0)) } +func idiv(t *testing.T, x0, y0 uint64) { div(t, Nat(x0), Nat(y0)) } func TestNRDiv(t *testing.T) { - idiv(t, 17, 18); - idiv(t, 17, 17); - idiv(t, 17, 1); - idiv(t, 17, 16); - idiv(t, 17, 10); - idiv(t, 17, 9); - idiv(t, 17, 8); - idiv(t, 17, 5); - idiv(t, 17, 3); - idiv(t, 1025, 512); - idiv(t, 7489595, 2); - idiv(t, 5404679459, 78495); - idiv(t, 7484890589595, 7484890589594); - div(t, Fact(100), Fact(91)); - div(t, Fact(1000), Fact(991)); + idiv(t, 17, 18) + idiv(t, 17, 17) + idiv(t, 17, 1) + idiv(t, 17, 16) + idiv(t, 17, 10) + idiv(t, 17, 9) + idiv(t, 17, 8) + idiv(t, 17, 5) + idiv(t, 17, 3) + idiv(t, 1025, 512) + idiv(t, 7489595, 2) + idiv(t, 5404679459, 78495) + idiv(t, 7484890589595, 7484890589594) + div(t, Fact(100), Fact(91)) + div(t, Fact(1000), Fact(991)) //div(t, Fact(10000), Fact(9991)); // takes too long - disabled for now } diff --git a/src/pkg/bignum/rational.go b/src/pkg/bignum/rational.go index 9e9c3a8e0..378585e5f 100644 --- a/src/pkg/bignum/rational.go +++ b/src/pkg/bignum/rational.go @@ -12,31 +12,31 @@ import "fmt" // Rational represents a quotient a/b of arbitrary precision. // type Rational struct { - a *Integer; // numerator - b Natural; // denominator + a *Integer // numerator + b Natural // denominator } // MakeRat makes a rational number given a numerator a and a denominator b. // func MakeRat(a *Integer, b Natural) *Rational { - f := a.mant.Gcd(b); // f > 0 + f := a.mant.Gcd(b) // f > 0 if f.Cmp(Nat(1)) != 0 { - a = MakeInt(a.sign, a.mant.Div(f)); - b = b.Div(f); + a = MakeInt(a.sign, a.mant.Div(f)) + b = b.Div(f) } - return &Rational{a, b}; + return &Rational{a, b} } // Rat creates a small rational number with value a0/b0. // func Rat(a0 int64, b0 int64) *Rational { - a, b := Int(a0), Int(b0); + a, b := Int(a0), Int(b0) if b.sign { a = a.Neg() } - return MakeRat(a, b.mant); + return MakeRat(a, b.mant) } @@ -51,30 +51,30 @@ func (x *Rational) Value() (numerator *Integer, denominator Natural) { // IsZero returns true iff x == 0. // -func (x *Rational) IsZero() bool { return x.a.IsZero() } +func (x *Rational) IsZero() bool { return x.a.IsZero() } // IsNeg returns true iff x < 0. // -func (x *Rational) IsNeg() bool { return x.a.IsNeg() } +func (x *Rational) IsNeg() bool { return x.a.IsNeg() } // IsPos returns true iff x > 0. // -func (x *Rational) IsPos() bool { return x.a.IsPos() } +func (x *Rational) IsPos() bool { return x.a.IsPos() } // IsInt returns true iff x can be written with a denominator 1 // in the form x == x'/1; i.e., if x is an integer value. // -func (x *Rational) IsInt() bool { return x.b.Cmp(Nat(1)) == 0 } +func (x *Rational) IsInt() bool { return x.b.Cmp(Nat(1)) == 0 } // Operations // Neg returns the negated value of x. // -func (x *Rational) Neg() *Rational { return MakeRat(x.a.Neg(), x.b) } +func (x *Rational) Neg() *Rational { return MakeRat(x.a.Neg(), x.b) } // Add returns the sum x + y. @@ -93,19 +93,19 @@ func (x *Rational) Sub(y *Rational) *Rational { // Mul returns the product x * y. // -func (x *Rational) Mul(y *Rational) *Rational { return MakeRat(x.a.Mul(y.a), x.b.Mul(y.b)) } +func (x *Rational) Mul(y *Rational) *Rational { return MakeRat(x.a.Mul(y.a), x.b.Mul(y.b)) } // Quo returns the quotient x / y for y != 0. // If y == 0, a division-by-zero run-time error occurs. // func (x *Rational) Quo(y *Rational) *Rational { - a := x.a.MulNat(y.b); - b := y.a.MulNat(x.b); + a := x.a.MulNat(y.b) + b := y.a.MulNat(x.b) if b.IsNeg() { a = a.Neg() } - return MakeRat(a, b.mant); + return MakeRat(a, b.mant) } @@ -115,7 +115,7 @@ func (x *Rational) Quo(y *Rational) *Rational { // == 0 if x == y // > 0 if x > y // -func (x *Rational) Cmp(y *Rational) int { return (x.a.MulNat(y.b)).Cmp(y.a.MulNat(x.b)) } +func (x *Rational) Cmp(y *Rational) int { return (x.a.MulNat(y.b)).Cmp(y.a.MulNat(x.b)) } // ToString converts x to a string for a given base, with 2 <= base <= 16. @@ -123,24 +123,24 @@ func (x *Rational) Cmp(y *Rational) int { return (x.a.MulNat(y.b)).Cmp(y.a.MulNa // it is of form "n/d". // func (x *Rational) ToString(base uint) string { - s := x.a.ToString(base); + s := x.a.ToString(base) if !x.IsInt() { s += "/" + x.b.ToString(base) } - return s; + return s } // String converts x to its decimal string representation. // x.String() is the same as x.ToString(10). // -func (x *Rational) String() string { return x.ToString(10) } +func (x *Rational) String() string { return x.ToString(10) } // Format is a support routine for fmt.Formatter. It accepts // the formats 'b' (binary), 'o' (octal), and 'x' (hexadecimal). // -func (x *Rational) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } +func (x *Rational) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString(fmtbase(c))) } // RatFromString returns the rational number corresponding to the @@ -164,35 +164,35 @@ func (x *Rational) Format(h fmt.State, c int) { fmt.Fprintf(h, "%s", x.ToString( // func RatFromString(s string, base uint) (*Rational, uint, int) { // read numerator - a, abase, alen := IntFromString(s, base); - b := Nat(1); + a, abase, alen := IntFromString(s, base) + b := Nat(1) // read denominator or fraction, if any - var blen int; + var blen int if alen < len(s) { - ch := s[alen]; + ch := s[alen] if ch == '/' { - alen++; - b, base, blen = NatFromString(s[alen:], base); + alen++ + b, base, blen = NatFromString(s[alen:], base) } else if ch == '.' { - alen++; - b, base, blen = NatFromString(s[alen:], abase); - assert(base == abase); - f := Nat(uint64(base)).Pow(uint(blen)); - a = MakeInt(a.sign, a.mant.Mul(f).Add(b)); - b = f; + alen++ + b, base, blen = NatFromString(s[alen:], abase) + assert(base == abase) + f := Nat(uint64(base)).Pow(uint(blen)) + a = MakeInt(a.sign, a.mant.Mul(f).Add(b)) + b = f } } // read exponent, if any - rlen := alen + blen; + rlen := alen + blen if rlen < len(s) { - ch := s[rlen]; + ch := s[rlen] if ch == 'e' || ch == 'E' { - rlen++; - e, _, elen := IntFromString(s[rlen:], 10); - rlen += elen; - m := Nat(10).Pow(uint(e.mant.Value())); + rlen++ + e, _, elen := IntFromString(s[rlen:], 10) + rlen += elen + m := Nat(10).Pow(uint(e.mant.Value())) if e.sign { b = b.Mul(m) } else { @@ -201,5 +201,5 @@ func RatFromString(s string, base uint) (*Rational, uint, int) { } } - return MakeRat(a, b), base, rlen; + return MakeRat(a, b), base, rlen } diff --git a/src/pkg/bufio/bufio.go b/src/pkg/bufio/bufio.go index 782bfe2c4..00bc53cd7 100644 --- a/src/pkg/bufio/bufio.go +++ b/src/pkg/bufio/bufio.go @@ -8,27 +8,27 @@ package bufio import ( - "bytes"; - "io"; - "os"; - "strconv"; - "utf8"; + "bytes" + "io" + "os" + "strconv" + "utf8" ) const ( - defaultBufSize = 4096; + defaultBufSize = 4096 ) // Errors introduced by this package. type Error struct { - os.ErrorString; + os.ErrorString } var ( - ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}; - ErrBufferFull os.Error = &Error{"bufio: buffer full"}; - errInternal os.Error = &Error{"bufio: internal error"}; + ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"} + ErrBufferFull os.Error = &Error{"bufio: buffer full"} + errInternal os.Error = &Error{"bufio: internal error"} ) // BufSizeError is the error representing an invalid buffer size. @@ -43,11 +43,11 @@ func (b BufSizeError) String() string { // Reader implements buffering for an io.Reader object. type Reader struct { - buf []byte; - rd io.Reader; - r, w int; - err os.Error; - lastbyte int; + buf []byte + rd io.Reader + r, w int + err os.Error + lastbyte int } // NewReaderSize creates a new Reader whose buffer has the specified size, @@ -59,41 +59,41 @@ func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) { return nil, BufSizeError(size) } // Is it already a Reader? - b, ok := rd.(*Reader); + b, ok := rd.(*Reader) if ok && len(b.buf) >= size { return b, nil } - b = new(Reader); - b.buf = make([]byte, size); - b.rd = rd; - b.lastbyte = -1; - return b, nil; + b = new(Reader) + b.buf = make([]byte, size) + b.rd = rd + b.lastbyte = -1 + return b, nil } // NewReader returns a new Reader whose buffer has the default size. func NewReader(rd io.Reader) *Reader { - b, err := NewReaderSize(rd, defaultBufSize); + b, err := NewReaderSize(rd, defaultBufSize) if err != nil { // cannot happen - defaultBufSize is a valid size panic("bufio: NewReader: ", err.String()) } - return b; + return b } // fill reads a new chunk into the buffer. func (b *Reader) fill() { // Slide existing data to beginning. if b.w > b.r { - copy(b.buf[0:b.w-b.r], b.buf[b.r:b.w]); - b.w -= b.r; + copy(b.buf[0:b.w-b.r], b.buf[b.r:b.w]) + b.w -= b.r } else { b.w = 0 } - b.r = 0; + b.r = 0 // Read new data. - n, e := b.rd.Read(b.buf[b.w:]); - b.w += n; + n, e := b.rd.Read(b.buf[b.w:]) + b.w += n if e != nil { b.err = e } @@ -105,9 +105,9 @@ func (b *Reader) fill() { // why the read is short. At EOF, the count will be // zero and err will be os.EOF. func (b *Reader) Read(p []byte) (nn int, err os.Error) { - nn = 0; + nn = 0 for len(p) > 0 { - n := len(p); + n := len(p) if b.w == b.r { if b.err != nil { return nn, b.err @@ -115,27 +115,27 @@ func (b *Reader) Read(p []byte) (nn int, err os.Error) { if len(p) >= len(b.buf) { // Large read, empty buffer. // Read directly into p to avoid copy. - n, b.err = b.rd.Read(p); + n, b.err = b.rd.Read(p) if n > 0 { b.lastbyte = int(p[n-1]) } - p = p[n:]; - nn += n; - continue; + p = p[n:] + nn += n + continue } - b.fill(); - continue; + b.fill() + continue } if n > b.w-b.r { n = b.w - b.r } - copy(p[0:n], b.buf[b.r:b.r+n]); - p = p[n:]; - b.r += n; - b.lastbyte = int(b.buf[b.r-1]); - nn += n; + copy(p[0:n], b.buf[b.r:b.r+n]) + p = p[n:] + b.r += n + b.lastbyte = int(b.buf[b.r-1]) + nn += n } - return nn, nil; + return nn, nil } // ReadByte reads and returns a single byte. @@ -145,29 +145,29 @@ func (b *Reader) ReadByte() (c byte, err os.Error) { if b.err != nil { return 0, b.err } - b.fill(); + b.fill() } - c = b.buf[b.r]; - b.r++; - b.lastbyte = int(c); - return c, nil; + c = b.buf[b.r] + b.r++ + b.lastbyte = int(c) + return c, nil } // UnreadByte unreads the last byte. Only the most recently read byte can be unread. func (b *Reader) UnreadByte() os.Error { if b.r == b.w && b.lastbyte >= 0 { - b.w = 1; - b.r = 0; - b.buf[0] = byte(b.lastbyte); - b.lastbyte = -1; - return nil; + b.w = 1 + b.r = 0 + b.buf[0] = byte(b.lastbyte) + b.lastbyte = -1 + return nil } if b.r <= 0 { return ErrInvalidUnreadByte } - b.r--; - b.lastbyte = -1; - return nil; + b.r-- + b.lastbyte = -1 + return nil } // ReadRune reads a single UTF-8 encoded Unicode character and returns the @@ -179,17 +179,17 @@ func (b *Reader) ReadRune() (rune int, size int, err os.Error) { if b.r == b.w { return 0, 0, b.err } - rune, size = int(b.buf[b.r]), 1; + rune, size = int(b.buf[b.r]), 1 if rune >= 0x80 { rune, size = utf8.DecodeRune(b.buf[b.r:b.w]) } - b.r += size; - b.lastbyte = int(b.buf[b.r-1]); - return rune, size, nil; + b.r += size + b.lastbyte = int(b.buf[b.r-1]) + return rune, size, nil } // Buffered returns the number of bytes that can be read from the current buffer. -func (b *Reader) Buffered() int { return b.w - b.r } +func (b *Reader) Buffered() int { return b.w - b.r } // ReadSlice reads until the first occurrence of delim in the input, // returning a slice pointing at the bytes in the buffer. @@ -204,27 +204,27 @@ func (b *Reader) Buffered() int { return b.w - b.r } func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) { // Look in buffer. if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 { - line1 := b.buf[b.r : b.r+i+1]; - b.r += i + 1; - return line1, nil; + line1 := b.buf[b.r : b.r+i+1] + b.r += i + 1 + return line1, nil } // Read more into buffer, until buffer fills or we find delim. for { if b.err != nil { - line := b.buf[b.r:b.w]; - b.r = b.w; - return line, b.err; + line := b.buf[b.r:b.w] + b.r = b.w + return line, b.err } - n := b.Buffered(); - b.fill(); + n := b.Buffered() + b.fill() // Search new part of buffer if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 { - line := b.buf[0 : n+i+1]; - b.r = n + i + 1; - return line, nil; + line := b.buf[0 : n+i+1] + b.r = n + i + 1 + return line, nil } // Buffer is full? @@ -232,7 +232,7 @@ func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) { return nil, ErrBufferFull } } - panic("not reached"); + panic("not reached") } // ReadBytes reads until the first occurrence of delim in the input, @@ -243,69 +243,69 @@ func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) { func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) { // Use ReadSlice to look for array, // accumulating full buffers. - var frag []byte; - var full [][]byte; - nfull := 0; - err = nil; + var frag []byte + var full [][]byte + nfull := 0 + err = nil for { - var e os.Error; - frag, e = b.ReadSlice(delim); - if e == nil { // got final fragment + var e os.Error + frag, e = b.ReadSlice(delim) + if e == nil { // got final fragment break } - if e != ErrBufferFull { // unexpected error - err = e; - break; + if e != ErrBufferFull { // unexpected error + err = e + break } // Read bytes out of buffer. - buf := make([]byte, b.Buffered()); - var n int; - n, e = b.Read(buf); + buf := make([]byte, b.Buffered()) + var n int + n, e = b.Read(buf) if e != nil { - frag = buf[0:n]; - err = e; - break; + frag = buf[0:n] + err = e + break } if n != len(buf) { - frag = buf[0:n]; - err = errInternal; - break; + frag = buf[0:n] + err = errInternal + break } // Grow list if needed. if full == nil { full = make([][]byte, 16) } else if nfull >= len(full) { - newfull := make([][]byte, len(full)*2); + newfull := make([][]byte, len(full)*2) for i := 0; i < len(full); i++ { newfull[i] = full[i] } - full = newfull; + full = newfull } // Save buffer - full[nfull] = buf; - nfull++; + full[nfull] = buf + nfull++ } // Allocate new buffer to hold the full pieces and the fragment. - n := 0; + n := 0 for i := 0; i < nfull; i++ { n += len(full[i]) } - n += len(frag); + n += len(frag) // Copy full pieces and fragment in. - buf := make([]byte, n); - n = 0; + buf := make([]byte, n) + n = 0 for i := 0; i < nfull; i++ { - copy(buf[n:n+len(full[i])], full[i]); - n += len(full[i]); + copy(buf[n:n+len(full[i])], full[i]) + n += len(full[i]) } - copy(buf[n:n+len(frag)], frag); - return buf, err; + copy(buf[n:n+len(frag)], frag) + return buf, err } // ReadString reads until the first occurrence of delim in the input, @@ -314,8 +314,8 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) { // it returns the data read before the error and the error itself (often os.EOF). // ReadString returns err != nil if and only if line does not end in delim. func (b *Reader) ReadString(delim byte) (line string, err os.Error) { - bytes, e := b.ReadBytes(delim); - return string(bytes), e; + bytes, e := b.ReadBytes(delim) + return string(bytes), e } @@ -323,10 +323,10 @@ func (b *Reader) ReadString(delim byte) (line string, err os.Error) { // Writer implements buffering for an io.Writer object. type Writer struct { - err os.Error; - buf []byte; - n int; - wr io.Writer; + err os.Error + buf []byte + n int + wr io.Writer } // NewWriterSize creates a new Writer whose buffer has the specified size, @@ -338,24 +338,24 @@ func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) { return nil, BufSizeError(size) } // Is it already a Writer? - b, ok := wr.(*Writer); + b, ok := wr.(*Writer) if ok && len(b.buf) >= size { return b, nil } - b = new(Writer); - b.buf = make([]byte, size); - b.wr = wr; - return b, nil; + b = new(Writer) + b.buf = make([]byte, size) + b.wr = wr + return b, nil } // NewWriter returns a new Writer whose buffer has the default size. func NewWriter(wr io.Writer) *Writer { - b, err := NewWriterSize(wr, defaultBufSize); + b, err := NewWriterSize(wr, defaultBufSize) if err != nil { // cannot happen - defaultBufSize is valid size panic("bufio: NewWriter: ", err.String()) } - return b; + return b } // Flush writes any buffered data to the underlying io.Writer. @@ -363,7 +363,7 @@ func (b *Writer) Flush() os.Error { if b.err != nil { return b.err } - n, e := b.wr.Write(b.buf[0:b.n]); + n, e := b.wr.Write(b.buf[0:b.n]) if n < b.n && e == nil { e = io.ErrShortWrite } @@ -371,19 +371,19 @@ func (b *Writer) Flush() os.Error { if n > 0 && n < b.n { copy(b.buf[0:b.n-n], b.buf[n:b.n]) } - b.n -= n; - b.err = e; - return e; + b.n -= n + b.err = e + return e } - b.n = 0; - return nil; + b.n = 0 + return nil } // Available returns how many bytes are unused in the buffer. -func (b *Writer) Available() int { return len(b.buf) - b.n } +func (b *Writer) Available() int { return len(b.buf) - b.n } // Buffered returns the number of bytes that have been written into the current buffer. -func (b *Writer) Buffered() int { return b.n } +func (b *Writer) Buffered() int { return b.n } // Write writes the contents of p into the buffer. // It returns the number of bytes written. @@ -393,35 +393,35 @@ func (b *Writer) Write(p []byte) (nn int, err os.Error) { if b.err != nil { return 0, b.err } - nn = 0; + nn = 0 for len(p) > 0 { - n := b.Available(); + n := b.Available() if n <= 0 { if b.Flush(); b.err != nil { break } - n = b.Available(); + n = b.Available() } if b.Available() == 0 && len(p) >= len(b.buf) { // Large write, empty buffer. // Write directly from p to avoid copy. - n, b.err = b.wr.Write(p); - nn += n; - p = p[n:]; + n, b.err = b.wr.Write(p) + nn += n + p = p[n:] if b.err != nil { break } - continue; + continue } if n > len(p) { n = len(p) } - copy(b.buf[b.n:b.n+n], p[0:n]); - b.n += n; - nn += n; - p = p[n:]; + copy(b.buf[b.n:b.n+n], p[0:n]) + b.n += n + nn += n + p = p[n:] } - return nn, b.err; + return nn, b.err } // WriteByte writes a single byte. @@ -432,9 +432,9 @@ func (b *Writer) WriteByte(c byte) os.Error { if b.Available() <= 0 && b.Flush() != nil { return b.err } - b.buf[b.n] = c; - b.n++; - return nil; + b.buf[b.n] = c + b.n++ + return nil } // WriteString writes a string. @@ -444,16 +444,16 @@ func (b *Writer) WriteString(s string) os.Error { } // Common case, worth making fast. if b.Available() >= len(s) || len(b.buf) >= len(s) && b.Flush() == nil { - for i := 0; i < len(s); i++ { // loop over bytes, not runes. - b.buf[b.n] = s[i]; - b.n++; + for i := 0; i < len(s); i++ { // loop over bytes, not runes. + b.buf[b.n] = s[i] + b.n++ } - return nil; + return nil } - for i := 0; i < len(s); i++ { // loop over bytes, not runes. + for i := 0; i < len(s); i++ { // loop over bytes, not runes. b.WriteByte(s[i]) } - return b.err; + return b.err } // buffered input and output @@ -461,8 +461,8 @@ func (b *Writer) WriteString(s string) os.Error { // ReadWriter stores pointers to a Reader and a Writer. // It implements io.ReadWriter. type ReadWriter struct { - *Reader; - *Writer; + *Reader + *Writer } // NewReadWriter allocates a new ReadWriter that dispatches to r and w. diff --git a/src/pkg/bufio/bufio_test.go b/src/pkg/bufio/bufio_test.go index bdd4800b4..83152e926 100644 --- a/src/pkg/bufio/bufio_test.go +++ b/src/pkg/bufio/bufio_test.go @@ -5,68 +5,68 @@ package bufio import ( - "bytes"; - "fmt"; - "io"; - "os"; - "strings"; - "testing"; - "testing/iotest"; + "bytes" + "fmt" + "io" + "os" + "strings" + "testing" + "testing/iotest" ) // Reads from a reader and rot13s the result. type rot13Reader struct { - r io.Reader; + r io.Reader } func newRot13Reader(r io.Reader) *rot13Reader { - r13 := new(rot13Reader); - r13.r = r; - return r13; + r13 := new(rot13Reader) + r13.r = r + return r13 } func (r13 *rot13Reader) Read(p []byte) (int, os.Error) { - n, e := r13.r.Read(p); + n, e := r13.r.Read(p) if e != nil { return n, e } for i := 0; i < n; i++ { - c := p[i] | 0x20; // lowercase byte + c := p[i] | 0x20 // lowercase byte if 'a' <= c && c <= 'm' { p[i] += 13 } else if 'n' <= c && c <= 'z' { p[i] -= 13 } } - return n, nil; + return n, nil } // Call ReadByte to accumulate the text of a file func readBytes(buf *Reader) string { - var b [1000]byte; - nb := 0; + var b [1000]byte + nb := 0 for { - c, e := buf.ReadByte(); + c, e := buf.ReadByte() if e == os.EOF { break } if e != nil { panic("Data: " + e.String()) } - b[nb] = c; - nb++; + b[nb] = c + nb++ } - return string(b[0:nb]); + return string(b[0:nb]) } func TestReaderSimple(t *testing.T) { - data := "hello world"; - b := NewReader(bytes.NewBufferString(data)); + data := "hello world" + b := NewReader(bytes.NewBufferString(data)) if s := readBytes(b); s != "hello world" { t.Errorf("simple hello world test failed: got %q", s) } - b = NewReader(newRot13Reader(bytes.NewBufferString(data))); + b = NewReader(newRot13Reader(bytes.NewBufferString(data))) if s := readBytes(b); s != "uryyb jbeyq" { t.Error("rot13 hello world test failed: got %q", s) } @@ -74,8 +74,8 @@ func TestReaderSimple(t *testing.T) { type readMaker struct { - name string; - fn func(io.Reader) io.Reader; + name string + fn func(io.Reader) io.Reader } var readMakers = []readMaker{ @@ -88,37 +88,37 @@ var readMakers = []readMaker{ // Call ReadString (which ends up calling everything else) // to accumulate the text of a file. func readLines(b *Reader) string { - s := ""; + s := "" for { - s1, e := b.ReadString('\n'); + s1, e := b.ReadString('\n') if e == os.EOF { break } if e != nil { panic("GetLines: " + e.String()) } - s += s1; + s += s1 } - return s; + return s } // Call Read to accumulate the text of a file func reads(buf *Reader, m int) string { - var b [1000]byte; - nb := 0; + var b [1000]byte + nb := 0 for { - n, e := buf.Read(b[nb : nb+m]); - nb += n; + n, e := buf.Read(b[nb : nb+m]) + nb += n if e == os.EOF { break } } - return string(b[0:nb]); + return string(b[0:nb]) } type bufReader struct { - name string; - fn func(*Reader) string; + name string + fn func(*Reader) string } var bufreaders = []bufReader{ @@ -138,27 +138,27 @@ var bufsizes = []int{ } func TestReader(t *testing.T) { - var texts [31]string; - str := ""; - all := ""; + var texts [31]string + str := "" + all := "" for i := 0; i < len(texts)-1; i++ { - texts[i] = str + "\n"; - all += texts[i]; - str += string(i%26 + 'a'); + texts[i] = str + "\n" + all += texts[i] + str += string(i%26 + 'a') } - texts[len(texts)-1] = all; + texts[len(texts)-1] = all for h := 0; h < len(texts); h++ { - text := texts[h]; + text := texts[h] for i := 0; i < len(readMakers); i++ { for j := 0; j < len(bufreaders); j++ { for k := 0; k < len(bufsizes); k++ { - readmaker := readMakers[i]; - bufreader := bufreaders[j]; - bufsize := bufsizes[k]; - read := readmaker.fn(bytes.NewBufferString(text)); - buf, _ := NewReaderSize(read, bufsize); - s := bufreader.fn(buf); + readmaker := readMakers[i] + bufreader := bufreaders[j] + bufsize := bufsizes[k] + read := readmaker.fn(bytes.NewBufferString(text)) + buf, _ := NewReaderSize(read, bufsize) + s := bufreader.fn(buf) if s != text { t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q", readmaker.name, bufreader.name, bufsize, text, s) @@ -171,37 +171,37 @@ func TestReader(t *testing.T) { // A StringReader delivers its data one string segment at a time via Read. type StringReader struct { - data []string; - step int; + data []string + step int } func (r *StringReader) Read(p []byte) (n int, err os.Error) { if r.step < len(r.data) { - s := r.data[r.step]; + s := r.data[r.step] for i := 0; i < len(s); i++ { p[i] = s[i] } - n = len(s); - r.step++; + n = len(s) + r.step++ } else { err = os.EOF } - return; + return } func readRuneSegments(t *testing.T, segments []string) { - got := ""; - want := strings.Join(segments, ""); - r := NewReader(&StringReader{data: segments}); + got := "" + want := strings.Join(segments, "") + r := NewReader(&StringReader{data: segments}) for { - rune, _, err := r.ReadRune(); + rune, _, err := r.ReadRune() if err != nil { if err != os.EOF { return } - break; + break } - got += string(rune); + got += string(rune) } if got != want { t.Errorf("segments=%v got=%s want=%s", segments, got, want) @@ -226,46 +226,46 @@ func TestReadRune(t *testing.T) { } func TestWriter(t *testing.T) { - var data [8192]byte; + var data [8192]byte for i := 0; i < len(data); i++ { data[i] = byte(' ' + i%('~'-' ')) } - w := new(bytes.Buffer); + w := new(bytes.Buffer) for i := 0; i < len(bufsizes); i++ { for j := 0; j < len(bufsizes); j++ { - nwrite := bufsizes[i]; - bs := bufsizes[j]; + nwrite := bufsizes[i] + bs := bufsizes[j] // Write nwrite bytes using buffer size bs. // Check that the right amount makes it out // and that the data is correct. - w.Reset(); - buf, e := NewWriterSize(w, bs); - context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs); + w.Reset() + buf, e := NewWriterSize(w, bs) + context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs) if e != nil { - t.Errorf("%s: NewWriterSize %d: %v", context, bs, e); - continue; + t.Errorf("%s: NewWriterSize %d: %v", context, bs, e) + continue } - n, e1 := buf.Write(data[0:nwrite]); + n, e1 := buf.Write(data[0:nwrite]) if e1 != nil || n != nwrite { - t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1); - continue; + t.Errorf("%s: buf.Write %d = %d, %v", context, nwrite, n, e1) + continue } if e = buf.Flush(); e != nil { t.Errorf("%s: buf.Flush = %v", context, e) } - written := w.Bytes(); + written := w.Bytes() if len(written) != nwrite { t.Errorf("%s: %d bytes written", context, len(written)) } for l := 0; l < len(written); l++ { if written[i] != data[i] { - t.Errorf("%s: wrong bytes written"); - t.Errorf("want=%s", data[0:len(written)]); - t.Errorf("have=%s", written); + t.Errorf("%s: wrong bytes written") + t.Errorf("want=%s", data[0:len(written)]) + t.Errorf("have=%s", written) } } } @@ -275,9 +275,9 @@ func TestWriter(t *testing.T) { // Check that write errors are returned properly. type errorWriterTest struct { - n, m int; - err os.Error; - expect os.Error; + n, m int + err os.Error + expect os.Error } func (w errorWriterTest) Write(p []byte) (int, os.Error) { @@ -295,13 +295,13 @@ var errorWriterTests = []errorWriterTest{ func TestWriteErrors(t *testing.T) { for _, w := range errorWriterTests { - buf := NewWriter(w); - _, e := buf.Write(strings.Bytes("hello world")); + buf := NewWriter(w) + _, e := buf.Write(strings.Bytes("hello world")) if e != nil { - t.Errorf("Write hello to %v: %v", w, e); - continue; + t.Errorf("Write hello to %v: %v", w, e) + continue } - e = buf.Flush(); + e = buf.Flush() if e != w.expect { t.Errorf("Flush %v: got %v, wanted %v", w, e, w.expect) } @@ -309,13 +309,13 @@ func TestWriteErrors(t *testing.T) { } func TestNewReaderSizeIdempotent(t *testing.T) { - const BufSize = 1000; - b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize); + const BufSize = 1000 + b, err := NewReaderSize(bytes.NewBufferString("hello world"), BufSize) if err != nil { t.Error("NewReaderSize create fail", err) } // Does it recognize itself? - b1, err2 := NewReaderSize(b, BufSize); + b1, err2 := NewReaderSize(b, BufSize) if err2 != nil { t.Error("NewReaderSize #2 create fail", err2) } @@ -323,7 +323,7 @@ func TestNewReaderSizeIdempotent(t *testing.T) { t.Error("NewReaderSize did not detect underlying Reader") } // Does it wrap if existing buffer is too small? - b2, err3 := NewReaderSize(b, 2*BufSize); + b2, err3 := NewReaderSize(b, 2*BufSize) if err3 != nil { t.Error("NewReaderSize #3 create fail", err3) } @@ -333,13 +333,13 @@ func TestNewReaderSizeIdempotent(t *testing.T) { } func TestNewWriterSizeIdempotent(t *testing.T) { - const BufSize = 1000; - b, err := NewWriterSize(new(bytes.Buffer), BufSize); + const BufSize = 1000 + b, err := NewWriterSize(new(bytes.Buffer), BufSize) if err != nil { t.Error("NewWriterSize create fail", err) } // Does it recognize itself? - b1, err2 := NewWriterSize(b, BufSize); + b1, err2 := NewWriterSize(b, BufSize) if err2 != nil { t.Error("NewWriterSize #2 create fail", err2) } @@ -347,7 +347,7 @@ func TestNewWriterSizeIdempotent(t *testing.T) { t.Error("NewWriterSize did not detect underlying Writer") } // Does it wrap if existing buffer is too small? - b2, err3 := NewWriterSize(b, 2*BufSize); + b2, err3 := NewWriterSize(b, 2*BufSize) if err3 != nil { t.Error("NewWriterSize #3 create fail", err3) } @@ -357,22 +357,22 @@ func TestNewWriterSizeIdempotent(t *testing.T) { } func TestWriteString(t *testing.T) { - const BufSize = 8; - buf := new(bytes.Buffer); - b, err := NewWriterSize(buf, BufSize); + const BufSize = 8 + buf := new(bytes.Buffer) + b, err := NewWriterSize(buf, BufSize) if err != nil { t.Error("NewWriterSize create fail", err) } - b.WriteString("0"); // easy - b.WriteString("123456"); // still easy - b.WriteString("7890"); // easy after flush - b.WriteString("abcdefghijklmnopqrstuvwxy"); // hard - b.WriteString("z"); - b.Flush(); + b.WriteString("0") // easy + b.WriteString("123456") // still easy + b.WriteString("7890") // easy after flush + b.WriteString("abcdefghijklmnopqrstuvwxy") // hard + b.WriteString("z") + b.Flush() if b.err != nil { t.Error("WriteString", b.err) } - s := "01234567890abcdefghijklmnopqrstuvwxyz"; + s := "01234567890abcdefghijklmnopqrstuvwxyz" if string(buf.Bytes()) != s { t.Errorf("WriteString wants %q gets %q", s, string(buf.Bytes())) } diff --git a/src/pkg/bytes/buffer.go b/src/pkg/bytes/buffer.go index b302b65fa..bbca70b06 100644 --- a/src/pkg/bytes/buffer.go +++ b/src/pkg/bytes/buffer.go @@ -7,15 +7,15 @@ package bytes // Simple byte buffer for marshaling data. import ( - "io"; - "os"; + "io" + "os" ) // Copy from string to byte array at offset doff. Assume there's room. func copyString(dst []byte, doff int, str string) { for soff := 0; soff < len(str); soff++ { - dst[doff] = str[soff]; - doff++; + dst[doff] = str[soff] + doff++ } } @@ -23,15 +23,15 @@ func copyString(dst []byte, doff int, str string) { // with Read and Write methods. // The zero value for Buffer is an empty buffer ready to use. type Buffer struct { - buf []byte; // contents are the bytes buf[off : len(buf)] - off int; // read at &buf[off], write at &buf[len(buf)] - oneByte [1]byte; // avoid allocation of slice on each WriteByte - bootstrap [64]byte; // memory to hold first slice; helps small buffers (Printf) avoid allocation. + buf []byte // contents are the bytes buf[off : len(buf)] + off int // read at &buf[off], write at &buf[len(buf)] + oneByte [1]byte // avoid allocation of slice on each WriteByte + bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation. } // Bytes returns the contents of the unread portion of the buffer; // len(b.Bytes()) == b.Len(). -func (b *Buffer) Bytes() []byte { return b.buf[b.off:] } +func (b *Buffer) Bytes() []byte { return b.buf[b.off:] } // String returns the contents of the unread portion of the buffer // as a string. If the Buffer is a nil pointer, it returns "<nil>". @@ -40,12 +40,12 @@ func (b *Buffer) String() string { // Special case, useful in debugging. return "<nil>" } - return string(b.buf[b.off:]); + return string(b.buf[b.off:]) } // Len returns the number of bytes of the unread portion of the buffer; // b.Len() == len(b.Bytes()). -func (b *Buffer) Len() int { return len(b.buf) - b.off } +func (b *Buffer) Len() int { return len(b.buf) - b.off } // Truncate discards all but the first n unread bytes from the buffer. // It is an error to call b.Truncate(n) with n > b.Len(). @@ -54,64 +54,64 @@ func (b *Buffer) Truncate(n int) { // Reuse buffer space. b.off = 0 } - b.buf = b.buf[0 : b.off+n]; + b.buf = b.buf[0 : b.off+n] } // Reset resets the buffer so it has no content. // b.Reset() is the same as b.Truncate(0). -func (b *Buffer) Reset() { b.Truncate(0) } +func (b *Buffer) Reset() { b.Truncate(0) } // Resize buffer to guarantee enough space for n more bytes. // After this call, the state of b.buf is inconsistent. // It must be fixed up as is done in Write and WriteString. func (b *Buffer) resize(n int) { - var buf []byte; + var buf []byte if b.buf == nil && n <= len(b.bootstrap) { buf = &b.bootstrap } else { - buf = b.buf; + buf = b.buf if len(b.buf)+n > cap(b.buf) { // not enough space anywhere buf = make([]byte, 2*cap(b.buf)+n) } - copy(buf, b.buf[b.off:]); + copy(buf, b.buf[b.off:]) } - b.buf = buf; - b.off = 0; + b.buf = buf + b.off = 0 } // Write appends the contents of p to the buffer. The return // value n is the length of p; err is always nil. func (b *Buffer) Write(p []byte) (n int, err os.Error) { - m := b.Len(); + m := b.Len() // If buffer is empty, reset to recover space. if m == 0 && b.off != 0 { b.Truncate(0) } - n = len(p); + n = len(p) if len(b.buf)+n > cap(b.buf) { b.resize(n) } - b.buf = b.buf[0 : b.off+m+n]; - copy(b.buf[b.off+m:], p); - return n, nil; + b.buf = b.buf[0 : b.off+m+n] + copy(b.buf[b.off+m:], p) + return n, nil } // WriteString appends the contents of s to the buffer. The return // value n is the length of s; err is always nil. func (b *Buffer) WriteString(s string) (n int, err os.Error) { - m := b.Len(); + m := b.Len() // If buffer is empty, reset to recover space. if m == 0 && b.off != 0 { b.Truncate(0) } - n = len(s); + n = len(s) if len(b.buf)+n > cap(b.buf) { b.resize(n) } - b.buf = b.buf[0 : b.off+m+n]; - copyString(b.buf, b.off+m, s); - return n, nil; + b.buf = b.buf[0 : b.off+m+n] + copyString(b.buf, b.off+m, s) + return n, nil } // MinRead is the minimum slice size passed to a Read call by @@ -131,7 +131,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) { } for { if cap(b.buf)-len(b.buf) < MinRead { - var newBuf []byte; + var newBuf []byte // can we get space without allocation? if b.off+cap(b.buf)-len(b.buf) >= MinRead { // reuse beginning of buffer @@ -140,13 +140,13 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) { // not enough space at end; put space on end newBuf = make([]byte, len(b.buf)-b.off, 2*(cap(b.buf)-b.off)+MinRead) } - copy(newBuf, b.buf[b.off:]); - b.buf = newBuf; - b.off = 0; + copy(newBuf, b.buf[b.off:]) + b.buf = newBuf + b.off = 0 } - m, e := r.Read(b.buf[len(b.buf):cap(b.buf)]); - b.buf = b.buf[b.off : len(b.buf)+m]; - n += int64(m); + m, e := r.Read(b.buf[len(b.buf):cap(b.buf)]) + b.buf = b.buf[b.off : len(b.buf)+m] + n += int64(m) if e == os.EOF { break } @@ -154,7 +154,7 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) { return n, e } } - return n, nil; // err is EOF, so return nil explicitly + return n, nil // err is EOF, so return nil explicitly } // WriteTo writes data to w until the buffer is drained or an error @@ -162,25 +162,25 @@ func (b *Buffer) ReadFrom(r io.Reader) (n int64, err os.Error) { // Any error encountered during the write is also returned. func (b *Buffer) WriteTo(w io.Writer) (n int64, err os.Error) { for b.off < len(b.buf) { - m, e := w.Write(b.buf[b.off:]); - n += int64(m); - b.off += m; + m, e := w.Write(b.buf[b.off:]) + n += int64(m) + b.off += m if e != nil { return n, e } } // Buffer is now empty; reset. - b.Truncate(0); - return; + b.Truncate(0) + return } // WriteByte appends the byte c to the buffer. // The returned error is always nil, but is included // to match bufio.Writer's WriteByte. func (b *Buffer) WriteByte(c byte) os.Error { - b.oneByte[0] = c; - b.Write(&b.oneByte); - return nil; + b.oneByte[0] = c + b.Write(&b.oneByte) + return nil } // Read reads the next len(p) bytes from the buffer or until the buffer @@ -190,20 +190,20 @@ func (b *Buffer) WriteByte(c byte) os.Error { func (b *Buffer) Read(p []byte) (n int, err os.Error) { if b.off >= len(b.buf) { // Buffer is empty, reset to recover space. - b.Truncate(0); - return 0, os.EOF; + b.Truncate(0) + return 0, os.EOF } - m := b.Len(); - n = len(p); + m := b.Len() + n = len(p) if n > m { // more bytes requested than available n = m } - copy(p, b.buf[b.off:b.off+n]); - b.off += n; - return n, err; + copy(p, b.buf[b.off:b.off+n]) + b.off += n + return n, err } // ReadByte reads and returns the next byte from the buffer. @@ -211,22 +211,22 @@ func (b *Buffer) Read(p []byte) (n int, err os.Error) { func (b *Buffer) ReadByte() (c byte, err os.Error) { if b.off >= len(b.buf) { // Buffer is empty, reset to recover space. - b.Truncate(0); - return 0, os.EOF; + b.Truncate(0) + return 0, os.EOF } - c = b.buf[b.off]; - b.off++; - return c, nil; + c = b.buf[b.off] + b.off++ + return c, nil } // NewBuffer creates and initializes a new Buffer // using buf as its initial contents. -func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} } +func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} } // NewBufferString creates and initializes a new Buffer // using string s as its initial contents. func NewBufferString(s string) *Buffer { - buf := make([]byte, len(s)); - copyString(buf, 0, s); - return &Buffer{buf: buf}; + buf := make([]byte, len(s)) + copyString(buf, 0, s) + return &Buffer{buf: buf} } diff --git a/src/pkg/bytes/buffer_test.go b/src/pkg/bytes/buffer_test.go index c9dafad40..af637cf63 100644 --- a/src/pkg/bytes/buffer_test.go +++ b/src/pkg/bytes/buffer_test.go @@ -5,29 +5,29 @@ package bytes_test import ( - . "bytes"; - "rand"; - "testing"; + . "bytes" + "rand" + "testing" ) -const N = 10000 // make this bigger for a larger (and slower) test -var data string // test data for write tests -var bytes []byte // test data; same as data but as a slice. +const N = 10000 // make this bigger for a larger (and slower) test +var data string // test data for write tests +var bytes []byte // test data; same as data but as a slice. func init() { - bytes = make([]byte, N); + bytes = make([]byte, N) for i := 0; i < N; i++ { bytes[i] = 'a' + byte(i%26) } - data = string(bytes); + data = string(bytes) } // Verify that contents of buf match the string s. func check(t *testing.T, testname string, buf *Buffer, s string) { - bytes := buf.Bytes(); - str := buf.String(); + bytes := buf.Bytes() + str := buf.String() if buf.Len() != len(bytes) { t.Errorf("%s: buf.Len() == %d, len(buf.Bytes()) == %d\n", testname, buf.Len(), len(bytes)) } @@ -50,19 +50,19 @@ func check(t *testing.T, testname string, buf *Buffer, s string) { // The initial contents of buf corresponds to the string s; // the result is the final contents of buf returned as a string. func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus string) string { - check(t, testname+" (fill 1)", buf, s); + check(t, testname+" (fill 1)", buf, s) for ; n > 0; n-- { - m, err := buf.WriteString(fus); + m, err := buf.WriteString(fus) if m != len(fus) { t.Errorf(testname+" (fill 2): m == %d, expected %d\n", m, len(fus)) } if err != nil { t.Errorf(testname+" (fill 3): err should always be nil, found err == %s\n", err) } - s += fus; - check(t, testname+" (fill 4)", buf, s); + s += fus + check(t, testname+" (fill 4)", buf, s) } - return s; + return s } @@ -70,103 +70,103 @@ func fillString(t *testing.T, testname string, buf *Buffer, s string, n int, fus // The initial contents of buf corresponds to the string s; // the result is the final contents of buf returned as a string. func fillBytes(t *testing.T, testname string, buf *Buffer, s string, n int, fub []byte) string { - check(t, testname+" (fill 1)", buf, s); + check(t, testname+" (fill 1)", buf, s) for ; n > 0; n-- { - m, err := buf.Write(fub); + m, err := buf.Write(fub) if m != len(fub) { t.Errorf(testname+" (fill 2): m == %d, expected %d\n", m, len(fub)) } if err != nil { t.Errorf(testname+" (fill 3): err should always be nil, found err == %s\n", err) } - s += string(fub); - check(t, testname+" (fill 4)", buf, s); + s += string(fub) + check(t, testname+" (fill 4)", buf, s) } - return s; + return s } func TestNewBuffer(t *testing.T) { - buf := NewBuffer(bytes); - check(t, "NewBuffer", buf, data); + buf := NewBuffer(bytes) + check(t, "NewBuffer", buf, data) } func TestNewBufferString(t *testing.T) { - buf := NewBufferString(data); - check(t, "NewBufferString", buf, data); + buf := NewBufferString(data) + check(t, "NewBufferString", buf, data) } // Empty buf through repeated reads into fub. // The initial contents of buf corresponds to the string s. func empty(t *testing.T, testname string, buf *Buffer, s string, fub []byte) { - check(t, testname+" (empty 1)", buf, s); + check(t, testname+" (empty 1)", buf, s) for { - n, err := buf.Read(fub); + n, err := buf.Read(fub) if n == 0 { break } if err != nil { t.Errorf(testname+" (empty 2): err should always be nil, found err == %s\n", err) } - s = s[n:]; - check(t, testname+" (empty 3)", buf, s); + s = s[n:] + check(t, testname+" (empty 3)", buf, s) } - check(t, testname+" (empty 4)", buf, ""); + check(t, testname+" (empty 4)", buf, "") } func TestBasicOperations(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 0; i < 5; i++ { - check(t, "TestBasicOperations (1)", &buf, ""); + check(t, "TestBasicOperations (1)", &buf, "") - buf.Reset(); - check(t, "TestBasicOperations (2)", &buf, ""); + buf.Reset() + check(t, "TestBasicOperations (2)", &buf, "") - buf.Truncate(0); - check(t, "TestBasicOperations (3)", &buf, ""); + buf.Truncate(0) + check(t, "TestBasicOperations (3)", &buf, "") - n, err := buf.Write(Bytes(data[0:1])); + n, err := buf.Write(Bytes(data[0:1])) if n != 1 { t.Errorf("wrote 1 byte, but n == %d\n", n) } if err != nil { t.Errorf("err should always be nil, but err == %s\n", err) } - check(t, "TestBasicOperations (4)", &buf, "a"); + check(t, "TestBasicOperations (4)", &buf, "a") - buf.WriteByte(data[1]); - check(t, "TestBasicOperations (5)", &buf, "ab"); + buf.WriteByte(data[1]) + check(t, "TestBasicOperations (5)", &buf, "ab") - n, err = buf.Write(Bytes(data[2:26])); + n, err = buf.Write(Bytes(data[2:26])) if n != 24 { t.Errorf("wrote 25 bytes, but n == %d\n", n) } - check(t, "TestBasicOperations (6)", &buf, string(data[0:26])); + check(t, "TestBasicOperations (6)", &buf, string(data[0:26])) - buf.Truncate(26); - check(t, "TestBasicOperations (7)", &buf, string(data[0:26])); + buf.Truncate(26) + check(t, "TestBasicOperations (7)", &buf, string(data[0:26])) - buf.Truncate(20); - check(t, "TestBasicOperations (8)", &buf, string(data[0:20])); + buf.Truncate(20) + check(t, "TestBasicOperations (8)", &buf, string(data[0:20])) - empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5)); - empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100)); + empty(t, "TestBasicOperations (9)", &buf, string(data[0:20]), make([]byte, 5)) + empty(t, "TestBasicOperations (10)", &buf, "", make([]byte, 100)) - buf.WriteByte(data[1]); - c, err := buf.ReadByte(); + buf.WriteByte(data[1]) + c, err := buf.ReadByte() if err != nil { t.Errorf("ReadByte unexpected eof\n") } if c != data[1] { t.Errorf("ReadByte wrong value c=%v\n", c) } - c, err = buf.ReadByte(); + c, err = buf.ReadByte() if err == nil { t.Errorf("ReadByte unexpected not eof\n") } @@ -175,67 +175,67 @@ func TestBasicOperations(t *testing.T) { func TestLargeStringWrites(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, data); - empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(data)/i)); + s := fillString(t, "TestLargeWrites (1)", &buf, "", 5, data) + empty(t, "TestLargeStringWrites (2)", &buf, s, make([]byte, len(data)/i)) } - check(t, "TestLargeStringWrites (3)", &buf, ""); + check(t, "TestLargeStringWrites (3)", &buf, "") } func TestLargeByteWrites(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, bytes); - empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i)); + s := fillBytes(t, "TestLargeWrites (1)", &buf, "", 5, bytes) + empty(t, "TestLargeByteWrites (2)", &buf, s, make([]byte, len(data)/i)) } - check(t, "TestLargeByteWrites (3)", &buf, ""); + check(t, "TestLargeByteWrites (3)", &buf, "") } func TestLargeStringReads(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillString(t, "TestLargeReads (1)", &buf, "", 5, data[0:len(data)/i]); - empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data))); + s := fillString(t, "TestLargeReads (1)", &buf, "", 5, data[0:len(data)/i]) + empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data))) } - check(t, "TestLargeStringReads (3)", &buf, ""); + check(t, "TestLargeStringReads (3)", &buf, "") } func TestLargeByteReads(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, bytes[0:len(bytes)/i]); - empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data))); + s := fillBytes(t, "TestLargeReads (1)", &buf, "", 5, bytes[0:len(bytes)/i]) + empty(t, "TestLargeReads (2)", &buf, s, make([]byte, len(data))) } - check(t, "TestLargeByteReads (3)", &buf, ""); + check(t, "TestLargeByteReads (3)", &buf, "") } func TestMixedReadsAndWrites(t *testing.T) { - var buf Buffer; - s := ""; + var buf Buffer + s := "" for i := 0; i < 50; i++ { - wlen := rand.Intn(len(data)); + wlen := rand.Intn(len(data)) if i%2 == 0 { s = fillString(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, data[0:wlen]) } else { s = fillBytes(t, "TestMixedReadsAndWrites (1)", &buf, s, 1, bytes[0:wlen]) } - rlen := rand.Intn(len(data)); - fub := make([]byte, rlen); - n, _ := buf.Read(fub); - s = s[n:]; + rlen := rand.Intn(len(data)) + fub := make([]byte, rlen) + n, _ := buf.Read(fub) + s = s[n:] } - empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len())); + empty(t, "TestMixedReadsAndWrites (2)", &buf, s, make([]byte, buf.Len())) } func TestNil(t *testing.T) { - var b *Buffer; + var b *Buffer if b.String() != "<nil>" { t.Error("expcted <nil>; got %q", b.String()) } @@ -243,22 +243,22 @@ func TestNil(t *testing.T) { func TestReadFrom(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]); - var b Buffer; - b.ReadFrom(&buf); - empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data))); + s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]) + var b Buffer + b.ReadFrom(&buf) + empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data))) } } func TestWriteTo(t *testing.T) { - var buf Buffer; + var buf Buffer for i := 3; i < 30; i += 3 { - s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]); - var b Buffer; - buf.WriteTo(&b); - empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data))); + s := fillBytes(t, "TestReadFrom (1)", &buf, "", 5, bytes[0:len(bytes)/i]) + var b Buffer + buf.WriteTo(&b) + empty(t, "TestReadFrom (2)", &b, s, make([]byte, len(data))) } } diff --git a/src/pkg/bytes/bytes.go b/src/pkg/bytes/bytes.go index 85d4f9fd7..0a2146413 100644 --- a/src/pkg/bytes/bytes.go +++ b/src/pkg/bytes/bytes.go @@ -7,8 +7,8 @@ package bytes import ( - "unicode"; - "utf8"; + "unicode" + "utf8" ) // Compare returns an integer comparing the two byte arrays lexicographically. @@ -28,7 +28,7 @@ func Compare(a, b []byte) int { case len(a) > len(b): return 1 } - return 0; + return 0 } // Equal returns a boolean reporting whether a == b. @@ -41,7 +41,7 @@ func Equal(a, b []byte) bool { return false } } - return true; + return true } // explode splits s into an array of UTF-8 sequences, one per Unicode character (still arrays of bytes), @@ -50,21 +50,21 @@ func explode(s []byte, n int) [][]byte { if n <= 0 { n = len(s) } - a := make([][]byte, n); - var size int; - na := 0; + a := make([][]byte, n) + var size int + na := 0 for len(s) > 0 { if na+1 >= n { - a[na] = s; - na++; - break; + a[na] = s + na++ + break } - _, size = utf8.DecodeRune(s); - a[na] = s[0:size]; - s = s[size:]; - na++; + _, size = utf8.DecodeRune(s) + a[na] = s[0:size] + s = s[size:] + na++ } - return a[0:na]; + return a[0:na] } // Count counts the number of non-overlapping instances of sep in s. @@ -72,34 +72,34 @@ func Count(s, sep []byte) int { if len(sep) == 0 { return utf8.RuneCount(s) + 1 } - c := sep[0]; - n := 0; + c := sep[0] + n := 0 for i := 0; i+len(sep) <= len(s); i++ { if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) { - n++; - i += len(sep) - 1; + n++ + i += len(sep) - 1 } } - return n; + return n } // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s. func Index(s, sep []byte) int { - n := len(sep); + n := len(sep) if n == 0 { return 0 } - c := sep[0]; + c := sep[0] for i := 0; i+n <= len(s); i++ { if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) { return i } } - return -1; + return -1 } // IndexByte returns the index of the first instance of c in s, or -1 if c is not present in s. -func IndexByte(s []byte, c byte) int // asm_$GOARCH.s +func IndexByte(s []byte, c byte) int // asm_$GOARCH.s func indexBytePortable(s []byte, c byte) int { for i, b := range s { @@ -107,22 +107,22 @@ func indexBytePortable(s []byte, c byte) int { return i } } - return -1; + return -1 } // LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s. func LastIndex(s, sep []byte) int { - n := len(sep); + n := len(sep) if n == 0 { return len(s) } - c := sep[0]; + c := sep[0] for i := len(s) - n; i >= 0; i-- { if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) { return i } } - return -1; + return -1 } // Generic split: splits after each instance of sep, @@ -134,26 +134,26 @@ func genSplit(s, sep []byte, sepSave, n int) [][]byte { if n <= 0 { n = Count(s, sep) + 1 } - c := sep[0]; - start := 0; - a := make([][]byte, n); - na := 0; + c := sep[0] + start := 0 + a := make([][]byte, n) + na := 0 for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ { if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) { - a[na] = s[start : i+sepSave]; - na++; - start = i + len(sep); - i += len(sep) - 1; + a[na] = s[start : i+sepSave] + na++ + start = i + len(sep) + i += len(sep) - 1 } } - a[na] = s[start:]; - return a[0 : na+1]; + a[na] = s[start:] + return a[0 : na+1] } // Split splits the array s around each instance of sep, returning an array of subarrays of s. // If sep is empty, Split splits s after each UTF-8 sequence. // If n > 0, Split splits s into at most n subarrays; the last subarray will contain an unsplit remainder. -func Split(s, sep []byte, n int) [][]byte { return genSplit(s, sep, 0, n) } +func Split(s, sep []byte, n int) [][]byte { return genSplit(s, sep, 0, n) } // SplitAfter splits the array s after each instance of sep, returning an array of subarrays of s. // If sep is empty, SplitAfter splits s after each UTF-8 sequence. @@ -172,28 +172,28 @@ func Join(a [][]byte, sep []byte) []byte { if len(a) == 1 { return a[0] } - n := len(sep) * (len(a) - 1); + n := len(sep) * (len(a) - 1) for i := 0; i < len(a); i++ { n += len(a[i]) } - b := make([]byte, n); - bp := 0; + b := make([]byte, n) + bp := 0 for i := 0; i < len(a); i++ { - s := a[i]; + s := a[i] for j := 0; j < len(s); j++ { - b[bp] = s[j]; - bp++; + b[bp] = s[j] + bp++ } if i+1 < len(a) { - s = sep; + s = sep for j := 0; j < len(s); j++ { - b[bp] = s[j]; - bp++; + b[bp] = s[j] + bp++ } } } - return b; + return b } // HasPrefix tests whether the byte array s begins with prefix. @@ -213,88 +213,88 @@ func Map(mapping func(rune int) int, s []byte) []byte { // In the worst case, the array can grow when mapped, making // things unpleasant. But it's so rare we barge in assuming it's // fine. It could also shrink but that falls out naturally. - maxbytes := len(s); // length of b - nbytes := 0; // number of bytes encoded in b - b := make([]byte, maxbytes); + maxbytes := len(s) // length of b + nbytes := 0 // number of bytes encoded in b + b := make([]byte, maxbytes) for i := 0; i < len(s); { - wid := 1; - rune := int(s[i]); + wid := 1 + rune := int(s[i]) if rune >= utf8.RuneSelf { rune, wid = utf8.DecodeRune(s[i:]) } - rune = mapping(rune); + rune = mapping(rune) if rune >= 0 { if nbytes+utf8.RuneLen(rune) > maxbytes { // Grow the buffer. - maxbytes = maxbytes*2 + utf8.UTFMax; - nb := make([]byte, maxbytes); + maxbytes = maxbytes*2 + utf8.UTFMax + nb := make([]byte, maxbytes) for i, c := range b[0:nbytes] { nb[i] = c } - b = nb; + b = nb } - nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]); + nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]) } - i += wid; + i += wid } - return b[0:nbytes]; + return b[0:nbytes] } // Repeat returns a new byte array consisting of count copies of b. func Repeat(b []byte, count int) []byte { - nb := make([]byte, len(b)*count); - bp := 0; + nb := make([]byte, len(b)*count) + bp := 0 for i := 0; i < count; i++ { for j := 0; j < len(b); j++ { - nb[bp] = b[j]; - bp++; + nb[bp] = b[j] + bp++ } } - return nb; + return nb } // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their upper case. -func ToUpper(s []byte) []byte { return Map(unicode.ToUpper, s) } +func ToUpper(s []byte) []byte { return Map(unicode.ToUpper, s) } // ToUpper returns a copy of the byte array s with all Unicode letters mapped to their lower case. -func ToLower(s []byte) []byte { return Map(unicode.ToLower, s) } +func ToLower(s []byte) []byte { return Map(unicode.ToLower, s) } // ToTitle returns a copy of the byte array s with all Unicode letters mapped to their title case. -func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) } +func ToTitle(s []byte) []byte { return Map(unicode.ToTitle, s) } // Trim returns a slice of the string s, with all leading and trailing white space // removed, as defined by Unicode. func TrimSpace(s []byte) []byte { - start, end := 0, len(s); + start, end := 0, len(s) for start < end { - wid := 1; - rune := int(s[start]); + wid := 1 + rune := int(s[start]) if rune >= utf8.RuneSelf { rune, wid = utf8.DecodeRune(s[start:end]) } if !unicode.IsSpace(rune) { break } - start += wid; + start += wid } for start < end { - wid := 1; - rune := int(s[end-1]); + wid := 1 + rune := int(s[end-1]) if rune >= utf8.RuneSelf { // Back up carefully looking for beginning of rune. Mustn't pass start. for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ { } - if start > end-wid { // invalid UTF-8 sequence; stop processing + if start > end-wid { // invalid UTF-8 sequence; stop processing return s[start:end] } - rune, wid = utf8.DecodeRune(s[end-wid : end]); + rune, wid = utf8.DecodeRune(s[end-wid : end]) } if !unicode.IsSpace(rune) { break } - end -= wid; + end -= wid } - return s[start:end]; + return s[start:end] } // How big to make a byte array when growing. @@ -303,51 +303,51 @@ func resize(n int) int { if n < 16 { n = 16 } - return n + n/2; + return n + n/2 } // Add appends the contents of t to the end of s and returns the result. // If s has enough capacity, it is extended in place; otherwise a // new array is allocated and returned. func Add(s, t []byte) []byte { - lens := len(s); - lent := len(t); + lens := len(s) + lent := len(t) if lens+lent <= cap(s) { s = s[0 : lens+lent] } else { - news := make([]byte, lens+lent, resize(lens+lent)); - copy(news, s); - s = news; + news := make([]byte, lens+lent, resize(lens+lent)) + copy(news, s) + s = news } - copy(s[lens:lens+lent], t); - return s; + copy(s[lens:lens+lent], t) + return s } // AddByte appends byte b to the end of s and returns the result. // If s has enough capacity, it is extended in place; otherwise a // new array is allocated and returned. func AddByte(s []byte, t byte) []byte { - lens := len(s); + lens := len(s) if lens+1 <= cap(s) { s = s[0 : lens+1] } else { - news := make([]byte, lens+1, resize(lens+1)); - copy(news, s); - s = news; + news := make([]byte, lens+1, resize(lens+1)) + copy(news, s) + s = news } - s[lens] = t; - return s; + s[lens] = t + return s } // Runes returns a slice of runes (Unicode code points) equivalent to s. func Runes(s []byte) []int { - t := make([]int, utf8.RuneCount(s)); - i := 0; + t := make([]int, utf8.RuneCount(s)) + i := 0 for len(s) > 0 { - r, l := utf8.DecodeRune(s); - t[i] = r; - i++; - s = s[l:]; + r, l := utf8.DecodeRune(s) + t[i] = r + i++ + s = s[l:] } - return t; + return t } diff --git a/src/pkg/bytes/bytes_test.go b/src/pkg/bytes/bytes_test.go index 3f77e6e9f..4c6d4166a 100644 --- a/src/pkg/bytes/bytes_test.go +++ b/src/pkg/bytes/bytes_test.go @@ -5,10 +5,10 @@ package bytes_test import ( - . "bytes"; - "strings"; - "testing"; - "unicode"; + . "bytes" + "strings" + "testing" + "unicode" ) func eq(a, b []string) bool { @@ -20,15 +20,15 @@ func eq(a, b []string) bool { return false } } - return true; + return true } func arrayOfString(a [][]byte) []string { - result := make([]string, len(a)); + result := make([]string, len(a)) for j := 0; j < len(a); j++ { result[j] = string(a[j]) } - return result; + return result } // For ease of reading, the test cases use strings that are converted to byte @@ -40,9 +40,9 @@ var commas = "1,2,3,4" var dots = "1....2....3....4" type BinOpTest struct { - a string; - b string; - i int; + a string + b string + i int } var comparetests = []BinOpTest{ @@ -60,10 +60,10 @@ var comparetests = []BinOpTest{ func TestCompare(t *testing.T) { for _, tt := range comparetests { - a := strings.Bytes(tt.a); - b := strings.Bytes(tt.b); - cmp := Compare(a, b); - eql := Equal(a, b); + a := strings.Bytes(tt.a) + b := strings.Bytes(tt.b) + cmp := Compare(a, b) + eql := Equal(a, b) if cmp != tt.i { t.Errorf(`Compare(%q, %q) = %v`, tt.a, tt.b, cmp) } @@ -94,9 +94,9 @@ var indextests = []BinOpTest{ func TestIndex(t *testing.T) { for _, tt := range indextests { - a := strings.Bytes(tt.a); - b := strings.Bytes(tt.b); - pos := Index(a, b); + a := strings.Bytes(tt.a) + b := strings.Bytes(tt.b) + pos := Index(a, b) if pos != tt.i { t.Errorf(`Index(%q, %q) = %v`, tt.a, tt.b, pos) } @@ -108,24 +108,24 @@ func TestIndexByte(t *testing.T) { if len(tt.b) != 1 { continue } - a := strings.Bytes(tt.a); - b := tt.b[0]; - pos := IndexByte(a, b); + a := strings.Bytes(tt.a) + b := tt.b[0] + pos := IndexByte(a, b) if pos != tt.i { t.Errorf(`IndexByte(%q, '%c') = %v`, tt.a, b, pos) } - posp := IndexBytePortable(a, b); + posp := IndexBytePortable(a, b) if posp != tt.i { t.Errorf(`indexBytePortable(%q, '%c') = %v`, tt.a, b, posp) } } } -func BenchmarkIndexByte4K(b *testing.B) { bmIndex(b, IndexByte, 4<<10) } +func BenchmarkIndexByte4K(b *testing.B) { bmIndex(b, IndexByte, 4<<10) } -func BenchmarkIndexByte4M(b *testing.B) { bmIndex(b, IndexByte, 4<<20) } +func BenchmarkIndexByte4M(b *testing.B) { bmIndex(b, IndexByte, 4<<20) } -func BenchmarkIndexByte64M(b *testing.B) { bmIndex(b, IndexByte, 64<<20) } +func BenchmarkIndexByte64M(b *testing.B) { bmIndex(b, IndexByte, 64<<20) } func BenchmarkIndexBytePortable4K(b *testing.B) { bmIndex(b, IndexBytePortable, 4<<10) @@ -145,22 +145,22 @@ func bmIndex(b *testing.B, index func([]byte, byte) int, n int) { if len(bmbuf) < n { bmbuf = make([]byte, n) } - b.SetBytes(int64(n)); - buf := bmbuf[0:n]; - buf[n-1] = 'x'; + b.SetBytes(int64(n)) + buf := bmbuf[0:n] + buf[n-1] = 'x' for i := 0; i < b.N; i++ { - j := index(buf, 'x'); + j := index(buf, 'x') if j != n-1 { panic("bad index", j) } } - buf[n-1] = '0'; + buf[n-1] = '0' } type ExplodeTest struct { - s string; - n int; - a []string; + s string + n int + a []string } var explodetests = []ExplodeTest{ @@ -171,13 +171,13 @@ var explodetests = []ExplodeTest{ func TestExplode(t *testing.T) { for _, tt := range (explodetests) { - a := Split(strings.Bytes(tt.s), nil, tt.n); - result := arrayOfString(a); + a := Split(strings.Bytes(tt.s), nil, tt.n) + result := arrayOfString(a) if !eq(result, tt.a) { - t.Errorf(`Explode("%s", %d) = %v; want %v`, tt.s, tt.n, result, tt.a); - continue; + t.Errorf(`Explode("%s", %d) = %v; want %v`, tt.s, tt.n, result, tt.a) + continue } - s := Join(a, []byte{}); + s := Join(a, []byte{}) if string(s) != tt.s { t.Errorf(`Join(Explode("%s", %d), "") = "%s"`, tt.s, tt.n, s) } @@ -186,10 +186,10 @@ func TestExplode(t *testing.T) { type SplitTest struct { - s string; - sep string; - n int; - a []string; + s string + sep string + n int + a []string } var splittests = []SplitTest{ @@ -210,13 +210,13 @@ var splittests = []SplitTest{ func TestSplit(t *testing.T) { for _, tt := range splittests { - a := Split(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n); - result := arrayOfString(a); + a := Split(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n) + result := arrayOfString(a) if !eq(result, tt.a) { - t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a); - continue; + t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a) + continue } - s := Join(a, strings.Bytes(tt.sep)); + s := Join(a, strings.Bytes(tt.sep)) if string(s) != tt.s { t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s) } @@ -241,13 +241,13 @@ var splitaftertests = []SplitTest{ func TestSplitAfter(t *testing.T) { for _, tt := range splitaftertests { - a := SplitAfter(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n); - result := arrayOfString(a); + a := SplitAfter(strings.Bytes(tt.s), strings.Bytes(tt.sep), tt.n) + result := arrayOfString(a) if !eq(result, tt.a) { - t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a); - continue; + t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, result, tt.a) + continue } - s := Join(a, nil); + s := Join(a, nil) if string(s) != tt.s { t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s) } @@ -257,7 +257,7 @@ func TestSplitAfter(t *testing.T) { // Test case for any function which accepts and returns a byte array. // For ease of creation, we write the byte arrays as strings. type StringTest struct { - in, out string; + in, out string } var upperTests = []StringTest{ @@ -265,7 +265,7 @@ var upperTests = []StringTest{ StringTest{"abc", "ABC"}, StringTest{"AbC123", "ABC123"}, StringTest{"azAZ09_", "AZAZ09_"}, - StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"}, // grows one byte per char + StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"}, // grows one byte per char } var lowerTests = []StringTest{ @@ -273,7 +273,7 @@ var lowerTests = []StringTest{ StringTest{"abc", "abc"}, StringTest{"AbC123", "abc123"}, StringTest{"azAZ09_", "azaz09_"}, - StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"}, // shrinks one byte per char + StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"}, // shrinks one byte per char } const space = "\t\v\r\f\n\u0085\u00a0\u2000\u3000" @@ -287,25 +287,25 @@ var trimSpaceTests = []StringTest{ StringTest{" \t\r\n x\t\t\r\r\n\n ", "x"}, StringTest{" \u2000\t\r\n x\t\t\r\r\ny\n \u3000", "x\t\t\r\r\ny"}, StringTest{"1 \t\r\n2", "1 \t\r\n2"}, - StringTest{" x\x80", "x\x80"}, // invalid UTF-8 on end - StringTest{" x\xc0", "x\xc0"}, // invalid UTF-8 on end + StringTest{" x\x80", "x\x80"}, // invalid UTF-8 on end + StringTest{" x\xc0", "x\xc0"}, // invalid UTF-8 on end } // Bytes returns a new slice containing the bytes in s. // Borrowed from strings to avoid dependency. func Bytes(s string) []byte { - b := make([]byte, len(s)); + b := make([]byte, len(s)) for i := 0; i < len(s); i++ { b[i] = s[i] } - return b; + return b } // Execute f on each test case. funcName should be the name of f; it's used // in failure reports. func runStringTests(t *testing.T, f func([]byte) []byte, funcName string, testCases []StringTest) { for _, tc := range testCases { - actual := string(f(Bytes(tc.in))); + actual := string(f(Bytes(tc.in))) if actual != tc.out { t.Errorf("%s(%q) = %q; want %q", funcName, tc.in, actual, tc.out) } @@ -313,55 +313,55 @@ func runStringTests(t *testing.T, f func([]byte) []byte, funcName string, testCa } func tenRunes(rune int) string { - r := make([]int, 10); + r := make([]int, 10) for i := range r { r[i] = rune } - return string(r); + return string(r) } // User-defined self-inverse mapping function func rot13(rune int) int { - step := 13; + step := 13 if rune >= 'a' && rune <= 'z' { return ((rune - 'a' + step) % 26) + 'a' } if rune >= 'A' && rune <= 'Z' { return ((rune - 'A' + step) % 26) + 'A' } - return rune; + return rune } func TestMap(t *testing.T) { // Run a couple of awful growth/shrinkage tests - a := tenRunes('a'); + a := tenRunes('a') // 1. Grow. This triggers two reallocations in Map. - maxRune := func(rune int) int { return unicode.MaxRune }; - m := Map(maxRune, Bytes(a)); - expect := tenRunes(unicode.MaxRune); + maxRune := func(rune int) int { return unicode.MaxRune } + m := Map(maxRune, Bytes(a)) + expect := tenRunes(unicode.MaxRune) if string(m) != expect { t.Errorf("growing: expected %q got %q", expect, m) } // 2. Shrink - minRune := func(rune int) int { return 'a' }; - m = Map(minRune, Bytes(tenRunes(unicode.MaxRune))); - expect = a; + minRune := func(rune int) int { return 'a' } + m = Map(minRune, Bytes(tenRunes(unicode.MaxRune))) + expect = a if string(m) != expect { t.Errorf("shrinking: expected %q got %q", expect, m) } // 3. Rot13 - m = Map(rot13, Bytes("a to zed")); - expect = "n gb mrq"; + m = Map(rot13, Bytes("a to zed")) + expect = "n gb mrq" if string(m) != expect { t.Errorf("rot13: expected %q got %q", expect, m) } // 4. Rot13^2 - m = Map(rot13, Map(rot13, Bytes("a to zed"))); - expect = "a to zed"; + m = Map(rot13, Map(rot13, Bytes("a to zed"))) + expect = "a to zed" if string(m) != expect { t.Errorf("rot13: expected %q got %q", expect, m) } @@ -371,24 +371,24 @@ func TestMap(t *testing.T) { if unicode.Is(unicode.Latin, rune) { return rune } - return -1; - }; - m = Map(dropNotLatin, Bytes("Hello, 세계")); - expect = "Hello"; + return -1 + } + m = Map(dropNotLatin, Bytes("Hello, 세계")) + expect = "Hello" if string(m) != expect { t.Errorf("drop: expected %q got %q", expect, m) } } -func TestToUpper(t *testing.T) { runStringTests(t, ToUpper, "ToUpper", upperTests) } +func TestToUpper(t *testing.T) { runStringTests(t, ToUpper, "ToUpper", upperTests) } -func TestToLower(t *testing.T) { runStringTests(t, ToLower, "ToLower", lowerTests) } +func TestToLower(t *testing.T) { runStringTests(t, ToLower, "ToLower", lowerTests) } -func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) } +func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) } type AddTest struct { - s, t string; - cap int; + s, t string + cap int } var addtests = []AddTest{ @@ -400,11 +400,11 @@ var addtests = []AddTest{ func TestAdd(t *testing.T) { for _, test := range addtests { - b := make([]byte, len(test.s), test.cap); + b := make([]byte, len(test.s), test.cap) for i := 0; i < len(test.s); i++ { b[i] = test.s[i] } - b = Add(b, strings.Bytes(test.t)); + b = Add(b, strings.Bytes(test.t)) if string(b) != test.s+test.t { t.Errorf("Add(%q,%q) = %q", test.s, test.t, string(b)) } @@ -412,8 +412,8 @@ func TestAdd(t *testing.T) { } func TestAddByte(t *testing.T) { - const N = 2e5; - b := make([]byte, 0); + const N = 2e5 + b := make([]byte, 0) for i := 0; i < N; i++ { b = AddByte(b, byte(i)) } @@ -428,8 +428,8 @@ func TestAddByte(t *testing.T) { } type RepeatTest struct { - in, out string; - count int; + in, out string + count int } var RepeatTests = []RepeatTest{ @@ -444,12 +444,12 @@ var RepeatTests = []RepeatTest{ func TestRepeat(t *testing.T) { for _, tt := range RepeatTests { - tin := strings.Bytes(tt.in); - tout := strings.Bytes(tt.out); - a := Repeat(tin, tt.count); + tin := strings.Bytes(tt.in) + tout := strings.Bytes(tt.out) + a := Repeat(tin, tt.count) if !Equal(a, tout) { - t.Errorf("Repeat(%q, %d) = %q; want %q", tin, tt.count, a, tout); - continue; + t.Errorf("Repeat(%q, %d) = %q; want %q", tin, tt.count, a, tout) + continue } } } @@ -463,13 +463,13 @@ func runesEqual(a, b []int) bool { return false } } - return true; + return true } type RunesTest struct { - in string; - out []int; - lossy bool; + in string + out []int + lossy bool } var RunesTests = []RunesTest{ @@ -484,15 +484,15 @@ var RunesTests = []RunesTest{ func TestRunes(t *testing.T) { for _, tt := range RunesTests { - tin := strings.Bytes(tt.in); - a := Runes(tin); + tin := strings.Bytes(tt.in) + a := Runes(tin) if !runesEqual(a, tt.out) { - t.Errorf("Runes(%q) = %v; want %v", tin, a, tt.out); - continue; + t.Errorf("Runes(%q) = %v; want %v", tin, a, tt.out) + continue } if !tt.lossy { // can only test reassembly if we didn't lose information - s := string(a); + s := string(a) if s != tt.in { t.Errorf("string(Runes(%q)) = %x; want %x", tin, s, tin) } diff --git a/src/pkg/compress/flate/deflate.go b/src/pkg/compress/flate/deflate.go index d07e46525..18bb353d2 100644 --- a/src/pkg/compress/flate/deflate.go +++ b/src/pkg/compress/flate/deflate.go @@ -5,55 +5,55 @@ package flate import ( - "io"; - "math"; - "os"; + "io" + "math" + "os" ) const ( - NoCompression = 0; - BestSpeed = 1; - fastCompression = 3; - BestCompression = 9; - DefaultCompression = -1; - logMaxOffsetSize = 15; // Standard DEFLATE - wideLogMaxOffsetSize = 22; // Wide DEFLATE - minMatchLength = 3; // The smallest match that the deflater looks for - maxMatchLength = 258; // The longest match for the deflater - minOffsetSize = 1; // The shortest offset that makes any sence + NoCompression = 0 + BestSpeed = 1 + fastCompression = 3 + BestCompression = 9 + DefaultCompression = -1 + logMaxOffsetSize = 15 // Standard DEFLATE + wideLogMaxOffsetSize = 22 // Wide DEFLATE + minMatchLength = 3 // The smallest match that the deflater looks for + maxMatchLength = 258 // The longest match for the deflater + minOffsetSize = 1 // The shortest offset that makes any sence // The maximum number of tokens we put into a single flat block, just too // stop things from getting too large. - maxFlateBlockTokens = 1 << 14; - maxStoreBlockSize = 65535; - hashBits = 15; - hashSize = 1 << hashBits; - hashMask = (1 << hashBits) - 1; - hashShift = (hashBits + minMatchLength - 1) / minMatchLength; + maxFlateBlockTokens = 1 << 14 + maxStoreBlockSize = 65535 + hashBits = 15 + hashSize = 1 << hashBits + hashMask = (1 << hashBits) - 1 + hashShift = (hashBits + minMatchLength - 1) / minMatchLength ) type syncPipeReader struct { - *io.PipeReader; - closeChan chan bool; + *io.PipeReader + closeChan chan bool } func (sr *syncPipeReader) CloseWithError(err os.Error) os.Error { - retErr := sr.PipeReader.CloseWithError(err); - sr.closeChan <- true; // finish writer close - return retErr; + retErr := sr.PipeReader.CloseWithError(err) + sr.closeChan <- true // finish writer close + return retErr } type syncPipeWriter struct { - *io.PipeWriter; - closeChan chan bool; + *io.PipeWriter + closeChan chan bool } type compressionLevel struct { - good, lazy, nice, chain, fastSkipHashing int; + good, lazy, nice, chain, fastSkipHashing int } var levels = []compressionLevel{ - compressionLevel{}, // 0 + compressionLevel{}, // 0 // For levels 1-3 we don't bother trying with lazy matches compressionLevel{3, 0, 8, 4, 4}, compressionLevel{3, 0, 16, 8, 5}, @@ -69,67 +69,67 @@ var levels = []compressionLevel{ } func (sw *syncPipeWriter) Close() os.Error { - err := sw.PipeWriter.Close(); - <-sw.closeChan; // wait for reader close - return err; + err := sw.PipeWriter.Close() + <-sw.closeChan // wait for reader close + return err } func syncPipe() (*syncPipeReader, *syncPipeWriter) { - r, w := io.Pipe(); - sr := &syncPipeReader{r, make(chan bool, 1)}; - sw := &syncPipeWriter{w, sr.closeChan}; - return sr, sw; + r, w := io.Pipe() + sr := &syncPipeReader{r, make(chan bool, 1)} + sw := &syncPipeWriter{w, sr.closeChan} + return sr, sw } type deflater struct { - level int; - logWindowSize uint; - w *huffmanBitWriter; - r io.Reader; + level int + logWindowSize uint + w *huffmanBitWriter + r io.Reader // (1 << logWindowSize) - 1. - windowMask int; + windowMask int // hashHead[hashValue] contains the largest inputIndex with the specified hash value - hashHead []int; + hashHead []int // If hashHead[hashValue] is within the current window, then // hashPrev[hashHead[hashValue] & windowMask] contains the previous index // with the same hash value. - hashPrev []int; + hashPrev []int // If we find a match of length >= niceMatch, then we don't bother searching // any further. - niceMatch int; + niceMatch int // If we find a match of length >= goodMatch, we only do a half-hearted // effort at doing lazy matching starting at the next character - goodMatch int; + goodMatch int // The maximum number of chains we look at when finding a match - maxChainLength int; + maxChainLength int // The sliding window we use for matching - window []byte; + window []byte // The index just past the last valid character - windowEnd int; + windowEnd int // index in "window" at which current block starts - blockStart int; + blockStart int } func (d *deflater) flush() os.Error { - d.w.flush(); - return d.w.err; + d.w.flush() + return d.w.err } func (d *deflater) fillWindow(index int) (int, os.Error) { - wSize := d.windowMask + 1; + wSize := d.windowMask + 1 if index >= wSize+wSize-(minMatchLength+maxMatchLength) { // shift the window by wSize - copy(d.window, d.window[wSize:2*wSize]); - index -= wSize; - d.windowEnd -= wSize; + copy(d.window, d.window[wSize:2*wSize]) + index -= wSize + d.windowEnd -= wSize if d.blockStart >= wSize { d.blockStart -= wSize } else { @@ -142,66 +142,66 @@ func (d *deflater) fillWindow(index int) (int, os.Error) { d.hashPrev[i] = max(h-wSize, -1) } } - var count int; - var err os.Error; - count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1); - d.windowEnd += count; + var count int + var err os.Error + count, err = io.ReadAtLeast(d.r, d.window[d.windowEnd:], 1) + d.windowEnd += count if err == os.EOF { return index, nil } - return index, err; + return index, err } func (d *deflater) writeBlock(tokens []token, index int, eof bool) os.Error { if index > 0 || eof { - var window []byte; + var window []byte if d.blockStart <= index { window = d.window[d.blockStart:index] } - d.blockStart = index; - d.w.writeBlock(tokens, eof, window); - return d.w.err; + d.blockStart = index + d.w.writeBlock(tokens, eof, window) + return d.w.err } - return nil; + return nil } // Try to find a match starting at index whose length is greater than prevSize. // We only look at chainCount possibilities before giving up. func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead int) (length, offset int, ok bool) { - win := d.window[0 : pos+min(maxMatchLength, lookahead)]; + win := d.window[0 : pos+min(maxMatchLength, lookahead)] // We quit when we get a match that's at least nice long - nice := min(d.niceMatch, len(win)-pos); + nice := min(d.niceMatch, len(win)-pos) // If we've got a match that's good enough, only look in 1/4 the chain. - tries := d.maxChainLength; - length = prevLength; + tries := d.maxChainLength + length = prevLength if length >= d.goodMatch { tries >>= 2 } - w0 := win[pos]; - w1 := win[pos+1]; - wEnd := win[pos+length]; - minIndex := pos - (d.windowMask + 1); + w0 := win[pos] + w1 := win[pos+1] + wEnd := win[pos+length] + minIndex := pos - (d.windowMask + 1) for i := prevHead; tries > 0; tries-- { if w0 == win[i] && w1 == win[i+1] && wEnd == win[i+length] { // The hash function ensures that if win[i] and win[i+1] match, win[i+2] matches - n := 3; + n := 3 for pos+n < len(win) && win[i+n] == win[pos+n] { n++ } if n > length && (n > 3 || pos-i <= 4096) { - length = n; - offset = pos - i; - ok = true; + length = n + offset = pos - i + ok = true if n >= nice { // The match is good enough that we don't try to find a better one. break } - wEnd = win[pos+n]; + wEnd = win[pos+n] } } if i == minIndex { @@ -212,21 +212,21 @@ func (d *deflater) findMatch(pos int, prevHead int, prevLength int, lookahead in break } } - return; + return } func (d *deflater) writeStoredBlock(buf []byte) os.Error { if d.w.writeStoredHeader(len(buf), false); d.w.err != nil { return d.w.err } - d.w.writeBytes(buf); - return d.w.err; + d.w.writeBytes(buf) + return d.w.err } func (d *deflater) storedDeflate() os.Error { - buf := make([]byte, maxStoreBlockSize); + buf := make([]byte, maxStoreBlockSize) for { - n, err := d.r.Read(buf); + n, err := d.r.Read(buf) if n > 0 { if err := d.writeStoredBlock(buf[0:n]); err != nil { return err @@ -236,83 +236,83 @@ func (d *deflater) storedDeflate() os.Error { if err == os.EOF { break } - return err; + return err } } - return nil; + return nil } func (d *deflater) doDeflate() (err os.Error) { // init - d.windowMask = 1<<d.logWindowSize - 1; - d.hashHead = make([]int, hashSize); - d.hashPrev = make([]int, 1<<d.logWindowSize); - d.window = make([]byte, 2<<d.logWindowSize); - fillInts(d.hashHead, -1); - tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1); - l := levels[d.level]; - d.goodMatch = l.good; - d.niceMatch = l.nice; - d.maxChainLength = l.chain; - lazyMatch := l.lazy; - length := minMatchLength - 1; - offset := 0; - byteAvailable := false; - isFastDeflate := l.fastSkipHashing != 0; - index := 0; + d.windowMask = 1<<d.logWindowSize - 1 + d.hashHead = make([]int, hashSize) + d.hashPrev = make([]int, 1<<d.logWindowSize) + d.window = make([]byte, 2<<d.logWindowSize) + fillInts(d.hashHead, -1) + tokens := make([]token, maxFlateBlockTokens, maxFlateBlockTokens+1) + l := levels[d.level] + d.goodMatch = l.good + d.niceMatch = l.nice + d.maxChainLength = l.chain + lazyMatch := l.lazy + length := minMatchLength - 1 + offset := 0 + byteAvailable := false + isFastDeflate := l.fastSkipHashing != 0 + index := 0 // run if index, err = d.fillWindow(index); err != nil { return } - maxOffset := d.windowMask + 1; // (1 << logWindowSize); + maxOffset := d.windowMask + 1 // (1 << logWindowSize); // only need to change when you refill the window - windowEnd := d.windowEnd; - maxInsertIndex := windowEnd - (minMatchLength - 1); - ti := 0; + windowEnd := d.windowEnd + maxInsertIndex := windowEnd - (minMatchLength - 1) + ti := 0 - hash := int(0); + hash := int(0) if index < maxInsertIndex { hash = int(d.window[index])<<hashShift + int(d.window[index+1]) } - chainHead := -1; + chainHead := -1 for { if index > windowEnd { panic("index > windowEnd") } - lookahead := windowEnd - index; + lookahead := windowEnd - index if lookahead < minMatchLength+maxMatchLength { if index, err = d.fillWindow(index); err != nil { return } - windowEnd = d.windowEnd; + windowEnd = d.windowEnd if index > windowEnd { panic("index > windowEnd") } - maxInsertIndex = windowEnd - (minMatchLength - 1); - lookahead = windowEnd - index; + maxInsertIndex = windowEnd - (minMatchLength - 1) + lookahead = windowEnd - index if lookahead == 0 { break } } if index < maxInsertIndex { // Update the hash - hash = (hash<<hashShift + int(d.window[index+2])) & hashMask; - chainHead = d.hashHead[hash]; - d.hashPrev[index&d.windowMask] = chainHead; - d.hashHead[hash] = index; + hash = (hash<<hashShift + int(d.window[index+2])) & hashMask + chainHead = d.hashHead[hash] + d.hashPrev[index&d.windowMask] = chainHead + d.hashHead[hash] = index } - prevLength := length; - prevOffset := offset; - minIndex := max(index-maxOffset, 0); - length = minMatchLength - 1; - offset = 0; + prevLength := length + prevOffset := offset + minIndex := max(index-maxOffset, 0) + length = minMatchLength - 1 + offset = 0 if chainHead >= minIndex && (isFastDeflate && lookahead > minMatchLength-1 || !isFastDeflate && lookahead > prevLength && prevLength < lazyMatch) { if newLength, newOffset, ok := d.findMatch(index, chainHead, minMatchLength-1, lookahead); ok { - length = newLength; - offset = newOffset; + length = newLength + offset = newOffset } } if isFastDeflate && length >= minMatchLength || @@ -324,13 +324,13 @@ func (d *deflater) doDeflate() (err os.Error) { } else { tokens[ti] = matchToken(uint32(prevLength-minMatchLength), uint32(prevOffset-minOffsetSize)) } - ti++; + ti++ // Insert in the hash table all strings up to the end of the match. // index and index-1 are already inserted. If there is not enough // lookahead, the last two strings are not inserted into the hash // table. if length <= l.fastSkipHashing { - var newIndex int; + var newIndex int if isFastDeflate { newIndex = index + length } else { @@ -338,47 +338,47 @@ func (d *deflater) doDeflate() (err os.Error) { } for index++; index < newIndex; index++ { if index < maxInsertIndex { - hash = (hash<<hashShift + int(d.window[index+2])) & hashMask; + hash = (hash<<hashShift + int(d.window[index+2])) & hashMask // Get previous value with the same hash. // Our chain should point to the previous value. - d.hashPrev[index&d.windowMask] = d.hashHead[hash]; + d.hashPrev[index&d.windowMask] = d.hashHead[hash] // Set the head of the hash chain to us. - d.hashHead[hash] = index; + d.hashHead[hash] = index } } if !isFastDeflate { - byteAvailable = false; - length = minMatchLength - 1; + byteAvailable = false + length = minMatchLength - 1 } } else { // For matches this long, we don't bother inserting each individual // item into the table. - index += length; - hash = (int(d.window[index])<<hashShift + int(d.window[index+1])); + index += length + hash = (int(d.window[index])<<hashShift + int(d.window[index+1])) } if ti == maxFlateBlockTokens { // The block includes the current character if err = d.writeBlock(tokens, index, false); err != nil { return } - ti = 0; + ti = 0 } } else { if isFastDeflate || byteAvailable { - i := index - 1; + i := index - 1 if isFastDeflate { i = index } - tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF); - ti++; + tokens[ti] = literalToken(uint32(d.window[i]) & 0xFF) + ti++ if ti == maxFlateBlockTokens { if err = d.writeBlock(tokens, i+1, false); err != nil { return } - ti = 0; + ti = 0 } } - index++; + index++ if !isFastDeflate { byteAvailable = true } @@ -387,8 +387,8 @@ func (d *deflater) doDeflate() (err os.Error) { } if byteAvailable { // There is still one pending token that needs to be flushed - tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF); - ti++; + tokens[ti] = literalToken(uint32(d.window[index-1]) & 0xFF) + ti++ } if ti > 0 { @@ -396,21 +396,21 @@ func (d *deflater) doDeflate() (err os.Error) { return } } - return; + return } func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize uint) (err os.Error) { - d.r = r; - d.w = newHuffmanBitWriter(w); - d.level = level; - d.logWindowSize = logWindowSize; + d.r = r + d.w = newHuffmanBitWriter(w) + d.level = level + d.logWindowSize = logWindowSize switch { case level == NoCompression: err = d.storedDeflate() case level == DefaultCompression: - d.level = 6; - fallthrough; + d.level = 6 + fallthrough case 1 <= level && level <= 9: err = d.doDeflate() default: @@ -423,17 +423,17 @@ func (d *deflater) deflater(r io.Reader, w io.Writer, level int, logWindowSize u if d.w.writeStoredHeader(0, true); d.w.err != nil { return d.w.err } - return d.flush(); + return d.flush() } func newDeflater(w io.Writer, level int, logWindowSize uint) io.WriteCloser { - var d deflater; - pr, pw := syncPipe(); + var d deflater + pr, pw := syncPipe() go func() { - err := d.deflater(pr, w, level, logWindowSize); - pr.CloseWithError(err); - }(); - return pw; + err := d.deflater(pr, w, level, logWindowSize) + pr.CloseWithError(err) + }() + return pw } func NewDeflater(w io.Writer, level int) io.WriteCloser { diff --git a/src/pkg/compress/flate/deflate_test.go b/src/pkg/compress/flate/deflate_test.go index 9d5ada994..1ac8059b3 100644 --- a/src/pkg/compress/flate/deflate_test.go +++ b/src/pkg/compress/flate/deflate_test.go @@ -5,27 +5,27 @@ package flate import ( - "bytes"; - "fmt"; - "io/ioutil"; - "os"; - "testing"; + "bytes" + "fmt" + "io/ioutil" + "os" + "testing" ) type deflateTest struct { - in []byte; - level int; - out []byte; + in []byte + level int + out []byte } type deflateInflateTest struct { - in []byte; + in []byte } type reverseBitsTest struct { - in uint16; - bitCount uint8; - out uint16; + in uint16 + bitCount uint8 + out uint16 } var deflateTests = []*deflateTest{ @@ -70,19 +70,19 @@ var reverseBitsTests = []*reverseBitsTest{ } func getLargeDataChunk() []byte { - result := make([]byte, 100000); + result := make([]byte, 100000) for i := range result { result[i] = byte(int64(i) * int64(i) & 0xFF) } - return result; + return result } func TestDeflate(t *testing.T) { for _, h := range deflateTests { - buffer := bytes.NewBuffer([]byte{}); - w := NewDeflater(buffer, h.level); - w.Write(h.in); - w.Close(); + buffer := bytes.NewBuffer([]byte{}) + w := NewDeflater(buffer, h.level) + w.Write(h.in) + w.Close() if bytes.Compare(buffer.Bytes(), h.out) != 0 { t.Errorf("buffer is wrong; level = %v, buffer.Bytes() = %v, expected output = %v", h.level, buffer.Bytes(), h.out) @@ -91,21 +91,21 @@ func TestDeflate(t *testing.T) { } func testToFromWithLevel(t *testing.T, level int, input []byte, name string) os.Error { - buffer := bytes.NewBuffer([]byte{}); - w := NewDeflater(buffer, level); - w.Write(input); - w.Close(); - inflater := NewInflater(buffer); - decompressed, err := ioutil.ReadAll(inflater); + buffer := bytes.NewBuffer([]byte{}) + w := NewDeflater(buffer, level) + w.Write(input) + w.Close() + inflater := NewInflater(buffer) + decompressed, err := ioutil.ReadAll(inflater) if err != nil { - t.Errorf("reading inflater: %s", err); - return err; + t.Errorf("reading inflater: %s", err) + return err } - inflater.Close(); + inflater.Close() if bytes.Compare(input, decompressed) != 0 { t.Errorf("decompress(compress(data)) != data: level=%d input=%s", level, name) } - return nil; + return nil } func testToFrom(t *testing.T, input []byte, name string) { @@ -130,8 +130,8 @@ func TestReverseBits(t *testing.T) { } func TestDeflateInflateString(t *testing.T) { - gold := bytes.NewBufferString(getEdata()).Bytes(); - testToFromWithLevel(t, 1, gold, "2.718281828..."); + gold := bytes.NewBufferString(getEdata()).Bytes() + testToFromWithLevel(t, 1, gold, "2.718281828...") } func getEdata() string { diff --git a/src/pkg/compress/flate/flate_test.go b/src/pkg/compress/flate/flate_test.go index e2a97b368..d7a9a3d24 100644 --- a/src/pkg/compress/flate/flate_test.go +++ b/src/pkg/compress/flate/flate_test.go @@ -9,9 +9,9 @@ package flate import ( - "bytes"; - "reflect"; - "testing"; + "bytes" + "reflect" + "testing" ) // The Huffman code lengths used by the fixed-format Huffman blocks. @@ -45,9 +45,9 @@ var fixedHuffmanBits = [...]int{ } type InitDecoderTest struct { - in []int; - out huffmanDecoder; - ok bool; + in []int + out huffmanDecoder + ok bool } var initDecoderTests = []*InitDecoderTest{ @@ -115,10 +115,10 @@ var initDecoderTests = []*InitDecoderTest{ func TestInitDecoder(t *testing.T) { for i, tt := range initDecoderTests { - var h huffmanDecoder; + var h huffmanDecoder if h.init(tt.in) != tt.ok { - t.Errorf("test %d: init = %v", i, !tt.ok); - continue; + t.Errorf("test %d: init = %v", i, !tt.ok) + continue } if !reflect.DeepEqual(&h, &tt.out) { t.Errorf("test %d:\nhave %v\nwant %v", i, h, tt.out) @@ -127,9 +127,9 @@ func TestInitDecoder(t *testing.T) { } func TestUncompressedSource(t *testing.T) { - decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11})); - output := make([]byte, 1); - n, error := decoder.Read(output); + decoder := NewInflater(bytes.NewBuffer([]byte{0x01, 0x01, 0x00, 0xfe, 0xff, 0x11})) + output := make([]byte, 1) + n, error := decoder.Read(output) if n != 1 || error != nil { t.Fatalf("decoder.Read() = %d, %v, want 1, nil", n, error) } diff --git a/src/pkg/compress/flate/huffman_bit_writer.go b/src/pkg/compress/flate/huffman_bit_writer.go index a1ef3694c..eac196dfc 100644 --- a/src/pkg/compress/flate/huffman_bit_writer.go +++ b/src/pkg/compress/flate/huffman_bit_writer.go @@ -5,28 +5,28 @@ package flate import ( - "io"; - "math"; - "os"; - "strconv"; + "io" + "math" + "os" + "strconv" ) const ( // The largest offset code. - offsetCodeCount = 30; + offsetCodeCount = 30 // The largest offset code in the extensions. - extendedOffsetCodeCount = 42; + extendedOffsetCodeCount = 42 // The special code used to mark the end of a block. - endBlockMarker = 256; + endBlockMarker = 256 // The first length code. - lengthCodesStart = 257; + lengthCodesStart = 257 // The number of codegen codes. - codegenCodeCount = 19; - badCode = 255; + codegenCodeCount = 19 + badCode = 255 ) // The number of extra bits needed by length code X - LENGTH_CODES_START. @@ -72,28 +72,28 @@ var offsetBase = []uint32{ var codegenOrder = []uint32{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15} type huffmanBitWriter struct { - w io.Writer; + w io.Writer // Data waiting to be written is bytes[0:nbytes] // and then the low nbits of bits. - bits uint32; - nbits uint32; - bytes [64]byte; - nbytes int; - literalFreq []int32; - offsetFreq []int32; - codegen []uint8; - codegenFreq []int32; - literalEncoding *huffmanEncoder; - offsetEncoding *huffmanEncoder; - codegenEncoding *huffmanEncoder; - err os.Error; + bits uint32 + nbits uint32 + bytes [64]byte + nbytes int + literalFreq []int32 + offsetFreq []int32 + codegen []uint8 + codegenFreq []int32 + literalEncoding *huffmanEncoder + offsetEncoding *huffmanEncoder + codegenEncoding *huffmanEncoder + err os.Error } type WrongValueError struct { - name string; - from int32; - to int32; - value int32; + name string + from int32 + to int32 + value int32 } func newHuffmanBitWriter(w io.Writer) *huffmanBitWriter { @@ -116,46 +116,46 @@ func (err WrongValueError) String() string { func (w *huffmanBitWriter) flushBits() { if w.err != nil { - w.nbits = 0; - return; - } - bits := w.bits; - w.bits >>= 16; - w.nbits -= 16; - n := w.nbytes; - w.bytes[n] = byte(bits); - w.bytes[n+1] = byte(bits >> 8); + w.nbits = 0 + return + } + bits := w.bits + w.bits >>= 16 + w.nbits -= 16 + n := w.nbytes + w.bytes[n] = byte(bits) + w.bytes[n+1] = byte(bits >> 8) if n += 2; n >= len(w.bytes) { - _, w.err = w.w.Write(&w.bytes); - n = 0; + _, w.err = w.w.Write(&w.bytes) + n = 0 } - w.nbytes = n; + w.nbytes = n } func (w *huffmanBitWriter) flush() { if w.err != nil { - w.nbits = 0; - return; + w.nbits = 0 + return } - n := w.nbytes; + n := w.nbytes if w.nbits > 8 { - w.bytes[n] = byte(w.bits); - w.bits >>= 8; - w.nbits -= 8; - n++; + w.bytes[n] = byte(w.bits) + w.bits >>= 8 + w.nbits -= 8 + n++ } if w.nbits > 0 { - w.bytes[n] = byte(w.bits); - w.nbits = 0; - n++; + w.bytes[n] = byte(w.bits) + w.nbits = 0 + n++ } - w.bits = 0; - _, w.err = w.w.Write(w.bytes[0:n]); - w.nbytes = 0; + w.bits = 0 + _, w.err = w.w.Write(w.bytes[0:n]) + w.nbytes = 0 } func (w *huffmanBitWriter) writeBits(b, nb int32) { - w.bits |= uint32(b) << w.nbits; + w.bits |= uint32(b) << w.nbits if w.nbits += uint32(nb); w.nbits >= 16 { w.flushBits() } @@ -165,24 +165,24 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) { if w.err != nil { return } - n := w.nbytes; + n := w.nbytes if w.nbits == 8 { - w.bytes[n] = byte(w.bits); - w.nbits = 0; - n++; + w.bytes[n] = byte(w.bits) + w.nbits = 0 + n++ } if w.nbits != 0 { - w.err = InternalError("writeBytes with unfinished bits"); - return; + w.err = InternalError("writeBytes with unfinished bits") + return } if n != 0 { - _, w.err = w.w.Write(w.bytes[0:n]); + _, w.err = w.w.Write(w.bytes[0:n]) if w.err != nil { return } } - w.nbytes = 0; - _, w.err = w.w.Write(bytes); + w.nbytes = 0 + _, w.err = w.w.Write(bytes) } // RFC 1951 3.2.7 specifies a special run-length encoding for specifiying @@ -197,82 +197,82 @@ func (w *huffmanBitWriter) writeBytes(bytes []byte) { // numLiterals The number of literals in literalEncoding // numOffsets The number of offsets in offsetEncoding func (w *huffmanBitWriter) generateCodegen(numLiterals int, numOffsets int) { - fillInt32s(w.codegenFreq, 0); + fillInt32s(w.codegenFreq, 0) // Note that we are using codegen both as a temporary variable for holding // a copy of the frequencies, and as the place where we put the result. // This is fine because the output is always shorter than the input used // so far. - codegen := w.codegen; // cache + codegen := w.codegen // cache // Copy the concatenated code sizes to codegen. Put a marker at the end. - copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits); - copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits); - codegen[numLiterals+numOffsets] = badCode; + copyUint8s(codegen[0:numLiterals], w.literalEncoding.codeBits) + copyUint8s(codegen[numLiterals:numLiterals+numOffsets], w.offsetEncoding.codeBits) + codegen[numLiterals+numOffsets] = badCode - size := codegen[0]; - count := 1; - outIndex := 0; + size := codegen[0] + count := 1 + outIndex := 0 for inIndex := 1; size != badCode; inIndex++ { // INVARIANT: We have seen "count" copies of size that have not yet // had output generated for them. - nextSize := codegen[inIndex]; + nextSize := codegen[inIndex] if nextSize == size { - count++; - continue; + count++ + continue } // We need to generate codegen indicating "count" of size. if size != 0 { - codegen[outIndex] = size; - outIndex++; - w.codegenFreq[size]++; - count--; + codegen[outIndex] = size + outIndex++ + w.codegenFreq[size]++ + count-- for count >= 3 { - n := min(count, 6); - codegen[outIndex] = 16; - outIndex++; - codegen[outIndex] = uint8(n - 3); - outIndex++; - w.codegenFreq[16]++; - count -= n; + n := min(count, 6) + codegen[outIndex] = 16 + outIndex++ + codegen[outIndex] = uint8(n - 3) + outIndex++ + w.codegenFreq[16]++ + count -= n } } else { for count >= 11 { - n := min(count, 138); - codegen[outIndex] = 18; - outIndex++; - codegen[outIndex] = uint8(n - 11); - outIndex++; - w.codegenFreq[18]++; - count -= n; + n := min(count, 138) + codegen[outIndex] = 18 + outIndex++ + codegen[outIndex] = uint8(n - 11) + outIndex++ + w.codegenFreq[18]++ + count -= n } if count >= 3 { // count >= 3 && count <= 10 - codegen[outIndex] = 17; - outIndex++; - codegen[outIndex] = uint8(count - 3); - outIndex++; - w.codegenFreq[17]++; - count = 0; + codegen[outIndex] = 17 + outIndex++ + codegen[outIndex] = uint8(count - 3) + outIndex++ + w.codegenFreq[17]++ + count = 0 } } - count--; + count-- for ; count >= 0; count-- { - codegen[outIndex] = size; - outIndex++; - w.codegenFreq[size]++; + codegen[outIndex] = size + outIndex++ + w.codegenFreq[size]++ } // Set up invariant for next time through the loop. - size = nextSize; - count = 1; + size = nextSize + count = 1 } // Marker indicating the end of the codegen. - codegen[outIndex] = badCode; + codegen[outIndex] = badCode } func (w *huffmanBitWriter) writeCode(code *huffmanEncoder, literal uint32) { if w.err != nil { return } - w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal])); + w.writeBits(int32(code.code[literal]), int32(code.codeBits[literal])) } // Write the header of a dynamic Huffman block to the output stream. @@ -284,49 +284,49 @@ func (w *huffmanBitWriter) writeDynamicHeader(numLiterals int, numOffsets int, n if w.err != nil { return } - var firstBits int32 = 4; + var firstBits int32 = 4 if isEof { firstBits = 5 } - w.writeBits(firstBits, 3); - w.writeBits(int32(numLiterals-257), 5); + w.writeBits(firstBits, 3) + w.writeBits(int32(numLiterals-257), 5) if numOffsets > offsetCodeCount { // Extended version of deflater - w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5); - w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3); + w.writeBits(int32(offsetCodeCount+((numOffsets-(1+offsetCodeCount))>>3)), 5) + w.writeBits(int32((numOffsets-(1+offsetCodeCount))&0x7), 3) } else { w.writeBits(int32(numOffsets-1), 5) } - w.writeBits(int32(numCodegens-4), 4); + w.writeBits(int32(numCodegens-4), 4) for i := 0; i < numCodegens; i++ { - value := w.codegenEncoding.codeBits[codegenOrder[i]]; - w.writeBits(int32(value), 3); + value := w.codegenEncoding.codeBits[codegenOrder[i]] + w.writeBits(int32(value), 3) } - i := 0; + i := 0 for { - var codeWord int = int(w.codegen[i]); - i++; + var codeWord int = int(w.codegen[i]) + i++ if codeWord == badCode { break } // The low byte contains the actual code to generate. - w.writeCode(w.codegenEncoding, uint32(codeWord)); + w.writeCode(w.codegenEncoding, uint32(codeWord)) switch codeWord { case 16: - w.writeBits(int32(w.codegen[i]), 2); - i++; - break; + w.writeBits(int32(w.codegen[i]), 2) + i++ + break case 17: - w.writeBits(int32(w.codegen[i]), 3); - i++; - break; + w.writeBits(int32(w.codegen[i]), 3) + i++ + break case 18: - w.writeBits(int32(w.codegen[i]), 7); - i++; - break; + w.writeBits(int32(w.codegen[i]), 7) + i++ + break } } } @@ -335,14 +335,14 @@ func (w *huffmanBitWriter) writeStoredHeader(length int, isEof bool) { if w.err != nil { return } - var flag int32; + var flag int32 if isEof { flag = 1 } - w.writeBits(flag, 3); - w.flush(); - w.writeBits(int32(length), 16); - w.writeBits(int32(^uint16(length)), 16); + w.writeBits(flag, 3) + w.flush() + w.writeBits(int32(length), 16) + w.writeBits(int32(^uint16(length)), 16) } func (w *huffmanBitWriter) writeFixedHeader(isEof bool) { @@ -350,61 +350,61 @@ func (w *huffmanBitWriter) writeFixedHeader(isEof bool) { return } // Indicate that we are a fixed Huffman block - var value int32 = 2; + var value int32 = 2 if isEof { value = 3 } - w.writeBits(value, 3); + w.writeBits(value, 3) } func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) { if w.err != nil { return } - fillInt32s(w.literalFreq, 0); - fillInt32s(w.offsetFreq, 0); + fillInt32s(w.literalFreq, 0) + fillInt32s(w.offsetFreq, 0) - n := len(tokens); - tokens = tokens[0 : n+1]; - tokens[n] = endBlockMarker; + n := len(tokens) + tokens = tokens[0 : n+1] + tokens[n] = endBlockMarker - totalLength := -1; // Subtract 1 for endBlock. + totalLength := -1 // Subtract 1 for endBlock. for _, t := range tokens { switch t.typ() { case literalType: - w.literalFreq[t.literal()]++; - totalLength++; - break; + w.literalFreq[t.literal()]++ + totalLength++ + break case matchType: - length := t.length(); - offset := t.offset(); - totalLength += int(length + 3); - w.literalFreq[lengthCodesStart+lengthCode(length)]++; - w.offsetFreq[offsetCode(offset)]++; - break; + length := t.length() + offset := t.offset() + totalLength += int(length + 3) + w.literalFreq[lengthCodesStart+lengthCode(length)]++ + w.offsetFreq[offsetCode(offset)]++ + break } } - w.literalEncoding.generate(w.literalFreq, 15); - w.offsetEncoding.generate(w.offsetFreq, 15); + w.literalEncoding.generate(w.literalFreq, 15) + w.offsetEncoding.generate(w.offsetFreq, 15) // get the number of literals - numLiterals := len(w.literalFreq); + numLiterals := len(w.literalFreq) for w.literalFreq[numLiterals-1] == 0 { numLiterals-- } // get the number of offsets - numOffsets := len(w.offsetFreq); + numOffsets := len(w.offsetFreq) for numOffsets > 1 && w.offsetFreq[numOffsets-1] == 0 { numOffsets-- } - storedBytes := 0; + storedBytes := 0 if input != nil { storedBytes = len(input) } - var extraBits int64; - var storedSize int64; + var extraBits int64 + var storedSize int64 if storedBytes <= maxStoreBlockSize && input != nil { - storedSize = int64((storedBytes + 5) * 8); + storedSize = int64((storedBytes + 5) * 8) // We only bother calculating the costs of the extra bits required by // the length of offset fields (which will be the same for both fixed // and dynamic encoding), if we need to compare those two encodings @@ -423,7 +423,7 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) { // Figure out which generates smaller code, fixed Huffman, dynamic // Huffman, or just storing the data. - var fixedSize int64 = math.MaxInt64; + var fixedSize int64 = math.MaxInt64 if numOffsets <= offsetCodeCount { fixedSize = int64(3) + fixedLiteralEncoding.bitLength(w.literalFreq) + @@ -432,13 +432,13 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) { } // Generate codegen and codegenFrequencies, which indicates how to encode // the literalEncoding and the offsetEncoding. - w.generateCodegen(numLiterals, numOffsets); - w.codegenEncoding.generate(w.codegenFreq, 7); - numCodegens := len(w.codegenFreq); + w.generateCodegen(numLiterals, numOffsets) + w.codegenEncoding.generate(w.codegenFreq, 7) + numCodegens := len(w.codegenFreq) for numCodegens > 4 && w.codegenFreq[codegenOrder[numCodegens-1]] == 0 { numCodegens-- } - extensionSummand := 0; + extensionSummand := 0 if numOffsets > offsetCodeCount { extensionSummand = 3 } @@ -449,56 +449,56 @@ func (w *huffmanBitWriter) writeBlock(tokens []token, eof bool, input []byte) { int64(extraBits) + int64(w.codegenFreq[16]*2) + int64(w.codegenFreq[17]*3) + - int64(w.codegenFreq[18]*7); + int64(w.codegenFreq[18]*7) dynamicSize := dynamicHeader + w.literalEncoding.bitLength(w.literalFreq) + - w.offsetEncoding.bitLength(w.offsetFreq); + w.offsetEncoding.bitLength(w.offsetFreq) if storedSize < fixedSize && storedSize < dynamicSize { - w.writeStoredHeader(storedBytes, eof); - w.writeBytes(input[0:storedBytes]); - return; + w.writeStoredHeader(storedBytes, eof) + w.writeBytes(input[0:storedBytes]) + return } - var literalEncoding *huffmanEncoder; - var offsetEncoding *huffmanEncoder; + var literalEncoding *huffmanEncoder + var offsetEncoding *huffmanEncoder if fixedSize <= dynamicSize { - w.writeFixedHeader(eof); - literalEncoding = fixedLiteralEncoding; - offsetEncoding = fixedOffsetEncoding; + w.writeFixedHeader(eof) + literalEncoding = fixedLiteralEncoding + offsetEncoding = fixedOffsetEncoding } else { // Write the header. - w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof); - literalEncoding = w.literalEncoding; - offsetEncoding = w.offsetEncoding; + w.writeDynamicHeader(numLiterals, numOffsets, numCodegens, eof) + literalEncoding = w.literalEncoding + offsetEncoding = w.offsetEncoding } // Write the tokens. for _, t := range tokens { switch t.typ() { case literalType: - w.writeCode(literalEncoding, t.literal()); - break; + w.writeCode(literalEncoding, t.literal()) + break case matchType: // Write the length - length := t.length(); - lengthCode := lengthCode(length); - w.writeCode(literalEncoding, lengthCode+lengthCodesStart); - extraLengthBits := int32(lengthExtraBits[lengthCode]); + length := t.length() + lengthCode := lengthCode(length) + w.writeCode(literalEncoding, lengthCode+lengthCodesStart) + extraLengthBits := int32(lengthExtraBits[lengthCode]) if extraLengthBits > 0 { - extraLength := int32(length - lengthBase[lengthCode]); - w.writeBits(extraLength, extraLengthBits); + extraLength := int32(length - lengthBase[lengthCode]) + w.writeBits(extraLength, extraLengthBits) } // Write the offset - offset := t.offset(); - offsetCode := offsetCode(offset); - w.writeCode(offsetEncoding, offsetCode); - extraOffsetBits := int32(offsetExtraBits[offsetCode]); + offset := t.offset() + offsetCode := offsetCode(offset) + w.writeCode(offsetEncoding, offsetCode) + extraOffsetBits := int32(offsetExtraBits[offsetCode]) if extraOffsetBits > 0 { - extraOffset := int32(offset - offsetBase[offsetCode]); - w.writeBits(extraOffset, extraOffsetBits); + extraOffset := int32(offset - offsetBase[offsetCode]) + w.writeBits(extraOffset, extraOffsetBits) } - break; + break default: panic("unknown token type: " + string(t)) } diff --git a/src/pkg/compress/flate/huffman_code.go b/src/pkg/compress/flate/huffman_code.go index f212d059d..94ff2dfb8 100644 --- a/src/pkg/compress/flate/huffman_code.go +++ b/src/pkg/compress/flate/huffman_code.go @@ -5,57 +5,57 @@ package flate import ( - "math"; - "sort"; + "math" + "sort" ) type huffmanEncoder struct { - codeBits []uint8; - code []uint16; + codeBits []uint8 + code []uint16 } type literalNode struct { - literal uint16; - freq int32; + literal uint16 + freq int32 } type chain struct { // The sum of the leaves in this tree - freq int32; + freq int32 // The number of literals to the left of this item at this level - leafCount int32; + leafCount int32 // The right child of this chain in the previous level. - up *chain; + up *chain } type levelInfo struct { // Our level. for better printing - level int32; + level int32 // The most recent chain generated for this level - lastChain *chain; + lastChain *chain // The frequency of the next character to add to this level - nextCharFreq int32; + nextCharFreq int32 // The frequency of the next pair (from level below) to add to this level. // Only valid if the "needed" value of the next lower level is 0. - nextPairFreq int32; + nextPairFreq int32 // The number of chains remaining to generate for this level before moving // up to the next level - needed int32; + needed int32 // The levelInfo for level+1 - up *levelInfo; + up *levelInfo // The levelInfo for level-1 - down *levelInfo; + down *levelInfo } -func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} } +func maxNode() literalNode { return literalNode{math.MaxUint16, math.MaxInt32} } func newHuffmanEncoder(size int) *huffmanEncoder { return &huffmanEncoder{make([]uint8, size), make([]uint16, size)} @@ -63,96 +63,96 @@ func newHuffmanEncoder(size int) *huffmanEncoder { // Generates a HuffmanCode corresponding to the fixed literal table func generateFixedLiteralEncoding() *huffmanEncoder { - h := newHuffmanEncoder(maxLit); - codeBits := h.codeBits; - code := h.code; - var ch uint16; + h := newHuffmanEncoder(maxLit) + codeBits := h.codeBits + code := h.code + var ch uint16 for ch = 0; ch < maxLit; ch++ { - var bits uint16; - var size uint8; + var bits uint16 + var size uint8 switch { case ch < 144: // size 8, 000110000 .. 10111111 - bits = ch + 48; - size = 8; - break; + bits = ch + 48 + size = 8 + break case ch < 256: // size 9, 110010000 .. 111111111 - bits = ch + 400 - 144; - size = 9; - break; + bits = ch + 400 - 144 + size = 9 + break case ch < 280: // size 7, 0000000 .. 0010111 - bits = ch - 256; - size = 7; - break; + bits = ch - 256 + size = 7 + break default: // size 8, 11000000 .. 11000111 - bits = ch + 192 - 280; - size = 8; + bits = ch + 192 - 280 + size = 8 } - codeBits[ch] = size; - code[ch] = reverseBits(bits, size); + codeBits[ch] = size + code[ch] = reverseBits(bits, size) } - return h; + return h } func generateFixedOffsetEncoding() *huffmanEncoder { - h := newHuffmanEncoder(30); - codeBits := h.codeBits; - code := h.code; + h := newHuffmanEncoder(30) + codeBits := h.codeBits + code := h.code for ch := uint16(0); ch < 30; ch++ { - codeBits[ch] = 5; - code[ch] = reverseBits(ch, 5); + codeBits[ch] = 5 + code[ch] = reverseBits(ch, 5) } - return h; + return h } var fixedLiteralEncoding *huffmanEncoder = generateFixedLiteralEncoding() var fixedOffsetEncoding *huffmanEncoder = generateFixedOffsetEncoding() func (h *huffmanEncoder) bitLength(freq []int32) int64 { - var total int64; + var total int64 for i, f := range freq { if f != 0 { total += int64(f) * int64(h.codeBits[i]) } } - return total; + return total } // Generate elements in the chain using an iterative algorithm. func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) { - n := len(list); - list = list[0 : n+1]; - list[n] = maxNode(); + n := len(list) + list = list[0 : n+1] + list[n] = maxNode() - l := top; + l := top for { if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 { // We've run out of both leafs and pairs. // End all calculations for this level. // To m sure we never come back to this level or any lower level, // set nextPairFreq impossibly large. - l.lastChain = nil; - l.needed = 0; - l = l.up; - l.nextPairFreq = math.MaxInt32; - continue; + l.lastChain = nil + l.needed = 0 + l = l.up + l.nextPairFreq = math.MaxInt32 + continue } - prevFreq := l.lastChain.freq; + prevFreq := l.lastChain.freq if l.nextCharFreq < l.nextPairFreq { // The next item on this row is a leaf node. - n := l.lastChain.leafCount + 1; - l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}; - l.nextCharFreq = list[n].freq; + n := l.lastChain.leafCount + 1 + l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up} + l.nextCharFreq = list[n].freq } else { // The next item on this row is a pair from the previous row. // nextPairFreq isn't valid until we generate two // more values in the level below - l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}; - l.down.needed = 2; + l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain} + l.down.needed = 2 } if l.needed--; l.needed == 0 { @@ -160,13 +160,13 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) { // Continue calculating one level up. Fill in nextPairFreq // of that level with the sum of the two nodes we've just calculated on // this level. - up := l.up; + up := l.up if up == nil { // All done! return } - up.nextPairFreq = prevFreq + l.lastChain.freq; - l = up; + up.nextPairFreq = prevFreq + l.lastChain.freq + l = up } else { // If we stole from below, move down temporarily to replenish it. for l.down.needed > 0 { @@ -189,20 +189,20 @@ func (h *huffmanEncoder) generateChains(top *levelInfo, list []literalNode) { // return An integer array in which array[i] indicates the number of literals // that should be encoded in i bits. func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 { - n := int32(len(list)); - list = list[0 : n+1]; - list[n] = maxNode(); + n := int32(len(list)) + list = list[0 : n+1] + list[n] = maxNode() // The tree can't have greater depth than n - 1, no matter what. This // saves a little bit of work in some small cases - maxBits = minInt32(maxBits, n-1); + maxBits = minInt32(maxBits, n-1) // Create information about each of the levels. // A bogus "Level 0" whose sole purpose is so that // level1.prev.needed==0. This makes level1.nextPairFreq // be a legitimate value that never gets chosen. - top := &levelInfo{needed: 0}; - chain2 := &chain{list[1].freq, 2, new(chain)}; + top := &levelInfo{needed: 0} + chain2 := &chain{list[1].freq, 2, new(chain)} for level := int32(1); level <= maxBits; level++ { // For every level, the first two items are the first two characters. // We initialize the levels as if we had already figured this out. @@ -212,42 +212,42 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 { nextCharFreq: list[2].freq, nextPairFreq: list[0].freq + list[1].freq, down: top, - }; - top.down.up = top; + } + top.down.up = top if level == 1 { top.nextPairFreq = math.MaxInt32 } } // We need a total of 2*n - 2 items at top level and have already generated 2. - top.needed = 2*n - 4; + top.needed = 2*n - 4 - l := top; + l := top for { if l.nextPairFreq == math.MaxInt32 && l.nextCharFreq == math.MaxInt32 { // We've run out of both leafs and pairs. // End all calculations for this level. // To m sure we never come back to this level or any lower level, // set nextPairFreq impossibly large. - l.lastChain = nil; - l.needed = 0; - l = l.up; - l.nextPairFreq = math.MaxInt32; - continue; + l.lastChain = nil + l.needed = 0 + l = l.up + l.nextPairFreq = math.MaxInt32 + continue } - prevFreq := l.lastChain.freq; + prevFreq := l.lastChain.freq if l.nextCharFreq < l.nextPairFreq { // The next item on this row is a leaf node. - n := l.lastChain.leafCount + 1; - l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up}; - l.nextCharFreq = list[n].freq; + n := l.lastChain.leafCount + 1 + l.lastChain = &chain{l.nextCharFreq, n, l.lastChain.up} + l.nextCharFreq = list[n].freq } else { // The next item on this row is a pair from the previous row. // nextPairFreq isn't valid until we generate two // more values in the level below - l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain}; - l.down.needed = 2; + l.lastChain = &chain{l.nextPairFreq, l.lastChain.leafCount, l.down.lastChain} + l.down.needed = 2 } if l.needed--; l.needed == 0 { @@ -255,13 +255,13 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 { // Continue calculating one level up. Fill in nextPairFreq // of that level with the sum of the two nodes we've just calculated on // this level. - up := l.up; + up := l.up if up == nil { // All done! break } - up.nextPairFreq = prevFreq + l.lastChain.freq; - l = up; + up.nextPairFreq = prevFreq + l.lastChain.freq + l = up } else { // If we stole from below, move down temporarily to replenish it. for l.down.needed > 0 { @@ -277,23 +277,23 @@ func (h *huffmanEncoder) bitCounts(list []literalNode, maxBits int32) []int32 { panic("top.lastChain.leafCount != n") } - bitCount := make([]int32, maxBits+1); - bits := 1; + bitCount := make([]int32, maxBits+1) + bits := 1 for chain := top.lastChain; chain.up != nil; chain = chain.up { // chain.leafCount gives the number of literals requiring at least "bits" // bits to encode. - bitCount[bits] = chain.leafCount - chain.up.leafCount; - bits++; + bitCount[bits] = chain.leafCount - chain.up.leafCount + bits++ } - return bitCount; + return bitCount } // Look at the leaves and assign them a bit count and an encoding as specified // in RFC 1951 3.2.2 func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalNode) { - code := uint16(0); + code := uint16(0) for n, bits := range bitCount { - code <<= 1; + code <<= 1 if n == 0 || bits == 0 { continue } @@ -301,14 +301,14 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN // are encoded using "bits" bits, and get the values // code, code + 1, .... The code values are // assigned in literal order (not frequency order). - chunk := list[len(list)-int(bits):]; - sortByLiteral(chunk); + chunk := list[len(list)-int(bits):] + sortByLiteral(chunk) for _, node := range chunk { - h.codeBits[node.literal] = uint8(n); - h.code[node.literal] = reverseBits(code, uint8(n)); - code++; + h.codeBits[node.literal] = uint8(n) + h.code[node.literal] = reverseBits(code, uint8(n)) + code++ } - list = list[0 : len(list)-int(bits)]; + list = list[0 : len(list)-int(bits)] } } @@ -317,58 +317,58 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN // freq An array of frequencies, in which frequency[i] gives the frequency of literal i. // maxBits The maximum number of bits to use for any literal. func (h *huffmanEncoder) generate(freq []int32, maxBits int32) { - list := make([]literalNode, len(freq)+1); + list := make([]literalNode, len(freq)+1) // Number of non-zero literals - count := 0; + count := 0 // Set list to be the set of all non-zero literals and their frequencies for i, f := range freq { if f != 0 { - list[count] = literalNode{uint16(i), f}; - count++; + list[count] = literalNode{uint16(i), f} + count++ } else { h.codeBits[i] = 0 } } // If freq[] is shorter than codeBits[], fill rest of codeBits[] with zeros - h.codeBits = h.codeBits[0:len(freq)]; - list = list[0:count]; + h.codeBits = h.codeBits[0:len(freq)] + list = list[0:count] if count <= 2 { // Handle the small cases here, because they are awkward for the general case code. With // two or fewer literals, everything has bit length 1. for i, node := range list { // "list" is in order of increasing literal value. - h.codeBits[node.literal] = 1; - h.code[node.literal] = uint16(i); + h.codeBits[node.literal] = 1 + h.code[node.literal] = uint16(i) } - return; + return } - sortByFreq(list); + sortByFreq(list) // Get the number of literals for each bit count - bitCount := h.bitCounts(list, maxBits); + bitCount := h.bitCounts(list, maxBits) // And do the assignment - h.assignEncodingAndSize(bitCount, list); + h.assignEncodingAndSize(bitCount, list) } type literalNodeSorter struct { - a []literalNode; - less func(i, j int) bool; + a []literalNode + less func(i, j int) bool } -func (s literalNodeSorter) Len() int { return len(s.a) } +func (s literalNodeSorter) Len() int { return len(s.a) } func (s literalNodeSorter) Less(i, j int) bool { return s.less(i, j) } -func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] } +func (s literalNodeSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] } func sortByFreq(a []literalNode) { - s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }}; - sort.Sort(s); + s := &literalNodeSorter{a, func(i, j int) bool { return a[i].freq < a[j].freq }} + sort.Sort(s) } func sortByLiteral(a []literalNode) { - s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }}; - sort.Sort(s); + s := &literalNodeSorter{a, func(i, j int) bool { return a[i].literal < a[j].literal }} + sort.Sort(s) } diff --git a/src/pkg/compress/flate/inflate.go b/src/pkg/compress/flate/inflate.go index 213846688..371fe94c5 100644 --- a/src/pkg/compress/flate/inflate.go +++ b/src/pkg/compress/flate/inflate.go @@ -8,18 +8,18 @@ package flate import ( - "bufio"; - "io"; - "os"; - "strconv"; + "bufio" + "io" + "os" + "strconv" ) const ( - maxCodeLen = 16; // max length of Huffman code - maxHist = 32768; // max history required - maxLit = 286; - maxDist = 32; - numCodes = 19; // number of codes in Huffman meta-code + maxCodeLen = 16 // max length of Huffman code + maxHist = 32768 // max history required + maxLit = 286 + maxDist = 32 + numCodes = 19 // number of codes in Huffman meta-code ) // A CorruptInputError reports the presence of corrupt input at a given offset. @@ -32,12 +32,12 @@ func (e CorruptInputError) String() string { // An InternalError reports an error in the flate code itself. type InternalError string -func (e InternalError) String() string { return "flate: internal error: " + string(e) } +func (e InternalError) String() string { return "flate: internal error: " + string(e) } // A ReadError reports an error encountered while reading input. type ReadError struct { - Offset int64; // byte offset where error occurred - Error os.Error; // error returned by underlying Read + Offset int64 // byte offset where error occurred + Error os.Error // error returned by underlying Read } func (e *ReadError) String() string { @@ -46,8 +46,8 @@ func (e *ReadError) String() string { // A WriteError reports an error encountered while writing output. type WriteError struct { - Offset int64; // byte offset where error occurred - Error os.Error; // error returned by underlying Read + Offset int64 // byte offset where error occurred + Error os.Error // error returned by underlying Read } func (e *WriteError) String() string { @@ -59,20 +59,20 @@ func (e *WriteError) String() string { // Proceedings of the IEEE, 61(7) (July 1973), pp 1046-1047. type huffmanDecoder struct { // min, max code length - min, max int; + min, max int // limit[i] = largest code word of length i // Given code v of length n, // need more bits if v > limit[n]. - limit [maxCodeLen + 1]int; + limit [maxCodeLen + 1]int // base[i] = smallest code word of length i - seq number - base [maxCodeLen + 1]int; + base [maxCodeLen + 1]int // codes[seq number] = output code. // Given code v of length n, value is // codes[v - base[n]]. - codes []int; + codes []int } // Initialize Huffman decoding tables from array of code lengths. @@ -81,8 +81,8 @@ func (h *huffmanDecoder) init(bits []int) bool { // Count number of codes of each length, // compute min and max length. - var count [maxCodeLen + 1]int; - var min, max int; + var count [maxCodeLen + 1]int + var min, max int for _, n := range bits { if n == 0 { continue @@ -93,31 +93,31 @@ func (h *huffmanDecoder) init(bits []int) bool { if n > max { max = n } - count[n]++; + count[n]++ } if max == 0 { return false } - h.min = min; - h.max = max; + h.min = min + h.max = max // For each code range, compute // nextcode (first code of that length), // limit (last code of that length), and // base (offset from first code to sequence number). - code := 0; - seq := 0; - var nextcode [maxCodeLen]int; + code := 0 + seq := 0 + var nextcode [maxCodeLen]int for i := min; i <= max; i++ { - n := count[i]; - nextcode[i] = code; - h.base[i] = code - seq; - code += n; - seq += n; - h.limit[i] = code - 1; - code <<= 1; + n := count[i] + nextcode[i] = code + h.base[i] = code - seq + code += n + seq += n + h.limit[i] = code - 1 + code <<= 1 } // Make array mapping sequence numbers to codes. @@ -128,12 +128,12 @@ func (h *huffmanDecoder) init(bits []int) bool { if n == 0 { continue } - code := nextcode[n]; - nextcode[n]++; - seq := code - h.base[n]; - h.codes[seq] = i; + code := nextcode[n] + nextcode[n]++ + seq := code - h.base[n] + h.codes[seq] = i } - return true; + return true } // Hard-coded Huffman tables for DEFLATE algorithm. @@ -192,51 +192,51 @@ var fixedHuffmanDecoder = huffmanDecoder{ // If the passed in io.Reader does not also have ReadByte, // the NewInflater will introduce its own buffering. type Reader interface { - io.Reader; - ReadByte() (c byte, err os.Error); + io.Reader + ReadByte() (c byte, err os.Error) } // Inflate state. type inflater struct { // Input/output sources. - r Reader; - w io.Writer; - roffset int64; - woffset int64; + r Reader + w io.Writer + roffset int64 + woffset int64 // Input bits, in top of b. - b uint32; - nb uint; + b uint32 + nb uint // Huffman decoders for literal/length, distance. - h1, h2 huffmanDecoder; + h1, h2 huffmanDecoder // Length arrays used to define Huffman codes. - bits [maxLit + maxDist]int; - codebits [numCodes]int; + bits [maxLit + maxDist]int + codebits [numCodes]int // Output history, buffer. - hist [maxHist]byte; - hp int; // current output position in buffer - hfull bool; // buffer has filled at least once + hist [maxHist]byte + hp int // current output position in buffer + hfull bool // buffer has filled at least once // Temporary buffer (avoids repeated allocation). - buf [4]byte; + buf [4]byte } func (f *inflater) inflate() (err os.Error) { - final := false; + final := false for err == nil && !final { for f.nb < 1+2 { if err = f.moreBits(); err != nil { return } } - final = f.b&1 == 1; - f.b >>= 1; - typ := f.b & 3; - f.b >>= 2; - f.nb -= 1 + 2; + final = f.b&1 == 1 + f.b >>= 1 + typ := f.b & 3 + f.b >>= 2 + f.nb -= 1 + 2 switch typ { case 0: err = f.dataBlock() @@ -253,7 +253,7 @@ func (f *inflater) inflate() (err os.Error) { err = CorruptInputError(f.roffset) } } - return; + return } // RFC 1951 section 3.2.7. @@ -268,13 +268,13 @@ func (f *inflater) readHuffman() os.Error { return err } } - nlit := int(f.b&0x1F) + 257; - f.b >>= 5; - ndist := int(f.b&0x1F) + 1; - f.b >>= 5; - nclen := int(f.b&0xF) + 4; - f.b >>= 4; - f.nb -= 5 + 5 + 4; + nlit := int(f.b&0x1F) + 257 + f.b >>= 5 + ndist := int(f.b&0x1F) + 1 + f.b >>= 5 + nclen := int(f.b&0xF) + 4 + f.b >>= 4 + f.nb -= 5 + 5 + 4 // (HCLEN+4)*3 bits: code lengths in the magic codeOrder order. for i := 0; i < nclen; i++ { @@ -283,9 +283,9 @@ func (f *inflater) readHuffman() os.Error { return err } } - f.codebits[codeOrder[i]] = int(f.b & 0x7); - f.b >>= 3; - f.nb -= 3; + f.codebits[codeOrder[i]] = int(f.b & 0x7) + f.b >>= 3 + f.nb -= 3 } for i := nclen; i < len(codeOrder); i++ { f.codebits[codeOrder[i]] = 0 @@ -297,53 +297,53 @@ func (f *inflater) readHuffman() os.Error { // HLIT + 257 code lengths, HDIST + 1 code lengths, // using the code length Huffman code. for i, n := 0, nlit+ndist; i < n; { - x, err := f.huffSym(&f.h1); + x, err := f.huffSym(&f.h1) if err != nil { return err } if x < 16 { // Actual length. - f.bits[i] = x; - i++; - continue; + f.bits[i] = x + i++ + continue } // Repeat previous length or zero. - var rep int; - var nb uint; - var b int; + var rep int + var nb uint + var b int switch x { default: return InternalError("unexpected length code") case 16: - rep = 3; - nb = 2; + rep = 3 + nb = 2 if i == 0 { return CorruptInputError(f.roffset) } - b = f.bits[i-1]; + b = f.bits[i-1] case 17: - rep = 3; - nb = 3; - b = 0; + rep = 3 + nb = 3 + b = 0 case 18: - rep = 11; - nb = 7; - b = 0; + rep = 11 + nb = 7 + b = 0 } for f.nb < nb { if err := f.moreBits(); err != nil { return err } } - rep += int(f.b & uint32(1<<nb-1)); - f.b >>= nb; - f.nb -= nb; + rep += int(f.b & uint32(1<<nb-1)) + f.b >>= nb + f.nb -= nb if i+rep > n { return CorruptInputError(f.roffset) } for j := 0; j < rep; j++ { - f.bits[i] = b; - i++; + f.bits[i] = b + i++ } } @@ -351,7 +351,7 @@ func (f *inflater) readHuffman() os.Error { return CorruptInputError(f.roffset) } - return nil; + return nil } // Decode a single Huffman block from f. @@ -360,46 +360,46 @@ func (f *inflater) readHuffman() os.Error { // fixed distance encoding associated with fixed Huffman blocks. func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error { for { - v, err := f.huffSym(hl); + v, err := f.huffSym(hl) if err != nil { return err } - var n uint; // number of bits extra - var length int; + var n uint // number of bits extra + var length int switch { case v < 256: - f.hist[f.hp] = byte(v); - f.hp++; + f.hist[f.hp] = byte(v) + f.hp++ if f.hp == len(f.hist) { if err = f.flush(); err != nil { return err } } - continue; + continue case v == 256: return nil // otherwise, reference to older data case v < 265: - length = v - (257 - 3); - n = 0; + length = v - (257 - 3) + n = 0 case v < 269: - length = v*2 - (265*2 - 11); - n = 1; + length = v*2 - (265*2 - 11) + n = 1 case v < 273: - length = v*4 - (269*4 - 19); - n = 2; + length = v*4 - (269*4 - 19) + n = 2 case v < 277: - length = v*8 - (273*8 - 35); - n = 3; + length = v*8 - (273*8 - 35) + n = 3 case v < 281: - length = v*16 - (277*16 - 67); - n = 4; + length = v*16 - (277*16 - 67) + n = 4 case v < 285: - length = v*32 - (281*32 - 131); - n = 5; + length = v*32 - (281*32 - 131) + n = 5 default: - length = 258; - n = 0; + length = 258 + n = 0 } if n > 0 { for f.nb < n { @@ -407,21 +407,21 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error { return err } } - length += int(f.b & uint32(1<<n-1)); - f.b >>= n; - f.nb -= n; + length += int(f.b & uint32(1<<n-1)) + f.b >>= n + f.nb -= n } - var dist int; + var dist int if hd == nil { for f.nb < 5 { if err = f.moreBits(); err != nil { return err } } - dist = int(reverseByte[(f.b&0x1F)<<3]); - f.b >>= 5; - f.nb -= 5; + dist = int(reverseByte[(f.b&0x1F)<<3]) + f.b >>= 5 + f.nb -= 5 } else { if dist, err = f.huffSym(hd); err != nil { return err @@ -434,18 +434,18 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error { case dist >= 30: return CorruptInputError(f.roffset) default: - nb := uint(dist-2) >> 1; + nb := uint(dist-2) >> 1 // have 1 bit in bottom of dist, need nb more. - extra := (dist & 1) << nb; + extra := (dist & 1) << nb for f.nb < nb { if err = f.moreBits(); err != nil { return err } } - extra |= int(f.b & uint32(1<<nb-1)); - f.b >>= nb; - f.nb -= nb; - dist = 1<<(nb+1) + 1 + extra; + extra |= int(f.b & uint32(1<<nb-1)) + f.b >>= nb + f.nb -= nb + dist = 1<<(nb+1) + 1 + extra } // Copy history[-dist:-dist+length] into output. @@ -458,14 +458,14 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error { return CorruptInputError(f.roffset) } - p := f.hp - dist; + p := f.hp - dist if p < 0 { p += len(f.hist) } for i := 0; i < length; i++ { - f.hist[f.hp] = f.hist[p]; - f.hp++; - p++; + f.hist[f.hp] = f.hist[p] + f.hp++ + p++ if f.hp == len(f.hist) { if err = f.flush(); err != nil { return err @@ -476,24 +476,24 @@ func (f *inflater) decodeBlock(hl, hd *huffmanDecoder) os.Error { } } } - panic("unreached"); + panic("unreached") } // Copy a single uncompressed data block from input to output. func (f *inflater) dataBlock() os.Error { // Uncompressed. // Discard current half-byte. - f.nb = 0; - f.b = 0; + f.nb = 0 + f.b = 0 // Length then ones-complement of length. - nr, err := io.ReadFull(f.r, f.buf[0:4]); - f.roffset += int64(nr); + nr, err := io.ReadFull(f.r, f.buf[0:4]) + f.roffset += int64(nr) if err != nil { return &ReadError{f.roffset, err} } - n := int(f.buf[0]) | int(f.buf[1])<<8; - nn := int(f.buf[2]) | int(f.buf[3])<<8; + n := int(f.buf[0]) | int(f.buf[1])<<8 + nn := int(f.buf[2]) | int(f.buf[3])<<8 if uint16(nn) != uint16(^n) { return CorruptInputError(f.roffset) } @@ -501,44 +501,44 @@ func (f *inflater) dataBlock() os.Error { // Read len bytes into history, // writing as history fills. for n > 0 { - m := len(f.hist) - f.hp; + m := len(f.hist) - f.hp if m > n { m = n } - m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m]); - f.roffset += int64(m); + m, err := io.ReadFull(f.r, f.hist[f.hp:f.hp+m]) + f.roffset += int64(m) if err != nil { return &ReadError{f.roffset, err} } - n -= m; - f.hp += m; + n -= m + f.hp += m if f.hp == len(f.hist) { if err = f.flush(); err != nil { return err } } } - return nil; + return nil } func (f *inflater) moreBits() os.Error { - c, err := f.r.ReadByte(); + c, err := f.r.ReadByte() if err != nil { if err == os.EOF { err = io.ErrUnexpectedEOF } - return err; + return err } - f.roffset++; - f.b |= uint32(c) << f.nb; - f.nb += 8; - return nil; + f.roffset++ + f.b |= uint32(c) << f.nb + f.nb += 8 + return nil } // Read the next Huffman-encoded symbol from f according to h. func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) { for n := uint(h.min); n <= uint(h.max); n++ { - lim := h.limit[n]; + lim := h.limit[n] if lim == -1 { continue } @@ -547,16 +547,16 @@ func (f *inflater) huffSym(h *huffmanDecoder) (int, os.Error) { return 0, err } } - v := int(f.b & uint32(1<<n-1)); - v <<= 16 - n; - v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8; // reverse bits + v := int(f.b & uint32(1<<n-1)) + v <<= 16 - n + v = int(reverseByte[v>>8]) | int(reverseByte[v&0xFF])<<8 // reverse bits if v <= lim { - f.b >>= n; - f.nb -= n; - return h.codes[v-h.base[n]], nil; + f.b >>= n + f.nb -= n + return h.codes[v-h.base[n]], nil } } - return 0, CorruptInputError(f.roffset); + return 0, CorruptInputError(f.roffset) } // Flush any buffered output to the underlying writer. @@ -564,39 +564,39 @@ func (f *inflater) flush() os.Error { if f.hp == 0 { return nil } - n, err := f.w.Write(f.hist[0:f.hp]); + n, err := f.w.Write(f.hist[0:f.hp]) if n != f.hp && err == nil { err = io.ErrShortWrite } if err != nil { return &WriteError{f.woffset, err} } - f.woffset += int64(f.hp); - f.hp = 0; - f.hfull = true; - return nil; + f.woffset += int64(f.hp) + f.hp = 0 + f.hfull = true + return nil } func makeReader(r io.Reader) Reader { if rr, ok := r.(Reader); ok { return rr } - return bufio.NewReader(r); + return bufio.NewReader(r) } // Inflate reads DEFLATE-compressed data from r and writes // the uncompressed data to w. func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error { - f.r = makeReader(r); - f.w = w; - f.woffset = 0; + f.r = makeReader(r) + f.w = w + f.woffset = 0 if err := f.inflate(); err != nil { return err } if err := f.flush(); err != nil { return err } - return nil; + return nil } // NewInflater returns a new ReadCloser that can be used @@ -604,8 +604,8 @@ func (f *inflater) inflater(r io.Reader, w io.Writer) os.Error { // responsibility to call Close on the ReadCloser when // finished reading. func NewInflater(r io.Reader) io.ReadCloser { - var f inflater; - pr, pw := io.Pipe(); - go func() { pw.CloseWithError(f.inflater(r, pw)) }(); - return pr; + var f inflater + pr, pw := io.Pipe() + go func() { pw.CloseWithError(f.inflater(r, pw)) }() + return pr } diff --git a/src/pkg/compress/flate/token.go b/src/pkg/compress/flate/token.go index 139e1d0da..38aea5fa6 100644 --- a/src/pkg/compress/flate/token.go +++ b/src/pkg/compress/flate/token.go @@ -8,11 +8,11 @@ const ( // 2 bits: type 0 = literal 1=EOF 2=Match 3=Unused // 8 bits: xlength = length - MIN_MATCH_LENGTH // 22 bits xoffset = offset - MIN_OFFSET_SIZE, or literal - lengthShift = 22; - offsetMask = 1<<lengthShift - 1; - typeMask = 3 << 30; - literalType = 0 << 30; - matchType = 1 << 30; + lengthShift = 22 + offsetMask = 1<<lengthShift - 1 + typeMask = 3 << 30 + literalType = 0 << 30 + matchType = 1 << 30 ) // The length code for length X (MIN_MATCH_LENGTH <= X <= MAX_MATCH_LENGTH) @@ -68,7 +68,7 @@ var offsetCodes = [...]uint32{ type token uint32 // Convert a literal into a literal token. -func literalToken(literal uint32) token { return token(literalType + literal) } +func literalToken(literal uint32) token { return token(literalType + literal) } // Convert a < xlength, xoffset > pair into a match token. func matchToken(xlength uint32, xoffset uint32) token { @@ -76,21 +76,21 @@ func matchToken(xlength uint32, xoffset uint32) token { } // Returns the type of a token -func (t token) typ() uint32 { return uint32(t) & typeMask } +func (t token) typ() uint32 { return uint32(t) & typeMask } // Returns the literal of a literal token -func (t token) literal() uint32 { return uint32(t - literalType) } +func (t token) literal() uint32 { return uint32(t - literalType) } // Returns the extra offset of a match token -func (t token) offset() uint32 { return uint32(t) & offsetMask } +func (t token) offset() uint32 { return uint32(t) & offsetMask } -func (t token) length() uint32 { return uint32((t - matchType) >> lengthShift) } +func (t token) length() uint32 { return uint32((t - matchType) >> lengthShift) } -func lengthCode(len uint32) uint32 { return lengthCodes[len] } +func lengthCode(len uint32) uint32 { return lengthCodes[len] } // Returns the offset code corresponding to a specific offset func offsetCode(off uint32) uint32 { - const n = uint32(len(offsetCodes)); + const n = uint32(len(offsetCodes)) switch { case off < n: return offsetCodes[off] @@ -99,5 +99,5 @@ func offsetCode(off uint32) uint32 { default: return offsetCodes[off>>14] + 28 } - panic("unreachable"); + panic("unreachable") } diff --git a/src/pkg/compress/flate/util.go b/src/pkg/compress/flate/util.go index f4e0b9ba3..aca5c78b2 100644 --- a/src/pkg/compress/flate/util.go +++ b/src/pkg/compress/flate/util.go @@ -8,21 +8,21 @@ func min(left int, right int) int { if left < right { return left } - return right; + return right } func minInt32(left int32, right int32) int32 { if left < right { return left } - return right; + return right } func max(left int, right int) int { if left > right { return left } - return right; + return right } func fillInts(a []int, value int) { @@ -56,17 +56,17 @@ func fillUint8s(a []uint8, value uint8) { } func copyInt8s(dst []int8, src []int8) int { - cnt := min(len(dst), len(src)); + cnt := min(len(dst), len(src)) for i := 0; i < cnt; i++ { dst[i] = src[i] } - return cnt; + return cnt } func copyUint8s(dst []uint8, src []uint8) int { - cnt := min(len(dst), len(src)); + cnt := min(len(dst), len(src)) for i := 0; i < cnt; i++ { dst[i] = src[i] } - return cnt; + return cnt } diff --git a/src/pkg/compress/gzip/gunzip.go b/src/pkg/compress/gzip/gunzip.go index ef84f16fc..b2a08830c 100644 --- a/src/pkg/compress/gzip/gunzip.go +++ b/src/pkg/compress/gzip/gunzip.go @@ -7,30 +7,30 @@ package gzip import ( - "bufio"; - "compress/flate"; - "hash"; - "hash/crc32"; - "io"; - "os"; + "bufio" + "compress/flate" + "hash" + "hash/crc32" + "io" + "os" ) const ( - gzipID1 = 0x1f; - gzipID2 = 0x8b; - gzipDeflate = 8; - flagText = 1 << 0; - flagHdrCrc = 1 << 1; - flagExtra = 1 << 2; - flagName = 1 << 3; - flagComment = 1 << 4; + gzipID1 = 0x1f + gzipID2 = 0x8b + gzipDeflate = 8 + flagText = 1 << 0 + flagHdrCrc = 1 << 1 + flagExtra = 1 << 2 + flagName = 1 << 3 + flagComment = 1 << 4 ) func makeReader(r io.Reader) flate.Reader { if rr, ok := r.(flate.Reader); ok { return rr } - return bufio.NewReader(r); + return bufio.NewReader(r) } var HeaderError os.Error = os.ErrorString("invalid gzip header") @@ -53,34 +53,34 @@ var ChecksumError os.Error = os.ErrorString("gzip checksum error") // returned by Read as tentative until they receive the successful // (zero length, nil error) Read marking the end of the data. type Inflater struct { - Comment string; // comment - Extra []byte; // "extra data" - Mtime uint32; // modification time (seconds since January 1, 1970) - Name string; // file name - OS byte; // operating system type - - r flate.Reader; - inflater io.ReadCloser; - digest hash.Hash32; - size uint32; - flg byte; - buf [512]byte; - err os.Error; - eof bool; + Comment string // comment + Extra []byte // "extra data" + Mtime uint32 // modification time (seconds since January 1, 1970) + Name string // file name + OS byte // operating system type + + r flate.Reader + inflater io.ReadCloser + digest hash.Hash32 + size uint32 + flg byte + buf [512]byte + err os.Error + eof bool } // NewInflater creates a new Inflater reading the given reader. // The implementation buffers input and may read more data than necessary from r. // It is the caller's responsibility to call Close on the Inflater when done. func NewInflater(r io.Reader) (*Inflater, os.Error) { - z := new(Inflater); - z.r = makeReader(r); - z.digest = crc32.NewIEEE(); + z := new(Inflater) + z.r = makeReader(r) + z.digest = crc32.NewIEEE() if err := z.readHeader(true); err != nil { - z.err = err; - return nil, err; + z.err = err + return nil, err } - return z, nil; + return z, nil } // GZIP (RFC 1952) is little-endian, unlike ZLIB (RFC 1950). @@ -89,12 +89,12 @@ func get4(p []byte) uint32 { } func (z *Inflater) readString() (string, os.Error) { - var err os.Error; + var err os.Error for i := 0; ; i++ { if i >= len(z.buf) { return "", HeaderError } - z.buf[i], err = z.r.ReadByte(); + z.buf[i], err = z.r.ReadByte() if err != nil { return "", err } @@ -102,40 +102,40 @@ func (z *Inflater) readString() (string, os.Error) { return string(z.buf[0:i]), nil } } - panic("not reached"); + panic("not reached") } func (z *Inflater) read2() (uint32, os.Error) { - _, err := z.r.Read(z.buf[0:2]); + _, err := z.r.Read(z.buf[0:2]) if err != nil { return 0, err } - return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil; + return uint32(z.buf[0]) | uint32(z.buf[1])<<8, nil } func (z *Inflater) readHeader(save bool) os.Error { - _, err := io.ReadFull(z.r, z.buf[0:10]); + _, err := io.ReadFull(z.r, z.buf[0:10]) if err != nil { return err } if z.buf[0] != gzipID1 || z.buf[1] != gzipID2 || z.buf[2] != gzipDeflate { return HeaderError } - z.flg = z.buf[3]; + z.flg = z.buf[3] if save { - z.Mtime = get4(z.buf[4:8]); + z.Mtime = get4(z.buf[4:8]) // z.buf[8] is xfl, ignored - z.OS = z.buf[9]; + z.OS = z.buf[9] } - z.digest.Reset(); - z.digest.Write(z.buf[0:10]); + z.digest.Reset() + z.digest.Write(z.buf[0:10]) if z.flg&flagExtra != 0 { - n, err := z.read2(); + n, err := z.read2() if err != nil { return err } - data := make([]byte, n); + data := make([]byte, n) if _, err = io.ReadFull(z.r, data); err != nil { return err } @@ -144,7 +144,7 @@ func (z *Inflater) readHeader(save bool) os.Error { } } - var s string; + var s string if z.flg&flagName != 0 { if s, err = z.readString(); err != nil { return err @@ -164,19 +164,19 @@ func (z *Inflater) readHeader(save bool) os.Error { } if z.flg&flagHdrCrc != 0 { - n, err := z.read2(); + n, err := z.read2() if err != nil { return err } - sum := z.digest.Sum32() & 0xFFFF; + sum := z.digest.Sum32() & 0xFFFF if n != sum { return HeaderError } } - z.digest.Reset(); - z.inflater = flate.NewInflater(z.r); - return nil; + z.digest.Reset() + z.inflater = flate.NewInflater(z.r) + return nil } func (z *Inflater) Read(p []byte) (n int, err os.Error) { @@ -187,37 +187,37 @@ func (z *Inflater) Read(p []byte) (n int, err os.Error) { return 0, nil } - n, err = z.inflater.Read(p); - z.digest.Write(p[0:n]); - z.size += uint32(n); + n, err = z.inflater.Read(p) + z.digest.Write(p[0:n]) + z.size += uint32(n) if n != 0 || err != os.EOF { - z.err = err; - return; + z.err = err + return } // Finished file; check checksum + size. if _, err := io.ReadFull(z.r, z.buf[0:8]); err != nil { - z.err = err; - return 0, err; + z.err = err + return 0, err } - crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8]); - sum := z.digest.Sum32(); + crc32, isize := get4(z.buf[0:4]), get4(z.buf[4:8]) + sum := z.digest.Sum32() if sum != crc32 || isize != z.size { - z.err = ChecksumError; - return 0, z.err; + z.err = ChecksumError + return 0, z.err } // File is ok; is there another? if err = z.readHeader(false); err != nil { - z.err = err; - return; + z.err = err + return } // Yes. Reset and read from it. - z.digest.Reset(); - z.size = 0; - return z.Read(p); + z.digest.Reset() + z.size = 0 + return z.Read(p) } // Calling Close does not close the wrapped io.Reader originally passed to NewInflater. -func (z *Inflater) Close() os.Error { return z.inflater.Close() } +func (z *Inflater) Close() os.Error { return z.inflater.Close() } diff --git a/src/pkg/compress/gzip/gunzip_test.go b/src/pkg/compress/gzip/gunzip_test.go index 67b3b3ce2..3930985e3 100644 --- a/src/pkg/compress/gzip/gunzip_test.go +++ b/src/pkg/compress/gzip/gunzip_test.go @@ -5,22 +5,22 @@ package gzip import ( - "bytes"; - "io"; - "os"; - "testing"; + "bytes" + "io" + "os" + "testing" ) type gzipTest struct { - name string; - desc string; - raw string; - gzip []byte; - err os.Error; + name string + desc string + raw string + gzip []byte + err os.Error } var gzipTests = []gzipTest{ - gzipTest{ // has 1 empty fixed-huffman block + gzipTest{ // has 1 empty fixed-huffman block "empty.txt", "empty.txt", "", @@ -32,7 +32,7 @@ var gzipTests = []gzipTest{ }, nil, }, - gzipTest{ // has 1 non-empty fixed huffman block + gzipTest{ // has 1 non-empty fixed huffman block "hello.txt", "hello.txt", "hello world\n", @@ -46,7 +46,7 @@ var gzipTests = []gzipTest{ }, nil, }, - gzipTest{ // concatenation + gzipTest{ // concatenation "hello.txt", "hello.txt x2", "hello world\n" + @@ -67,7 +67,7 @@ var gzipTests = []gzipTest{ }, nil, }, - gzipTest{ // has a fixed huffman block with some length-distance pairs + gzipTest{ // has a fixed huffman block with some length-distance pairs "shesells.txt", "shesells.txt", "she sells seashells by the seashore\n", @@ -83,7 +83,7 @@ var gzipTests = []gzipTest{ }, nil, }, - gzipTest{ // has dynamic huffman blocks + gzipTest{ // has dynamic huffman blocks "gettysburg", "gettysburg", " Four score and seven years ago our fathers brought forth on\n" + @@ -221,7 +221,7 @@ var gzipTests = []gzipTest{ }, nil, }, - gzipTest{ // has 1 non-empty fixed huffman block then garbage + gzipTest{ // has 1 non-empty fixed huffman block then garbage "hello.txt", "hello.txt + garbage", "hello world\n", @@ -235,7 +235,7 @@ var gzipTests = []gzipTest{ }, HeaderError, }, - gzipTest{ // has 1 non-empty fixed huffman block not enough header + gzipTest{ // has 1 non-empty fixed huffman block not enough header "hello.txt", "hello.txt + garbage", "hello world\n", @@ -249,7 +249,7 @@ var gzipTests = []gzipTest{ }, io.ErrUnexpectedEOF, }, - gzipTest{ // has 1 non-empty fixed huffman block but corrupt checksum + gzipTest{ // has 1 non-empty fixed huffman block but corrupt checksum "hello.txt", "hello.txt + corrupt checksum", "hello world\n", @@ -263,7 +263,7 @@ var gzipTests = []gzipTest{ }, ChecksumError, }, - gzipTest{ // has 1 non-empty fixed huffman block but corrupt size + gzipTest{ // has 1 non-empty fixed huffman block but corrupt size "hello.txt", "hello.txt + corrupt size", "hello world\n", @@ -280,24 +280,24 @@ var gzipTests = []gzipTest{ } func TestInflater(t *testing.T) { - b := new(bytes.Buffer); + b := new(bytes.Buffer) for _, tt := range gzipTests { - in := bytes.NewBuffer(tt.gzip); - gzip, err := NewInflater(in); + in := bytes.NewBuffer(tt.gzip) + gzip, err := NewInflater(in) if err != nil { - t.Errorf("%s: NewInflater: %s", tt.name, err); - continue; + t.Errorf("%s: NewInflater: %s", tt.name, err) + continue } - defer gzip.Close(); + defer gzip.Close() if tt.name != gzip.Name { t.Errorf("%s: got name %s", tt.name, gzip.Name) } - b.Reset(); - n, err := io.Copy(b, gzip); + b.Reset() + n, err := io.Copy(b, gzip) if err != tt.err { t.Errorf("%s: io.Copy: %v want %v", tt.name, err, tt.err) } - s := b.String(); + s := b.String() if s != tt.raw { t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.name, n, s, len(tt.raw), tt.raw) } diff --git a/src/pkg/compress/zlib/reader.go b/src/pkg/compress/zlib/reader.go index ffe5cbafc..c3a9d28ca 100644 --- a/src/pkg/compress/zlib/reader.go +++ b/src/pkg/compress/zlib/reader.go @@ -7,12 +7,12 @@ package zlib import ( - "bufio"; - "compress/flate"; - "hash"; - "hash/adler32"; - "io"; - "os"; + "bufio" + "compress/flate" + "hash" + "hash/adler32" + "io" + "os" ) const zlibDeflate = 8 @@ -22,28 +22,28 @@ var HeaderError os.Error = os.ErrorString("invalid zlib header") var UnsupportedError os.Error = os.ErrorString("unsupported zlib format") type reader struct { - r flate.Reader; - inflater io.ReadCloser; - digest hash.Hash32; - err os.Error; - scratch [4]byte; + r flate.Reader + inflater io.ReadCloser + digest hash.Hash32 + err os.Error + scratch [4]byte } // NewInflater creates a new io.ReadCloser that satisfies reads by decompressing data read from r. // The implementation buffers input and may read more data than necessary from r. // It is the caller's responsibility to call Close on the ReadCloser when done. func NewInflater(r io.Reader) (io.ReadCloser, os.Error) { - z := new(reader); + z := new(reader) if fr, ok := r.(flate.Reader); ok { z.r = fr } else { z.r = bufio.NewReader(r) } - _, err := io.ReadFull(z.r, z.scratch[0:2]); + _, err := io.ReadFull(z.r, z.scratch[0:2]) if err != nil { return nil, err } - h := uint(z.scratch[0])<<8 | uint(z.scratch[1]); + h := uint(z.scratch[0])<<8 | uint(z.scratch[1]) if (z.scratch[0]&0x0f != zlibDeflate) || (h%31 != 0) { return nil, HeaderError } @@ -51,9 +51,9 @@ func NewInflater(r io.Reader) (io.ReadCloser, os.Error) { // BUG(nigeltao): The zlib package does not implement the FDICT flag. return nil, UnsupportedError } - z.digest = adler32.New(); - z.inflater = flate.NewInflater(z.r); - return z, nil; + z.digest = adler32.New() + z.inflater = flate.NewInflater(z.r) + return z, nil } func (z *reader) Read(p []byte) (n int, err os.Error) { @@ -64,25 +64,25 @@ func (z *reader) Read(p []byte) (n int, err os.Error) { return 0, nil } - n, err = z.inflater.Read(p); - z.digest.Write(p[0:n]); + n, err = z.inflater.Read(p) + z.digest.Write(p[0:n]) if n != 0 || err != os.EOF { - z.err = err; - return; + z.err = err + return } // Finished file; check checksum. if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil { - z.err = err; - return 0, err; + z.err = err + return 0, err } // ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952). - checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]); + checksum := uint32(z.scratch[0])<<24 | uint32(z.scratch[1])<<16 | uint32(z.scratch[2])<<8 | uint32(z.scratch[3]) if checksum != z.digest.Sum32() { - z.err = ChecksumError; - return 0, z.err; + z.err = ChecksumError + return 0, z.err } - return; + return } // Calling Close does not close the wrapped io.Reader originally passed to NewInflater. @@ -90,6 +90,6 @@ func (z *reader) Close() os.Error { if z.err != nil { return z.err } - z.err = z.inflater.Close(); - return z.err; + z.err = z.inflater.Close() + return z.err } diff --git a/src/pkg/compress/zlib/reader_test.go b/src/pkg/compress/zlib/reader_test.go index 5e057ee21..3b349f5ee 100644 --- a/src/pkg/compress/zlib/reader_test.go +++ b/src/pkg/compress/zlib/reader_test.go @@ -5,17 +5,17 @@ package zlib import ( - "bytes"; - "io"; - "os"; - "testing"; + "bytes" + "io" + "os" + "testing" ) type zlibTest struct { - desc string; - raw string; - compressed []byte; - err os.Error; + desc string + raw string + compressed []byte + err os.Error } // Compare-to-golden test data was generated by the ZLIB example program at @@ -68,26 +68,26 @@ var zlibTests = []zlibTest{ } func TestInflater(t *testing.T) { - b := new(bytes.Buffer); + b := new(bytes.Buffer) for _, tt := range zlibTests { - in := bytes.NewBuffer(tt.compressed); - zlib, err := NewInflater(in); + in := bytes.NewBuffer(tt.compressed) + zlib, err := NewInflater(in) if err != nil { if err != tt.err { t.Errorf("%s: NewInflater: %s", tt.desc, err) } - continue; + continue } - defer zlib.Close(); - b.Reset(); - n, err := io.Copy(b, zlib); + defer zlib.Close() + b.Reset() + n, err := io.Copy(b, zlib) if err != nil { if err != tt.err { t.Errorf("%s: io.Copy: %v want %v", tt.desc, err, tt.err) } - continue; + continue } - s := b.String(); + s := b.String() if s != tt.raw { t.Errorf("%s: got %d-byte %q want %d-byte %q", tt.desc, n, s, len(tt.raw), tt.raw) } diff --git a/src/pkg/compress/zlib/writer.go b/src/pkg/compress/zlib/writer.go index 25abcde3b..0441b0463 100644 --- a/src/pkg/compress/zlib/writer.go +++ b/src/pkg/compress/zlib/writer.go @@ -5,28 +5,28 @@ package zlib import ( - "compress/flate"; - "hash"; - "hash/adler32"; - "io"; - "os"; + "compress/flate" + "hash" + "hash/adler32" + "io" + "os" ) // These constants are copied from the flate package, so that code that imports // "compress/zlib" does not also have to import "compress/flate". const ( - NoCompression = flate.NoCompression; - BestSpeed = flate.BestSpeed; - BestCompression = flate.BestCompression; - DefaultCompression = flate.DefaultCompression; + NoCompression = flate.NoCompression + BestSpeed = flate.BestSpeed + BestCompression = flate.BestCompression + DefaultCompression = flate.DefaultCompression ) type writer struct { - w io.Writer; - deflater io.WriteCloser; - digest hash.Hash32; - err os.Error; - scratch [4]byte; + w io.Writer + deflater io.WriteCloser + digest hash.Hash32 + err os.Error + scratch [4]byte } // NewDeflater calls NewDeflaterLevel with the default compression level. @@ -39,11 +39,11 @@ func NewDeflater(w io.Writer) (io.WriteCloser, os.Error) { // level is the compression level, which can be DefaultCompression, NoCompression, // or any integer value between BestSpeed and BestCompression (inclusive). func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) { - z := new(writer); + z := new(writer) // ZLIB has a two-byte header (as documented in RFC 1950). // The first four bits is the CINFO (compression info), which is 7 for the default deflate window size. // The next four bits is the CM (compression method), which is 8 for deflate. - z.scratch[0] = 0x78; + z.scratch[0] = 0x78 // The next two bits is the FLEVEL (compression level). The four values are: // 0=fastest, 1=fast, 2=default, 3=best. // The next bit, FDICT, is unused, in this implementation. @@ -60,14 +60,14 @@ func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) { default: return nil, os.NewError("level out of range") } - _, err := w.Write(z.scratch[0:2]); + _, err := w.Write(z.scratch[0:2]) if err != nil { return nil, err } - z.w = w; - z.deflater = flate.NewDeflater(w, level); - z.digest = adler32.New(); - return z, nil; + z.w = w + z.deflater = flate.NewDeflater(w, level) + z.digest = adler32.New() + return z, nil } func (z *writer) Write(p []byte) (n int, err os.Error) { @@ -77,13 +77,13 @@ func (z *writer) Write(p []byte) (n int, err os.Error) { if len(p) == 0 { return 0, nil } - n, err = z.deflater.Write(p); + n, err = z.deflater.Write(p) if err != nil { - z.err = err; - return; + z.err = err + return } - z.digest.Write(p); - return; + z.digest.Write(p) + return } // Calling Close does not close the wrapped io.Writer originally passed to NewDeflater. @@ -91,16 +91,16 @@ func (z *writer) Close() os.Error { if z.err != nil { return z.err } - z.err = z.deflater.Close(); + z.err = z.deflater.Close() if z.err != nil { return z.err } - checksum := z.digest.Sum32(); + checksum := z.digest.Sum32() // ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952). - z.scratch[0] = uint8(checksum >> 24); - z.scratch[1] = uint8(checksum >> 16); - z.scratch[2] = uint8(checksum >> 8); - z.scratch[3] = uint8(checksum >> 0); - _, z.err = z.w.Write(z.scratch[0:4]); - return z.err; + z.scratch[0] = uint8(checksum >> 24) + z.scratch[1] = uint8(checksum >> 16) + z.scratch[2] = uint8(checksum >> 8) + z.scratch[3] = uint8(checksum >> 0) + _, z.err = z.w.Write(z.scratch[0:4]) + return z.err } diff --git a/src/pkg/compress/zlib/writer_test.go b/src/pkg/compress/zlib/writer_test.go index 963a072e9..97a9ed619 100644 --- a/src/pkg/compress/zlib/writer_test.go +++ b/src/pkg/compress/zlib/writer_test.go @@ -5,10 +5,10 @@ package zlib import ( - "io"; - "io/ioutil"; - "os"; - "testing"; + "io" + "io/ioutil" + "os" + "testing" ) var filenames = []string{ @@ -20,85 +20,85 @@ var filenames = []string{ // yields equivalent bytes to the original file. func testFileLevel(t *testing.T, fn string, level int) { // Read the file, as golden output. - golden, err := os.Open(fn, os.O_RDONLY, 0444); + golden, err := os.Open(fn, os.O_RDONLY, 0444) if err != nil { - t.Errorf("%s (level=%d): %v", fn, level, err); - return; + t.Errorf("%s (level=%d): %v", fn, level, err) + return } - defer golden.Close(); + defer golden.Close() // Read the file again, and push it through a pipe that compresses at the write end, and decompresses at the read end. - raw, err := os.Open(fn, os.O_RDONLY, 0444); + raw, err := os.Open(fn, os.O_RDONLY, 0444) if err != nil { - t.Errorf("%s (level=%d): %v", fn, level, err); - return; + t.Errorf("%s (level=%d): %v", fn, level, err) + return } - piper, pipew := io.Pipe(); - defer piper.Close(); + piper, pipew := io.Pipe() + defer piper.Close() go func() { - defer raw.Close(); - defer pipew.Close(); - zlibw, err := NewDeflaterLevel(pipew, level); + defer raw.Close() + defer pipew.Close() + zlibw, err := NewDeflaterLevel(pipew, level) if err != nil { - t.Errorf("%s (level=%d): %v", fn, level, err); - return; + t.Errorf("%s (level=%d): %v", fn, level, err) + return } - defer zlibw.Close(); - var b [1024]byte; + defer zlibw.Close() + var b [1024]byte for { - n, err0 := raw.Read(&b); + n, err0 := raw.Read(&b) if err0 != nil && err0 != os.EOF { - t.Errorf("%s (level=%d): %v", fn, level, err0); - return; + t.Errorf("%s (level=%d): %v", fn, level, err0) + return } - _, err1 := zlibw.Write(b[0:n]); + _, err1 := zlibw.Write(b[0:n]) if err1 == os.EPIPE { // Fail, but do not report the error, as some other (presumably reportable) error broke the pipe. return } if err1 != nil { - t.Errorf("%s (level=%d): %v", fn, level, err1); - return; + t.Errorf("%s (level=%d): %v", fn, level, err1) + return } if err0 == os.EOF { break } } - }(); - zlibr, err := NewInflater(piper); + }() + zlibr, err := NewInflater(piper) if err != nil { - t.Errorf("%s (level=%d): %v", fn, level, err); - return; + t.Errorf("%s (level=%d): %v", fn, level, err) + return } - defer zlibr.Close(); + defer zlibr.Close() // Compare the two. - b0, err0 := ioutil.ReadAll(golden); - b1, err1 := ioutil.ReadAll(zlibr); + b0, err0 := ioutil.ReadAll(golden) + b1, err1 := ioutil.ReadAll(zlibr) if err0 != nil { - t.Errorf("%s (level=%d): %v", fn, level, err0); - return; + t.Errorf("%s (level=%d): %v", fn, level, err0) + return } if err1 != nil { - t.Errorf("%s (level=%d): %v", fn, level, err1); - return; + t.Errorf("%s (level=%d): %v", fn, level, err1) + return } if len(b0) != len(b1) { - t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1)); - return; + t.Errorf("%s (level=%d): length mismatch %d versus %d", fn, level, len(b0), len(b1)) + return } for i := 0; i < len(b0); i++ { if b0[i] != b1[i] { - t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i]); - return; + t.Errorf("%s (level=%d): mismatch at %d, 0x%02x versus 0x%02x\n", fn, level, i, b0[i], b1[i]) + return } } } func TestWriter(t *testing.T) { for _, fn := range filenames { - testFileLevel(t, fn, DefaultCompression); - testFileLevel(t, fn, NoCompression); + testFileLevel(t, fn, DefaultCompression) + testFileLevel(t, fn, NoCompression) for level := BestSpeed; level <= BestCompression; level++ { testFileLevel(t, fn, level) } diff --git a/src/pkg/container/heap/heap.go b/src/pkg/container/heap/heap.go index 7a7cb9b80..4435a57c4 100644 --- a/src/pkg/container/heap/heap.go +++ b/src/pkg/container/heap/heap.go @@ -16,9 +16,9 @@ import "sort" // !h.Less(j, i) for 0 <= i < h.Len() and j = 2*i+1 or 2*i+2 and j < h.Len() // type Interface interface { - sort.Interface; - Push(x interface{}); - Pop() interface{}; + sort.Interface + Push(x interface{}) + Pop() interface{} } @@ -29,7 +29,7 @@ type Interface interface { // func Init(h Interface) { // heapify - n := h.Len(); + n := h.Len() for i := n/2 - 1; i >= 0; i-- { down(h, i, n) } @@ -40,8 +40,8 @@ func Init(h Interface) { // O(log(n)) where n = h.Len(). // func Push(h Interface, x interface{}) { - h.Push(x); - up(h, h.Len()-1); + h.Push(x) + up(h, h.Len()-1) } @@ -50,10 +50,10 @@ func Push(h Interface, x interface{}) { // Same as Remove(h, 0). // func Pop(h Interface) interface{} { - n := h.Len() - 1; - h.Swap(0, n); - down(h, 0, n); - return h.Pop(); + n := h.Len() - 1 + h.Swap(0, n) + down(h, 0, n) + return h.Pop() } @@ -61,42 +61,42 @@ func Pop(h Interface) interface{} { // The complexity is O(log(n)) where n = h.Len(). // func Remove(h Interface, i int) interface{} { - n := h.Len() - 1; + n := h.Len() - 1 if n != i { - h.Swap(i, n); - down(h, i, n); - up(h, i); + h.Swap(i, n) + down(h, i, n) + up(h, i) } - return h.Pop(); + return h.Pop() } func up(h Interface, j int) { for { - i := (j - 1) / 2; // parent + i := (j - 1) / 2 // parent if i == j || h.Less(i, j) { break } - h.Swap(i, j); - j = i; + h.Swap(i, j) + j = i } } func down(h Interface, i, n int) { for { - j1 := 2*i + 1; + j1 := 2*i + 1 if j1 >= n { break } - j := j1; // left child + j := j1 // left child if j2 := j1 + 1; j2 < n && !h.Less(j1, j2) { - j = j2 // = 2*i + 2 // right child + j = j2 // = 2*i + 2 // right child } if h.Less(i, j) { break } - h.Swap(i, j); - i = j; + h.Swap(i, j) + i = j } } diff --git a/src/pkg/container/heap/heap_test.go b/src/pkg/container/heap/heap_test.go index dc13201cd..8130555f3 100644 --- a/src/pkg/container/heap/heap_test.go +++ b/src/pkg/container/heap/heap_test.go @@ -5,53 +5,53 @@ package heap import ( - "testing"; - "container/vector"; + "testing" + "container/vector" ) type myHeap struct { // A vector.Vector implements sort.Interface except for Less, // and it implements Push and Pop as required for heap.Interface. - vector.Vector; + vector.Vector } -func (h *myHeap) Less(i, j int) bool { return h.At(i).(int) < h.At(j).(int) } +func (h *myHeap) Less(i, j int) bool { return h.At(i).(int) < h.At(j).(int) } func (h *myHeap) verify(t *testing.T, i int) { - n := h.Len(); - j1 := 2*i + 1; - j2 := 2*i + 2; + n := h.Len() + j1 := 2*i + 1 + j2 := 2*i + 2 if j1 < n { if h.Less(j1, i) { - t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j1)); - return; + t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j1)) + return } - h.verify(t, j1); + h.verify(t, j1) } if j2 < n { if h.Less(j2, i) { - t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j2)); - return; + t.Errorf("heap invariant invalidated [%d] = %d > [%d] = %d", i, h.At(i), j1, h.At(j2)) + return } - h.verify(t, j2); + h.verify(t, j2) } } func TestInit0(t *testing.T) { - h := new(myHeap); + h := new(myHeap) for i := 20; i > 0; i-- { - h.Push(0) // all elements are the same + h.Push(0) // all elements are the same } - Init(h); - h.verify(t, 0); + Init(h) + h.verify(t, 0) for i := 1; h.Len() > 0; i++ { - x := Pop(h).(int); - h.verify(t, 0); + x := Pop(h).(int) + h.verify(t, 0) if x != 0 { t.Errorf("%d.th pop got %d; want %d", i, x, 0) } @@ -60,16 +60,16 @@ func TestInit0(t *testing.T) { func TestInit1(t *testing.T) { - h := new(myHeap); + h := new(myHeap) for i := 20; i > 0; i-- { - h.Push(i) // all elements are different + h.Push(i) // all elements are different } - Init(h); - h.verify(t, 0); + Init(h) + h.verify(t, 0) for i := 1; h.Len() > 0; i++ { - x := Pop(h).(int); - h.verify(t, 0); + x := Pop(h).(int) + h.verify(t, 0) if x != i { t.Errorf("%d.th pop got %d; want %d", i, x, i) } @@ -78,26 +78,26 @@ func TestInit1(t *testing.T) { func Test(t *testing.T) { - h := new(myHeap); - h.verify(t, 0); + h := new(myHeap) + h.verify(t, 0) for i := 20; i > 10; i-- { h.Push(i) } - Init(h); - h.verify(t, 0); + Init(h) + h.verify(t, 0) for i := 10; i > 0; i-- { - Push(h, i); - h.verify(t, 0); + Push(h, i) + h.verify(t, 0) } for i := 1; h.Len() > 0; i++ { - x := Pop(h).(int); + x := Pop(h).(int) if i < 20 { Push(h, 20+i) } - h.verify(t, 0); + h.verify(t, 0) if x != i { t.Errorf("%d.th pop got %d; want %d", i, x, i) } @@ -106,53 +106,53 @@ func Test(t *testing.T) { func TestRemove0(t *testing.T) { - h := new(myHeap); + h := new(myHeap) for i := 0; i < 10; i++ { h.Push(i) } - h.verify(t, 0); + h.verify(t, 0) for h.Len() > 0 { - i := h.Len() - 1; - x := Remove(h, i).(int); + i := h.Len() - 1 + x := Remove(h, i).(int) if x != i { t.Errorf("Remove(%d) got %d; want %d", i, x, i) } - h.verify(t, 0); + h.verify(t, 0) } } func TestRemove1(t *testing.T) { - h := new(myHeap); + h := new(myHeap) for i := 0; i < 10; i++ { h.Push(i) } - h.verify(t, 0); + h.verify(t, 0) for i := 0; h.Len() > 0; i++ { - x := Remove(h, 0).(int); + x := Remove(h, 0).(int) if x != i { t.Errorf("Remove(0) got %d; want %d", x, i) } - h.verify(t, 0); + h.verify(t, 0) } } func TestRemove2(t *testing.T) { - N := 10; + N := 10 - h := new(myHeap); + h := new(myHeap) for i := 0; i < N; i++ { h.Push(i) } - h.verify(t, 0); + h.verify(t, 0) - m := make(map[int]int); + m := make(map[int]int) for h.Len() > 0 { - m[Remove(h, (h.Len()-1)/2).(int)] = 1; - h.verify(t, 0); + m[Remove(h, (h.Len()-1)/2).(int)] = 1 + h.verify(t, 0) } if len(m) != N { diff --git a/src/pkg/container/list/list.go b/src/pkg/container/list/list.go index b7b392cea..9429c90a7 100644 --- a/src/pkg/container/list/list.go +++ b/src/pkg/container/list/list.go @@ -9,45 +9,45 @@ package list type Element struct { // Next and previous pointers in the doubly-linked list of elements. // The front of the list has prev = nil, and the back has next = nil. - next, prev *Element; + next, prev *Element // A unique ID for the list to which this element belongs. - id *byte; + id *byte // The contents of this list element. - Value interface{}; + Value interface{} } // Next returns the next list element or nil. -func (e *Element) Next() *Element { return e.next } +func (e *Element) Next() *Element { return e.next } // Prev returns the previous list element or nil. -func (e *Element) Prev() *Element { return e.prev } +func (e *Element) Prev() *Element { return e.prev } // List represents a doubly linked list. type List struct { - front, back *Element; - len int; - id *byte; + front, back *Element + len int + id *byte } // Init initializes or clears a List. func (l *List) Init() *List { - l.front = nil; - l.back = nil; - l.len = 0; - l.id = new(byte); - return l; + l.front = nil + l.back = nil + l.len = 0 + l.id = new(byte) + return l } // New returns an initialized list. -func New() *List { return new(List).Init() } +func New() *List { return new(List).Init() } // Front returns the first element in the list. -func (l *List) Front() *Element { return l.front } +func (l *List) Front() *Element { return l.front } // Back returns the last element in the list. -func (l *List) Back() *Element { return l.back } +func (l *List) Back() *Element { return l.back } // Remove removes the element from the list. func (l *List) Remove(e *Element) { @@ -65,9 +65,9 @@ func (l *List) Remove(e *Element) { e.next.prev = e.prev } - e.prev = nil; - e.next = nil; - l.len--; + e.prev = nil + e.next = nil + l.len-- } func (l *List) insertBefore(e *Element, mark *Element) { @@ -77,10 +77,10 @@ func (l *List) insertBefore(e *Element, mark *Element) { } else { mark.prev.next = e } - e.prev = mark.prev; - mark.prev = e; - e.next = mark; - l.len++; + e.prev = mark.prev + mark.prev = e + e.next = mark + l.len++ } func (l *List) insertAfter(e *Element, mark *Element) { @@ -90,32 +90,32 @@ func (l *List) insertAfter(e *Element, mark *Element) { } else { mark.next.prev = e } - e.next = mark.next; - mark.next = e; - e.prev = mark; - l.len++; + e.next = mark.next + mark.next = e + e.prev = mark + l.len++ } func (l *List) insertFront(e *Element) { if l.front == nil { // empty list - l.front, l.back = e, e; - e.prev, e.next = nil, nil; - l.len = 1; - return; + l.front, l.back = e, e + e.prev, e.next = nil, nil + l.len = 1 + return } - l.insertBefore(e, l.front); + l.insertBefore(e, l.front) } func (l *List) insertBack(e *Element) { if l.back == nil { // empty list - l.front, l.back = e, e; - e.prev, e.next = nil, nil; - l.len = 1; - return; + l.front, l.back = e, e + e.prev, e.next = nil, nil + l.len = 1 + return } - l.insertAfter(e, l.back); + l.insertAfter(e, l.back) } // PushFront inserts the value at the front of the list and returns a new Element containing the value. @@ -123,9 +123,9 @@ func (l *List) PushFront(value interface{}) *Element { if l.id == nil { l.Init() } - e := &Element{nil, nil, l.id, value}; - l.insertFront(e); - return e; + e := &Element{nil, nil, l.id, value} + l.insertFront(e) + return e } // PushBack inserts the value at the back of the list and returns a new Element containing the value. @@ -133,9 +133,9 @@ func (l *List) PushBack(value interface{}) *Element { if l.id == nil { l.Init() } - e := &Element{nil, nil, l.id, value}; - l.insertBack(e); - return e; + e := &Element{nil, nil, l.id, value} + l.insertBack(e) + return e } // InsertBefore inserts the value immediately before mark and returns a new Element containing the value. @@ -143,9 +143,9 @@ func (l *List) InsertBefore(value interface{}, mark *Element) *Element { if mark.id != l.id { return nil } - e := &Element{nil, nil, l.id, value}; - l.insertBefore(e, mark); - return e; + e := &Element{nil, nil, l.id, value} + l.insertBefore(e, mark) + return e } // InsertAfter inserts the value immediately after mark and returns a new Element containing the value. @@ -153,9 +153,9 @@ func (l *List) InsertAfter(value interface{}, mark *Element) *Element { if mark.id != l.id { return nil } - e := &Element{nil, nil, l.id, value}; - l.insertAfter(e, mark); - return e; + e := &Element{nil, nil, l.id, value} + l.insertAfter(e, mark) + return e } // MoveToFront moves the element to the front of the list. @@ -163,8 +163,8 @@ func (l *List) MoveToFront(e *Element) { if e.id != l.id || l.front == e { return } - l.Remove(e); - l.insertFront(e); + l.Remove(e) + l.insertFront(e) } // MoveToBack moves the element to the back of the list. @@ -172,22 +172,22 @@ func (l *List) MoveToBack(e *Element) { if e.id != l.id || l.back == e { return } - l.Remove(e); - l.insertBack(e); + l.Remove(e) + l.insertBack(e) } // Len returns the number of elements in the list. -func (l *List) Len() int { return l.len } +func (l *List) Len() int { return l.len } func (l *List) iterate(c chan<- interface{}) { for e := l.front; e != nil; e = e.next { c <- e.Value } - close(c); + close(c) } func (l *List) Iter() <-chan interface{} { - c := make(chan interface{}); - go l.iterate(c); - return c; + c := make(chan interface{}) + go l.iterate(c) + return c } diff --git a/src/pkg/container/list/list_test.go b/src/pkg/container/list/list_test.go index 52df37f56..846937a38 100644 --- a/src/pkg/container/list/list_test.go +++ b/src/pkg/container/list/list_test.go @@ -5,7 +5,7 @@ package list import ( - "testing"; + "testing" ) func checkListPointers(t *testing.T, l *List, es []*Element) { @@ -13,7 +13,7 @@ func checkListPointers(t *testing.T, l *List, es []*Element) { if l.front != nil || l.back != nil { t.Errorf("l.front/l.back = %v/%v should be nil/nil", l.front, l.back) } - return; + return } if l.front != es[0] { @@ -24,8 +24,8 @@ func checkListPointers(t *testing.T, l *List, es []*Element) { } for i := 0; i < len(es); i++ { - e := es[i]; - var e_prev, e_next *Element = nil, nil; + e := es[i] + var e_prev, e_next *Element = nil, nil if i > 0 { e_prev = es[i-1] } @@ -48,74 +48,74 @@ func checkListLen(t *testing.T, l *List, n int) { } func TestList(t *testing.T) { - l := New(); - checkListPointers(t, l, []*Element{}); - checkListLen(t, l, 0); + l := New() + checkListPointers(t, l, []*Element{}) + checkListLen(t, l, 0) // Single element list - e := l.PushFront("a"); - checkListLen(t, l, 1); - checkListPointers(t, l, []*Element{e}); - l.MoveToFront(e); - checkListPointers(t, l, []*Element{e}); - l.MoveToBack(e); - checkListPointers(t, l, []*Element{e}); - checkListLen(t, l, 1); - l.Remove(e); - checkListPointers(t, l, []*Element{}); - checkListLen(t, l, 0); + e := l.PushFront("a") + checkListLen(t, l, 1) + checkListPointers(t, l, []*Element{e}) + l.MoveToFront(e) + checkListPointers(t, l, []*Element{e}) + l.MoveToBack(e) + checkListPointers(t, l, []*Element{e}) + checkListLen(t, l, 1) + l.Remove(e) + checkListPointers(t, l, []*Element{}) + checkListLen(t, l, 0) // Bigger list - e2 := l.PushFront(2); - e1 := l.PushFront(1); - e3 := l.PushBack(3); - e4 := l.PushBack("banana"); - checkListPointers(t, l, []*Element{e1, e2, e3, e4}); - checkListLen(t, l, 4); - - l.Remove(e2); - checkListPointers(t, l, []*Element{e1, e3, e4}); - checkListLen(t, l, 3); - - l.MoveToFront(e3); // move from middle - checkListPointers(t, l, []*Element{e3, e1, e4}); - - l.MoveToFront(e1); - l.MoveToBack(e3); // move from middle - checkListPointers(t, l, []*Element{e1, e4, e3}); - - l.MoveToFront(e3); // move from back - checkListPointers(t, l, []*Element{e3, e1, e4}); - l.MoveToFront(e3); // should be no-op - checkListPointers(t, l, []*Element{e3, e1, e4}); - - l.MoveToBack(e3); // move from front - checkListPointers(t, l, []*Element{e1, e4, e3}); - l.MoveToBack(e3); // should be no-op - checkListPointers(t, l, []*Element{e1, e4, e3}); - - e2 = l.InsertBefore(2, e1); // insert before front - checkListPointers(t, l, []*Element{e2, e1, e4, e3}); - l.Remove(e2); - e2 = l.InsertBefore(2, e4); // insert before middle - checkListPointers(t, l, []*Element{e1, e2, e4, e3}); - l.Remove(e2); - e2 = l.InsertBefore(2, e3); // insert before back - checkListPointers(t, l, []*Element{e1, e4, e2, e3}); - l.Remove(e2); - - e2 = l.InsertAfter(2, e1); // insert after front - checkListPointers(t, l, []*Element{e1, e2, e4, e3}); - l.Remove(e2); - e2 = l.InsertAfter(2, e4); // insert after middle - checkListPointers(t, l, []*Element{e1, e4, e2, e3}); - l.Remove(e2); - e2 = l.InsertAfter(2, e3); // insert after back - checkListPointers(t, l, []*Element{e1, e4, e3, e2}); - l.Remove(e2); + e2 := l.PushFront(2) + e1 := l.PushFront(1) + e3 := l.PushBack(3) + e4 := l.PushBack("banana") + checkListPointers(t, l, []*Element{e1, e2, e3, e4}) + checkListLen(t, l, 4) + + l.Remove(e2) + checkListPointers(t, l, []*Element{e1, e3, e4}) + checkListLen(t, l, 3) + + l.MoveToFront(e3) // move from middle + checkListPointers(t, l, []*Element{e3, e1, e4}) + + l.MoveToFront(e1) + l.MoveToBack(e3) // move from middle + checkListPointers(t, l, []*Element{e1, e4, e3}) + + l.MoveToFront(e3) // move from back + checkListPointers(t, l, []*Element{e3, e1, e4}) + l.MoveToFront(e3) // should be no-op + checkListPointers(t, l, []*Element{e3, e1, e4}) + + l.MoveToBack(e3) // move from front + checkListPointers(t, l, []*Element{e1, e4, e3}) + l.MoveToBack(e3) // should be no-op + checkListPointers(t, l, []*Element{e1, e4, e3}) + + e2 = l.InsertBefore(2, e1) // insert before front + checkListPointers(t, l, []*Element{e2, e1, e4, e3}) + l.Remove(e2) + e2 = l.InsertBefore(2, e4) // insert before middle + checkListPointers(t, l, []*Element{e1, e2, e4, e3}) + l.Remove(e2) + e2 = l.InsertBefore(2, e3) // insert before back + checkListPointers(t, l, []*Element{e1, e4, e2, e3}) + l.Remove(e2) + + e2 = l.InsertAfter(2, e1) // insert after front + checkListPointers(t, l, []*Element{e1, e2, e4, e3}) + l.Remove(e2) + e2 = l.InsertAfter(2, e4) // insert after middle + checkListPointers(t, l, []*Element{e1, e4, e2, e3}) + l.Remove(e2) + e2 = l.InsertAfter(2, e3) // insert after back + checkListPointers(t, l, []*Element{e1, e4, e3, e2}) + l.Remove(e2) // Check standard iteration. - sum := 0; + sum := 0 for e := range l.Iter() { if i, ok := e.(int); ok { sum += i @@ -126,11 +126,11 @@ func TestList(t *testing.T) { } // Clear all elements by iterating - var next *Element; + var next *Element for e := l.Front(); e != nil; e = next { - next = e.Next(); - l.Remove(e); + next = e.Next() + l.Remove(e) } - checkListPointers(t, l, []*Element{}); - checkListLen(t, l, 0); + checkListPointers(t, l, []*Element{}) + checkListLen(t, l, 0) } diff --git a/src/pkg/container/ring/ring.go b/src/pkg/container/ring/ring.go index 5fcdfc366..335afbc3c 100644 --- a/src/pkg/container/ring/ring.go +++ b/src/pkg/container/ring/ring.go @@ -12,15 +12,15 @@ package ring // ring with a nil Value. // type Ring struct { - next, prev *Ring; - Value interface{}; // for use by client; untouched by this library + next, prev *Ring + Value interface{} // for use by client; untouched by this library } func (r *Ring) init() *Ring { - r.next = r; - r.prev = r; - return r; + r.next = r + r.prev = r + return r } @@ -29,7 +29,7 @@ func (r *Ring) Next() *Ring { if r.next == nil { return r.init() } - return r.next; + return r.next } @@ -38,7 +38,7 @@ func (r *Ring) Prev() *Ring { if r.next == nil { return r.init() } - return r.prev; + return r.prev } @@ -59,7 +59,7 @@ func (r *Ring) Move(n int) *Ring { r = r.next } } - return r; + return r } @@ -68,15 +68,15 @@ func New(n int) *Ring { if n <= 0 { return nil } - r := new(Ring); - p := r; + r := new(Ring) + p := r for i := 1; i < n; i++ { - p.next = &Ring{prev: p}; - p = p.next; + p.next = &Ring{prev: p} + p = p.next } - p.next = r; - r.prev = p; - return r; + p.next = r + r.prev = p + return r } @@ -97,17 +97,17 @@ func New(n int) *Ring { // last element of s after insertion. // func (r *Ring) Link(s *Ring) *Ring { - n := r.Next(); + n := r.Next() if s != nil { - p := s.Prev(); + p := s.Prev() // Note: Cannot use multiple assignment because // evaluation order of LHS is not specified. - r.next = s; - s.prev = r; - n.prev = p; - p.next = n; + r.next = s + s.prev = r + n.prev = p + p.next = n } - return n; + return n } @@ -119,7 +119,7 @@ func (r *Ring) Unlink(n int) *Ring { if n <= 0 { return nil } - return r.Link(r.Move(n + 1)); + return r.Link(r.Move(n + 1)) } @@ -127,27 +127,27 @@ func (r *Ring) Unlink(n int) *Ring { // It executes in time proportional to the number of elements. // func (r *Ring) Len() int { - n := 0; + n := 0 if r != nil { - n = 1; + n = 1 for p := r.Next(); p != r; p = p.next { n++ } } - return n; + return n } func (r *Ring) Iter() <-chan interface{} { - c := make(chan interface{}); + c := make(chan interface{}) go func() { if r != nil { - c <- r.Value; + c <- r.Value for p := r.Next(); p != r; p = p.next { c <- p.Value } } - close(c); - }(); - return c; + close(c) + }() + return c } diff --git a/src/pkg/container/ring/ring_test.go b/src/pkg/container/ring/ring_test.go index b55f438fa..ee3c41128 100644 --- a/src/pkg/container/ring/ring_test.go +++ b/src/pkg/container/ring/ring_test.go @@ -5,38 +5,38 @@ package ring import ( - "fmt"; - "testing"; + "fmt" + "testing" ) // For debugging - keep around. func dump(r *Ring) { if r == nil { - fmt.Println("empty"); - return; + fmt.Println("empty") + return } - i, n := 0, r.Len(); + i, n := 0, r.Len() for p := r; i < n; p = p.next { - fmt.Printf("%4d: %p = {<- %p | %p ->}\n", i, p, p.prev, p.next); - i++; + fmt.Printf("%4d: %p = {<- %p | %p ->}\n", i, p, p.prev, p.next) + i++ } - fmt.Println(); + fmt.Println() } func verify(t *testing.T, r *Ring, N int, sum int) { // Len - n := r.Len(); + n := r.Len() if n != N { t.Errorf("r.Len() == %d; expected %d", n, N) } // iteration - n = 0; - s := 0; + n = 0 + s := 0 for p := range r.Iter() { - n++; + n++ if p != nil { s += p.(int) } @@ -54,12 +54,12 @@ func verify(t *testing.T, r *Ring, N int, sum int) { // connections if r.next != nil { - var p *Ring; // previous element + var p *Ring // previous element for q := r; p == nil || q != r; q = q.next { if p != nil && p != q.prev { t.Errorf("prev = %p, expected q.prev = %p\n", p, q.prev) } - p = q; + p = q } if p != r.prev { t.Errorf("prev = %p, expected r.prev = %p\n", p, r.prev) @@ -85,8 +85,8 @@ func verify(t *testing.T, r *Ring, N int, sum int) { t.Errorf("r.Move(%d) != r", -N) } for i := 0; i < 10; i++ { - ni := N + i; - mi := ni % N; + ni := N + i + mi := ni % N if r.Move(ni) != r.Move(mi) { t.Errorf("r.Move(%d) != r.Move(%d)", ni, mi) } @@ -99,142 +99,142 @@ func verify(t *testing.T, r *Ring, N int, sum int) { func TestCornerCases(t *testing.T) { var ( - r0 *Ring; - r1 Ring; + r0 *Ring + r1 Ring ) // Basics - verify(t, r0, 0, 0); - verify(t, &r1, 1, 0); + verify(t, r0, 0, 0) + verify(t, &r1, 1, 0) // Insert - r1.Link(r0); - verify(t, r0, 0, 0); - verify(t, &r1, 1, 0); + r1.Link(r0) + verify(t, r0, 0, 0) + verify(t, &r1, 1, 0) // Insert - r1.Link(r0); - verify(t, r0, 0, 0); - verify(t, &r1, 1, 0); + r1.Link(r0) + verify(t, r0, 0, 0) + verify(t, &r1, 1, 0) // Unlink - r1.Unlink(0); - verify(t, &r1, 1, 0); + r1.Unlink(0) + verify(t, &r1, 1, 0) } func makeN(n int) *Ring { - r := New(n); + r := New(n) for i := 1; i <= n; i++ { - r.Value = i; - r = r.Next(); + r.Value = i + r = r.Next() } - return r; + return r } func sum(r *Ring) int { - s := 0; + s := 0 for p := range r.Iter() { s += p.(int) } - return s; + return s } -func sumN(n int) int { return (n*n + n) / 2 } +func sumN(n int) int { return (n*n + n) / 2 } func TestNew(t *testing.T) { for i := 0; i < 10; i++ { - r := New(i); - verify(t, r, i, -1); + r := New(i) + verify(t, r, i, -1) } for i := 0; i < 10; i++ { - r := makeN(i); - verify(t, r, i, sumN(i)); + r := makeN(i) + verify(t, r, i, sumN(i)) } } func TestLink1(t *testing.T) { - r1a := makeN(1); - var r1b Ring; - r2a := r1a.Link(&r1b); - verify(t, r2a, 2, 1); + r1a := makeN(1) + var r1b Ring + r2a := r1a.Link(&r1b) + verify(t, r2a, 2, 1) if r2a != r1a { t.Errorf("a) 2-element link failed") } - r2b := r2a.Link(r2a.Next()); - verify(t, r2b, 2, 1); + r2b := r2a.Link(r2a.Next()) + verify(t, r2b, 2, 1) if r2b != r2a.Next() { t.Errorf("b) 2-element link failed") } - r1c := r2b.Link(r2b); - verify(t, r1c, 1, 1); - verify(t, r2b, 1, 0); + r1c := r2b.Link(r2b) + verify(t, r1c, 1, 1) + verify(t, r2b, 1, 0) } func TestLink2(t *testing.T) { - var r0 *Ring; - r1a := &Ring{Value: 42}; - r1b := &Ring{Value: 77}; - r10 := makeN(10); + var r0 *Ring + r1a := &Ring{Value: 42} + r1b := &Ring{Value: 77} + r10 := makeN(10) - r1a.Link(r0); - verify(t, r1a, 1, 42); + r1a.Link(r0) + verify(t, r1a, 1, 42) - r1a.Link(r1b); - verify(t, r1a, 2, 42+77); + r1a.Link(r1b) + verify(t, r1a, 2, 42+77) - r10.Link(r0); - verify(t, r10, 10, sumN(10)); + r10.Link(r0) + verify(t, r10, 10, sumN(10)) - r10.Link(r1a); - verify(t, r10, 12, sumN(10)+42+77); + r10.Link(r1a) + verify(t, r10, 12, sumN(10)+42+77) } func TestLink3(t *testing.T) { - var r Ring; - n := 1; + var r Ring + n := 1 for i := 1; i < 100; i++ { - n += i; - verify(t, r.Link(New(i)), n, -1); + n += i + verify(t, r.Link(New(i)), n, -1) } } func TestUnlink(t *testing.T) { - r10 := makeN(10); - s10 := r10.Move(6); + r10 := makeN(10) + s10 := r10.Move(6) - sum10 := sumN(10); + sum10 := sumN(10) - verify(t, r10, 10, sum10); - verify(t, s10, 10, sum10); + verify(t, r10, 10, sum10) + verify(t, s10, 10, sum10) - r0 := r10.Unlink(0); - verify(t, r0, 0, 0); + r0 := r10.Unlink(0) + verify(t, r0, 0, 0) - r1 := r10.Unlink(1); - verify(t, r1, 1, 2); - verify(t, r10, 9, sum10-2); + r1 := r10.Unlink(1) + verify(t, r1, 1, 2) + verify(t, r10, 9, sum10-2) - r9 := r10.Unlink(9); - verify(t, r9, 9, sum10-2); - verify(t, r10, 9, sum10-2); + r9 := r10.Unlink(9) + verify(t, r9, 9, sum10-2) + verify(t, r10, 9, sum10-2) } func TestLinkUnlink(t *testing.T) { for i := 1; i < 4; i++ { - ri := New(i); + ri := New(i) for j := 0; j < i; j++ { - rj := ri.Unlink(j); - verify(t, rj, j, -1); - verify(t, ri, i-j, -1); - ri.Link(rj); - verify(t, ri, i, -1); + rj := ri.Unlink(j) + verify(t, rj, j, -1) + verify(t, ri, i-j, -1) + ri.Link(rj) + verify(t, ri, i, -1) } } } diff --git a/src/pkg/container/vector/intvector.go b/src/pkg/container/vector/intvector.go index 43f8ff808..1ec4b85a9 100644 --- a/src/pkg/container/vector/intvector.go +++ b/src/pkg/container/vector/intvector.go @@ -7,7 +7,7 @@ package vector // IntVector is a specialization of Vector that hides the wrapping of Elements around ints. type IntVector struct { - Vector; + Vector } @@ -17,40 +17,40 @@ type IntVector struct { // Resize adds 0 elements. The capacity parameter is ignored unless the // new length or capacity is longer that the current capacity. func (p *IntVector) Resize(length, capacity int) *IntVector { - i := p.Len(); - p.Vector.Resize(length, capacity); + i := p.Len() + p.Vector.Resize(length, capacity) for a := p.a; i < len(a); i++ { a[i] = 0 } - return p; + return p } // At returns the i'th element of the vector. -func (p *IntVector) At(i int) int { return p.Vector.At(i).(int) } +func (p *IntVector) At(i int) int { return p.Vector.At(i).(int) } // Set sets the i'th element of the vector to value x. -func (p *IntVector) Set(i int, x int) { p.a[i] = x } +func (p *IntVector) Set(i int, x int) { p.a[i] = x } // Last returns the element in the vector of highest index. -func (p *IntVector) Last() int { return p.Vector.Last().(int) } +func (p *IntVector) Last() int { return p.Vector.Last().(int) } // Data returns all the elements as a slice. func (p *IntVector) Data() []int { - arr := make([]int, p.Len()); + arr := make([]int, p.Len()) for i, v := range p.a { arr[i] = v.(int) } - return arr; + return arr } // Insert inserts into the vector an element of value x before // the current element at index i. -func (p *IntVector) Insert(i int, x int) { p.Vector.Insert(i, x) } +func (p *IntVector) Insert(i int, x int) { p.Vector.Insert(i, x) } // InsertVector inserts into the vector the contents of the Vector @@ -68,11 +68,11 @@ func (p *IntVector) Slice(i, j int) *IntVector { // Push appends x to the end of the vector. -func (p *IntVector) Push(x int) { p.Vector.Push(x) } +func (p *IntVector) Push(x int) { p.Vector.Push(x) } // Pop deletes and returns the last element of the vector. -func (p *IntVector) Pop() int { return p.Vector.Pop().(int) } +func (p *IntVector) Pop() int { return p.Vector.Pop().(int) } // AppendVector appends the entire IntVector x to the end of this vector. @@ -83,7 +83,7 @@ func (p *IntVector) AppendVector(x *IntVector) { // sort.Interface support // Less returns a boolean denoting whether the i'th element is less than the j'th element. -func (p *IntVector) Less(i, j int) bool { return p.At(i) < p.At(j) } +func (p *IntVector) Less(i, j int) bool { return p.At(i) < p.At(j) } // Iterate over all elements; driver for range @@ -91,13 +91,13 @@ func (p *IntVector) iterate(c chan<- int) { for _, v := range p.a { c <- v.(int) } - close(c); + close(c) } // Channel iterator for range. func (p *IntVector) Iter() <-chan int { - c := make(chan int); - go p.iterate(c); - return c; + c := make(chan int) + go p.iterate(c) + return c } diff --git a/src/pkg/container/vector/stringvector.go b/src/pkg/container/vector/stringvector.go index 93a4197a5..821a7a101 100644 --- a/src/pkg/container/vector/stringvector.go +++ b/src/pkg/container/vector/stringvector.go @@ -6,7 +6,7 @@ package vector // StringVector is a specialization of Vector that hides the wrapping of Elements around strings. type StringVector struct { - Vector; + Vector } @@ -16,34 +16,34 @@ type StringVector struct { // Resize adds "" elements. The capacity parameter is ignored unless the // new length or capacity is longer that the current capacity. func (p *StringVector) Resize(length, capacity int) *StringVector { - i := p.Len(); - p.Vector.Resize(length, capacity); + i := p.Len() + p.Vector.Resize(length, capacity) for a := p.a; i < len(a); i++ { a[i] = "" } - return p; + return p } // At returns the i'th element of the vector. -func (p *StringVector) At(i int) string { return p.Vector.At(i).(string) } +func (p *StringVector) At(i int) string { return p.Vector.At(i).(string) } // Set sets the i'th element of the vector to value x. -func (p *StringVector) Set(i int, x string) { p.a[i] = x } +func (p *StringVector) Set(i int, x string) { p.a[i] = x } // Last returns the element in the vector of highest index. -func (p *StringVector) Last() string { return p.Vector.Last().(string) } +func (p *StringVector) Last() string { return p.Vector.Last().(string) } // Data returns all the elements as a slice. func (p *StringVector) Data() []string { - arr := make([]string, p.Len()); + arr := make([]string, p.Len()) for i, v := range p.a { arr[i] = v.(string) } - return arr; + return arr } @@ -69,11 +69,11 @@ func (p *StringVector) Slice(i, j int) *StringVector { // Push appends x to the end of the vector. -func (p *StringVector) Push(x string) { p.Vector.Push(x) } +func (p *StringVector) Push(x string) { p.Vector.Push(x) } // Pop deletes and returns the last element of the vector. -func (p *StringVector) Pop() string { return p.Vector.Pop().(string) } +func (p *StringVector) Pop() string { return p.Vector.Pop().(string) } // AppendVector appends the entire StringVector x to the end of this vector. @@ -84,7 +84,7 @@ func (p *StringVector) AppendVector(x *StringVector) { // sort.Interface support // Less returns a boolean denoting whether the i'th element is less than the j'th element. -func (p *StringVector) Less(i, j int) bool { return p.At(i) < p.At(j) } +func (p *StringVector) Less(i, j int) bool { return p.At(i) < p.At(j) } // Iterate over all elements; driver for range @@ -92,13 +92,13 @@ func (p *StringVector) iterate(c chan<- string) { for _, v := range p.a { c <- v.(string) } - close(c); + close(c) } // Channel iterator for range. func (p *StringVector) Iter() <-chan string { - c := make(chan string); - go p.iterate(c); - return c; + c := make(chan string) + go p.iterate(c) + return c } diff --git a/src/pkg/container/vector/vector.go b/src/pkg/container/vector/vector.go index 0408490be..ed1845b27 100644 --- a/src/pkg/container/vector/vector.go +++ b/src/pkg/container/vector/vector.go @@ -9,8 +9,8 @@ package vector // Vector is the container itself. // The zero value for Vector is an empty vector ready to use. type Vector struct { - a []interface{}; - bootstrap [8]interface{}; + a []interface{} + bootstrap [8]interface{} } @@ -21,31 +21,31 @@ func (p *Vector) realloc(length, capacity int) (b []interface{}) { } else { b = make([]interface{}, length, capacity) } - copy(b, p.a); - p.a = b; - return; + copy(b, p.a) + p.a = b + return } // Insert n elements at position i. func (p *Vector) expand(i, n int) { - a := p.a; + a := p.a // make sure we have enough space - len0 := len(a); - len1 := len0 + n; + len0 := len(a) + len1 := len0 + n if len1 <= cap(a) { // enough space - just expand a = a[0:len1] } else { // not enough space - double capacity - capb := cap(a) * 2; + capb := cap(a) * 2 if capb < len1 { // still not enough - use required length capb = len1 } // capb >= len1 - a = p.realloc(len1, capb); + a = p.realloc(len1, capb) } // make a hole @@ -53,7 +53,7 @@ func (p *Vector) expand(i, n int) { a[j+n] = a[j] } - p.a = a; + p.a = a } @@ -64,7 +64,7 @@ func (p *Vector) expand(i, n int) { // new length or capacity is longer that the current capacity. The resized // vector's capacity may be larger than the requested capacity. func (p *Vector) Resize(length, capacity int) *Vector { - a := p.a; + a := p.a if length > cap(a) || capacity > cap(a) { // not enough space or larger capacity requested explicitly @@ -76,91 +76,91 @@ func (p *Vector) Resize(length, capacity int) *Vector { } } - p.a = a[0:length]; - return p; + p.a = a[0:length] + return p } // Len returns the number of elements in the vector. -func (p *Vector) Len() int { return len(p.a) } +func (p *Vector) Len() int { return len(p.a) } // Cap returns the capacity of the vector; that is, the // maximum length the vector can grow without resizing. -func (p *Vector) Cap() int { return cap(p.a) } +func (p *Vector) Cap() int { return cap(p.a) } // At returns the i'th element of the vector. -func (p *Vector) At(i int) interface{} { return p.a[i] } +func (p *Vector) At(i int) interface{} { return p.a[i] } // Set sets the i'th element of the vector to value x. -func (p *Vector) Set(i int, x interface{}) { p.a[i] = x } +func (p *Vector) Set(i int, x interface{}) { p.a[i] = x } // Last returns the element in the vector of highest index. -func (p *Vector) Last() interface{} { return p.a[len(p.a)-1] } +func (p *Vector) Last() interface{} { return p.a[len(p.a)-1] } // Data returns all the elements as a slice. func (p *Vector) Data() []interface{} { - arr := make([]interface{}, p.Len()); + arr := make([]interface{}, p.Len()) for i, v := range p.a { arr[i] = v } - return arr; + return arr } // Insert inserts into the vector an element of value x before // the current element at index i. func (p *Vector) Insert(i int, x interface{}) { - p.expand(i, 1); - p.a[i] = x; + p.expand(i, 1) + p.a[i] = x } // Delete deletes the i'th element of the vector. The gap is closed so the old // element at index i+1 has index i afterwards. func (p *Vector) Delete(i int) { - a := p.a; - n := len(a); + a := p.a + n := len(a) - copy(a[i:n-1], a[i+1:n]); - a[n-1] = nil; // support GC, nil out entry - p.a = a[0 : n-1]; + copy(a[i:n-1], a[i+1:n]) + a[n-1] = nil // support GC, nil out entry + p.a = a[0 : n-1] } // InsertVector inserts into the vector the contents of the Vector // x such that the 0th element of x appears at index i after insertion. func (p *Vector) InsertVector(i int, x *Vector) { - p.expand(i, len(x.a)); - copy(p.a[i:i+len(x.a)], x.a); + p.expand(i, len(x.a)) + copy(p.a[i:i+len(x.a)], x.a) } // Cut deletes elements i through j-1, inclusive. func (p *Vector) Cut(i, j int) { - a := p.a; - n := len(a); - m := n - (j - i); + a := p.a + n := len(a) + m := n - (j - i) - copy(a[i:m], a[j:n]); + copy(a[i:m], a[j:n]) for k := m; k < n; k++ { - a[k] = nil // support GC, nil out entries + a[k] = nil // support GC, nil out entries } - p.a = a[0:m]; + p.a = a[0:m] } // Slice returns a new Vector by slicing the old one to extract slice [i:j]. // The elements are copied. The original vector is unchanged. func (p *Vector) Slice(i, j int) *Vector { - s := new(Vector).Resize(j-i, 0); // will fail in Init() if j < i - copy(s.a, p.a[i:j]); - return s; + s := new(Vector).Resize(j-i, 0) // will fail in Init() if j < i + copy(s.a, p.a[i:j]) + return s } @@ -168,7 +168,7 @@ func (p *Vector) Slice(i, j int) *Vector { // The function should not change the indexing of the vector underfoot. func (p *Vector) Do(f func(elem interface{})) { for i := 0; i < len(p.a); i++ { - f(p.a[i]) // not too safe if f changes the Vector + f(p.a[i]) // not too safe if f changes the Vector } } @@ -176,39 +176,39 @@ func (p *Vector) Do(f func(elem interface{})) { // Convenience wrappers // Push appends x to the end of the vector. -func (p *Vector) Push(x interface{}) { p.Insert(len(p.a), x) } +func (p *Vector) Push(x interface{}) { p.Insert(len(p.a), x) } // Pop deletes the last element of the vector. func (p *Vector) Pop() interface{} { - i := len(p.a) - 1; - x := p.a[i]; - p.a[i] = nil; // support GC, nil out entry - p.a = p.a[0:i]; - return x; + i := len(p.a) - 1 + x := p.a[i] + p.a[i] = nil // support GC, nil out entry + p.a = p.a[0:i] + return x } // AppendVector appends the entire Vector x to the end of this vector. -func (p *Vector) AppendVector(x *Vector) { p.InsertVector(len(p.a), x) } +func (p *Vector) AppendVector(x *Vector) { p.InsertVector(len(p.a), x) } // Partial sort.Interface support // LessInterface provides partial support of the sort.Interface. type LessInterface interface { - Less(y interface{}) bool; + Less(y interface{}) bool } // Less returns a boolean denoting whether the i'th element is less than the j'th element. -func (p *Vector) Less(i, j int) bool { return p.a[i].(LessInterface).Less(p.a[j]) } +func (p *Vector) Less(i, j int) bool { return p.a[i].(LessInterface).Less(p.a[j]) } // Swap exchanges the elements at indexes i and j. func (p *Vector) Swap(i, j int) { - a := p.a; - a[i], a[j] = a[j], a[i]; + a := p.a + a[i], a[j] = a[j], a[i] } @@ -217,13 +217,13 @@ func (p *Vector) iterate(c chan<- interface{}) { for _, v := range p.a { c <- v } - close(c); + close(c) } // Channel iterator for range. func (p *Vector) Iter() <-chan interface{} { - c := make(chan interface{}); - go p.iterate(c); - return c; + c := make(chan interface{}) + go p.iterate(c) + return c } diff --git a/src/pkg/container/vector/vector_test.go b/src/pkg/container/vector/vector_test.go index f187f7218..755ba7cad 100644 --- a/src/pkg/container/vector/vector_test.go +++ b/src/pkg/container/vector/vector_test.go @@ -10,7 +10,7 @@ import "fmt" func TestZeroLen(t *testing.T) { - a := new(Vector); + a := new(Vector) if a.Len() != 0 { t.Errorf("B) expected 0, got %d", a.Len()) } @@ -18,8 +18,8 @@ func TestZeroLen(t *testing.T) { type VectorInterface interface { - Len() int; - Cap() int; + Len() int + Cap() int } @@ -34,27 +34,27 @@ func checkSize(t *testing.T, v VectorInterface, len, cap int) { func TestResize(t *testing.T) { - var a Vector; - checkSize(t, &a, 0, 0); - checkSize(t, a.Resize(0, 5), 0, 5); - checkSize(t, a.Resize(1, 0), 1, 5); - checkSize(t, a.Resize(10, 0), 10, 10); - checkSize(t, a.Resize(5, 0), 5, 10); - checkSize(t, a.Resize(3, 8), 3, 10); - checkSize(t, a.Resize(0, 100), 0, 100); - checkSize(t, a.Resize(11, 100), 11, 100); + var a Vector + checkSize(t, &a, 0, 0) + checkSize(t, a.Resize(0, 5), 0, 5) + checkSize(t, a.Resize(1, 0), 1, 5) + checkSize(t, a.Resize(10, 0), 10, 10) + checkSize(t, a.Resize(5, 0), 5, 10) + checkSize(t, a.Resize(3, 8), 3, 10) + checkSize(t, a.Resize(0, 100), 0, 100) + checkSize(t, a.Resize(11, 100), 11, 100) } func TestIntResize(t *testing.T) { - var a IntVector; - checkSize(t, &a, 0, 0); - a.Push(1); - a.Push(2); - a.Push(3); - a.Push(4); - checkSize(t, &a, 4, 4); - checkSize(t, a.Resize(10, 0), 10, 10); + var a IntVector + checkSize(t, &a, 0, 0) + a.Push(1) + a.Push(2) + a.Push(3) + a.Push(4) + checkSize(t, &a, 4, 4) + checkSize(t, a.Resize(10, 0), 10, 10) for i := 4; i < a.Len(); i++ { if a.At(i) != 0 { t.Errorf("expected a.At(%d) == 0; found %d", i, a.At(i)) @@ -64,14 +64,14 @@ func TestIntResize(t *testing.T) { func TestStringResize(t *testing.T) { - var a StringVector; - checkSize(t, &a, 0, 0); - a.Push("1"); - a.Push("2"); - a.Push("3"); - a.Push("4"); - checkSize(t, &a, 4, 4); - checkSize(t, a.Resize(10, 0), 10, 10); + var a StringVector + checkSize(t, &a, 0, 0) + a.Push("1") + a.Push("2") + a.Push("3") + a.Push("4") + checkSize(t, &a, 4, 4) + checkSize(t, a.Resize(10, 0), 10, 10) for i := 4; i < a.Len(); i++ { if a.At(i) != "" { t.Errorf("expected a.At(%d) == "+"; found %s", i, a.At(i)) @@ -95,25 +95,25 @@ func checkNil(t *testing.T, a *Vector, i int) { func TestTrailingElements(t *testing.T) { - var a Vector; + var a Vector for i := 0; i < 10; i++ { a.Push(i) } - checkNil(t, &a, 10); - checkSize(t, &a, 10, 16); - checkSize(t, a.Resize(5, 0), 5, 16); - checkSize(t, a.Resize(10, 0), 10, 16); - checkNil(t, &a, 5); + checkNil(t, &a, 10) + checkSize(t, &a, 10, 16) + checkSize(t, a.Resize(5, 0), 5, 16) + checkSize(t, a.Resize(10, 0), 10, 16) + checkNil(t, &a, 5) } -func val(i int) int { return i*991 - 1234 } +func val(i int) int { return i*991 - 1234 } func TestAccess(t *testing.T) { - const n = 100; - var a Vector; - a.Resize(n, 0); + const n = 100 + var a Vector + a.Resize(n, 0) for i := 0; i < n; i++ { a.Set(i, val(i)) } @@ -126,14 +126,14 @@ func TestAccess(t *testing.T) { func TestInsertDeleteClear(t *testing.T) { - const n = 100; - var a Vector; + const n = 100 + var a Vector for i := 0; i < n; i++ { if a.Len() != i { t.Errorf("A) wrong len %d (expected %d)", a.Len(), i) } - a.Insert(0, val(i)); + a.Insert(0, val(i)) if a.Last().(int) != val(0) { t.Error("B") } @@ -145,7 +145,7 @@ func TestInsertDeleteClear(t *testing.T) { if a.At(0).(int) != val(i) { t.Error("D") } - a.Delete(0); + a.Delete(0) if a.Len() != i { t.Errorf("E) wrong len %d (expected %d)", a.Len(), i) } @@ -155,7 +155,7 @@ func TestInsertDeleteClear(t *testing.T) { t.Errorf("F) wrong len %d (expected 0)", a.Len()) } for i := 0; i < n; i++ { - a.Push(val(i)); + a.Push(val(i)) if a.Len() != i+1 { t.Errorf("G) wrong len %d (expected %d)", a.Len(), i+1) } @@ -163,17 +163,17 @@ func TestInsertDeleteClear(t *testing.T) { t.Error("H") } } - a.Resize(0, 0); + a.Resize(0, 0) if a.Len() != 0 { t.Errorf("I wrong len %d (expected 0)", a.Len()) } - const m = 5; + const m = 5 for j := 0; j < m; j++ { - a.Push(j); + a.Push(j) for i := 0; i < n; i++ { - x := val(i); - a.Push(x); + x := val(i) + a.Push(x) if a.Pop().(int) != x { t.Error("J") } @@ -195,7 +195,7 @@ func verify_slice(t *testing.T, x *Vector, elt, i, j int) { } } - s := x.Slice(i, j); + s := x.Slice(i, j) for k, n := 0, j-i; k < n; k++ { if s.At(k).(int) != elt { t.Errorf("N) wrong [%d] element %d (expected %d)", k, x.At(k).(int), elt) @@ -205,54 +205,54 @@ func verify_slice(t *testing.T, x *Vector, elt, i, j int) { func verify_pattern(t *testing.T, x *Vector, a, b, c int) { - n := a + b + c; + n := a + b + c if x.Len() != n { t.Errorf("O) wrong len %d (expected %d)", x.Len(), n) } - verify_slice(t, x, 0, 0, a); - verify_slice(t, x, 1, a, a+b); - verify_slice(t, x, 0, a+b, n); + verify_slice(t, x, 0, 0, a) + verify_slice(t, x, 1, a, a+b) + verify_slice(t, x, 0, a+b, n) } func make_vector(elt, len int) *Vector { - x := new(Vector).Resize(len, 0); + x := new(Vector).Resize(len, 0) for i := 0; i < len; i++ { x.Set(i, elt) } - return x; + return x } func TestInsertVector(t *testing.T) { // 1 - a := make_vector(0, 0); - b := make_vector(1, 10); - a.InsertVector(0, b); - verify_pattern(t, a, 0, 10, 0); + a := make_vector(0, 0) + b := make_vector(1, 10) + a.InsertVector(0, b) + verify_pattern(t, a, 0, 10, 0) // 2 - a = make_vector(0, 10); - b = make_vector(1, 0); - a.InsertVector(5, b); - verify_pattern(t, a, 5, 0, 5); + a = make_vector(0, 10) + b = make_vector(1, 0) + a.InsertVector(5, b) + verify_pattern(t, a, 5, 0, 5) // 3 - a = make_vector(0, 10); - b = make_vector(1, 3); - a.InsertVector(3, b); - verify_pattern(t, a, 3, 3, 7); + a = make_vector(0, 10) + b = make_vector(1, 3) + a.InsertVector(3, b) + verify_pattern(t, a, 3, 3, 7) // 4 - a = make_vector(0, 10); - b = make_vector(1, 1000); - a.InsertVector(8, b); - verify_pattern(t, a, 8, 1000, 2); + a = make_vector(0, 10) + b = make_vector(1, 1000) + a.InsertVector(8, b) + verify_pattern(t, a, 8, 1000, 2) } // This also tests IntVector and StringVector func TestSorting(t *testing.T) { - const n = 100; + const n = 100 - a := new(IntVector).Resize(n, 0); + a := new(IntVector).Resize(n, 0) for i := n - 1; i >= 0; i-- { a.Set(i, n-1-i) } @@ -260,7 +260,7 @@ func TestSorting(t *testing.T) { t.Error("int vector not sorted") } - b := new(StringVector).Resize(n, 0); + b := new(StringVector).Resize(n, 0) for i := n - 1; i >= 0; i-- { b.Set(i, fmt.Sprint(n-1-i)) } @@ -271,20 +271,20 @@ func TestSorting(t *testing.T) { func TestDo(t *testing.T) { - const n = 25; - const salt = 17; - a := new(IntVector).Resize(n, 0); + const n = 25 + const salt = 17 + a := new(IntVector).Resize(n, 0) for i := 0; i < n; i++ { a.Set(i, salt*i) } - count := 0; + count := 0 a.Do(func(e interface{}) { - i := e.(int); + i := e.(int) if i != count*salt { t.Error("value at", count, "should be", count*salt, "not", i) } - count++; - }); + count++ + }) if count != n { t.Error("should visit", n, "values; did visit", count) } @@ -292,17 +292,17 @@ func TestDo(t *testing.T) { func TestIter(t *testing.T) { - const Len = 100; - x := new(Vector).Resize(Len, 0); + const Len = 100 + x := new(Vector).Resize(Len, 0) for i := 0; i < Len; i++ { x.Set(i, i*i) } - i := 0; + i := 0 for v := range x.Iter() { if v.(int) != i*i { t.Error("Iter expected", i*i, "got", v.(int)) } - i++; + i++ } if i != Len { t.Error("Iter stopped at", i, "not", Len) diff --git a/src/pkg/crypto/aes/aes_test.go b/src/pkg/crypto/aes/aes_test.go index 39933a824..1629a33ed 100644 --- a/src/pkg/crypto/aes/aes_test.go +++ b/src/pkg/crypto/aes/aes_test.go @@ -5,7 +5,7 @@ package aes import ( - "testing"; + "testing" ) // See const.go for overview of math here. @@ -13,12 +13,12 @@ import ( // Test that powx is initialized correctly. // (Can adapt this code to generate it too.) func TestPowx(t *testing.T) { - p := 1; + p := 1 for i := 0; i < len(powx); i++ { if powx[i] != byte(p) { t.Errorf("powx[%d] = %#x, want %#x", i, powx[i], p) } - p <<= 1; + p <<= 1 if p&0x100 != 0 { p ^= poly } @@ -27,25 +27,25 @@ func TestPowx(t *testing.T) { // Multiply b and c as GF(2) polynomials modulo poly func mul(b, c uint32) uint32 { - i := b; - j := c; - s := uint32(0); + i := b + j := c + s := uint32(0) for k := uint32(1); k < 0x100 && j != 0; k <<= 1 { // Invariant: k == 1<<n, i == b * xⁿ if j&k != 0 { // s += i in GF(2); xor in binary - s ^= i; - j ^= k; // turn off bit to end loop early + s ^= i + j ^= k // turn off bit to end loop early } // i *= x in GF(2) modulo the polynomial - i <<= 1; + i <<= 1 if i&0x100 != 0 { i ^= poly } } - return s; + return s } // Test all mul inputs against bit-by-bit n² algorithm. @@ -53,7 +53,7 @@ func TestMul(t *testing.T) { for i := uint32(0); i < 256; i++ { for j := uint32(0); j < 256; j++ { // Multiply i, j bit by bit. - s := uint8(0); + s := uint8(0) for k := uint(0); k < 8; k++ { for l := uint(0); l < 8; l++ { if i&(1<<k) != 0 && j&(1<<l) != 0 { @@ -87,15 +87,15 @@ func TestSboxes(t *testing.T) { // (Can adapt this code to generate them too.) func TestTe(t *testing.T) { for i := 0; i < 256; i++ { - s := uint32(sbox0[i]); - s2 := mul(s, 2); - s3 := mul(s, 3); - w := s2<<24 | s<<16 | s<<8 | s3; + s := uint32(sbox0[i]) + s2 := mul(s, 2) + s3 := mul(s, 3) + w := s2<<24 | s<<16 | s<<8 | s3 for j := 0; j < 4; j++ { if x := te[j][i]; x != w { t.Fatalf("te[%d][%d] = %#x, want %#x", j, i, x, w) } - w = w<<24 | w>>8; + w = w<<24 | w>>8 } } } @@ -104,17 +104,17 @@ func TestTe(t *testing.T) { // (Can adapt this code to generate them too.) func TestTd(t *testing.T) { for i := 0; i < 256; i++ { - s := uint32(sbox1[i]); - s9 := mul(s, 0x9); - sb := mul(s, 0xb); - sd := mul(s, 0xd); - se := mul(s, 0xe); - w := se<<24 | s9<<16 | sd<<8 | sb; + s := uint32(sbox1[i]) + s9 := mul(s, 0x9) + sb := mul(s, 0xb) + sd := mul(s, 0xd) + se := mul(s, 0xe) + w := se<<24 | s9<<16 | sd<<8 | sb for j := 0; j < 4; j++ { if x := td[j][i]; x != w { t.Fatalf("td[%d][%d] = %#x, want %#x", j, i, x, w) } - w = w<<24 | w>>8; + w = w<<24 | w>>8 } } } @@ -124,9 +124,9 @@ func TestTd(t *testing.T) { // Appendix A of FIPS 197: Key expansion examples type KeyTest struct { - key []byte; - enc []uint32; - dec []uint32; // decryption expansion; not in FIPS 197, computed from C implementation. + key []byte + enc []uint32 + dec []uint32 // decryption expansion; not in FIPS 197, computed from C implementation. } var keyTests = []KeyTest{ @@ -214,23 +214,23 @@ var keyTests = []KeyTest{ func TestExpandKey(t *testing.T) { L: for i, tt := range keyTests { - enc := make([]uint32, len(tt.enc)); - var dec []uint32; + enc := make([]uint32, len(tt.enc)) + var dec []uint32 if tt.dec != nil { dec = make([]uint32, len(tt.dec)) } - expandKey(tt.key, enc, dec); + expandKey(tt.key, enc, dec) for j, v := range enc { if v != tt.enc[j] { - t.Errorf("key %d: enc[%d] = %#x, want %#x", i, j, v, tt.enc[j]); - continue L; + t.Errorf("key %d: enc[%d] = %#x, want %#x", i, j, v, tt.enc[j]) + continue L } } if dec != nil { for j, v := range dec { if v != tt.dec[j] { - t.Errorf("key %d: dec[%d] = %#x, want %#x", i, j, v, tt.dec[j]); - continue L; + t.Errorf("key %d: dec[%d] = %#x, want %#x", i, j, v, tt.dec[j]) + continue L } } } @@ -239,9 +239,9 @@ L: // Appendix B, C of FIPS 197: Cipher examples, Example vectors. type CryptTest struct { - key []byte; - in []byte; - out []byte; + key []byte + in []byte + out []byte } var encryptTests = []CryptTest{ @@ -278,16 +278,16 @@ var encryptTests = []CryptTest{ // Test encryptBlock against FIPS 197 examples. func TestEncryptBlock(t *testing.T) { for i, tt := range encryptTests { - n := len(tt.key) + 28; - enc := make([]uint32, n); - dec := make([]uint32, n); - expandKey(tt.key, enc, dec); - out := make([]byte, len(tt.in)); - encryptBlock(enc, tt.in, out); + n := len(tt.key) + 28 + enc := make([]uint32, n) + dec := make([]uint32, n) + expandKey(tt.key, enc, dec) + out := make([]byte, len(tt.in)) + encryptBlock(enc, tt.in, out) for j, v := range out { if v != tt.out[j] { - t.Errorf("encryptBlock %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]); - break; + t.Errorf("encryptBlock %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]) + break } } } @@ -296,16 +296,16 @@ func TestEncryptBlock(t *testing.T) { // Test decryptBlock against FIPS 197 examples. func TestDecryptBlock(t *testing.T) { for i, tt := range encryptTests { - n := len(tt.key) + 28; - enc := make([]uint32, n); - dec := make([]uint32, n); - expandKey(tt.key, enc, dec); - plain := make([]byte, len(tt.in)); - decryptBlock(dec, tt.out, plain); + n := len(tt.key) + 28 + enc := make([]uint32, n) + dec := make([]uint32, n) + expandKey(tt.key, enc, dec) + plain := make([]byte, len(tt.in)) + decryptBlock(dec, tt.out, plain) for j, v := range plain { if v != tt.in[j] { - t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]); - break; + t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]) + break } } } @@ -314,17 +314,17 @@ func TestDecryptBlock(t *testing.T) { // Test Cipher Encrypt method against FIPS 197 examples. func TestCipherEncrypt(t *testing.T) { for i, tt := range encryptTests { - c, err := NewCipher(tt.key); + c, err := NewCipher(tt.key) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err); - continue; + t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err) + continue } - out := make([]byte, len(tt.in)); - c.Encrypt(tt.in, out); + out := make([]byte, len(tt.in)) + c.Encrypt(tt.in, out) for j, v := range out { if v != tt.out[j] { - t.Errorf("Cipher.Encrypt %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]); - break; + t.Errorf("Cipher.Encrypt %d: out[%d] = %#x, want %#x", i, j, v, tt.out[j]) + break } } } @@ -333,17 +333,17 @@ func TestCipherEncrypt(t *testing.T) { // Test Cipher Decrypt against FIPS 197 examples. func TestCipherDecrypt(t *testing.T) { for i, tt := range encryptTests { - c, err := NewCipher(tt.key); + c, err := NewCipher(tt.key) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err); - continue; + t.Errorf("NewCipher(%d bytes) = %s", len(tt.key), err) + continue } - plain := make([]byte, len(tt.in)); - c.Decrypt(tt.out, plain); + plain := make([]byte, len(tt.in)) + c.Decrypt(tt.out, plain) for j, v := range plain { if v != tt.in[j] { - t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]); - break; + t.Errorf("decryptBlock %d: plain[%d] = %#x, want %#x", i, j, v, tt.in[j]) + break } } } diff --git a/src/pkg/crypto/aes/block.go b/src/pkg/crypto/aes/block.go index dbd448f8b..a502554bd 100644 --- a/src/pkg/crypto/aes/block.go +++ b/src/pkg/crypto/aes/block.go @@ -38,92 +38,92 @@ package aes // Encrypt one block from src into dst, using the expanded key xk. func encryptBlock(xk []uint32, src, dst []byte) { - var s0, s1, s2, s3, t0, t1, t2, t3 uint32; + var s0, s1, s2, s3, t0, t1, t2, t3 uint32 - s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]); - s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]); - s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]); - s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]); + s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]) + s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]) + s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]) + s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]) // First round just XORs input with key. - s0 ^= xk[0]; - s1 ^= xk[1]; - s2 ^= xk[2]; - s3 ^= xk[3]; + s0 ^= xk[0] + s1 ^= xk[1] + s2 ^= xk[2] + s3 ^= xk[3] // Middle rounds shuffle using tables. // Number of rounds is set by length of expanded key. - nr := len(xk)/4 - 2; // - 2: one above, one more below - k := 4; + nr := len(xk)/4 - 2 // - 2: one above, one more below + k := 4 for r := 0; r < nr; r++ { - t0 = xk[k+0] ^ te[0][s0>>24] ^ te[1][s1>>16&0xff] ^ te[2][s2>>8&0xff] ^ te[3][s3&0xff]; - t1 = xk[k+1] ^ te[0][s1>>24] ^ te[1][s2>>16&0xff] ^ te[2][s3>>8&0xff] ^ te[3][s0&0xff]; - t2 = xk[k+2] ^ te[0][s2>>24] ^ te[1][s3>>16&0xff] ^ te[2][s0>>8&0xff] ^ te[3][s1&0xff]; - t3 = xk[k+3] ^ te[0][s3>>24] ^ te[1][s0>>16&0xff] ^ te[2][s1>>8&0xff] ^ te[3][s2&0xff]; - k += 4; - s0, s1, s2, s3 = t0, t1, t2, t3; + t0 = xk[k+0] ^ te[0][s0>>24] ^ te[1][s1>>16&0xff] ^ te[2][s2>>8&0xff] ^ te[3][s3&0xff] + t1 = xk[k+1] ^ te[0][s1>>24] ^ te[1][s2>>16&0xff] ^ te[2][s3>>8&0xff] ^ te[3][s0&0xff] + t2 = xk[k+2] ^ te[0][s2>>24] ^ te[1][s3>>16&0xff] ^ te[2][s0>>8&0xff] ^ te[3][s1&0xff] + t3 = xk[k+3] ^ te[0][s3>>24] ^ te[1][s0>>16&0xff] ^ te[2][s1>>8&0xff] ^ te[3][s2&0xff] + k += 4 + s0, s1, s2, s3 = t0, t1, t2, t3 } // Last round uses s-box directly and XORs to produce output. - s0 = uint32(sbox0[t0>>24])<<24 | uint32(sbox0[t1>>16&0xff])<<16 | uint32(sbox0[t2>>8&0xff])<<8 | uint32(sbox0[t3&0xff]); - s1 = uint32(sbox0[t1>>24])<<24 | uint32(sbox0[t2>>16&0xff])<<16 | uint32(sbox0[t3>>8&0xff])<<8 | uint32(sbox0[t0&0xff]); - s2 = uint32(sbox0[t2>>24])<<24 | uint32(sbox0[t3>>16&0xff])<<16 | uint32(sbox0[t0>>8&0xff])<<8 | uint32(sbox0[t1&0xff]); - s3 = uint32(sbox0[t3>>24])<<24 | uint32(sbox0[t0>>16&0xff])<<16 | uint32(sbox0[t1>>8&0xff])<<8 | uint32(sbox0[t2&0xff]); - - s0 ^= xk[k+0]; - s1 ^= xk[k+1]; - s2 ^= xk[k+2]; - s3 ^= xk[k+3]; - - dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0); - dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1); - dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2); - dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3); + s0 = uint32(sbox0[t0>>24])<<24 | uint32(sbox0[t1>>16&0xff])<<16 | uint32(sbox0[t2>>8&0xff])<<8 | uint32(sbox0[t3&0xff]) + s1 = uint32(sbox0[t1>>24])<<24 | uint32(sbox0[t2>>16&0xff])<<16 | uint32(sbox0[t3>>8&0xff])<<8 | uint32(sbox0[t0&0xff]) + s2 = uint32(sbox0[t2>>24])<<24 | uint32(sbox0[t3>>16&0xff])<<16 | uint32(sbox0[t0>>8&0xff])<<8 | uint32(sbox0[t1&0xff]) + s3 = uint32(sbox0[t3>>24])<<24 | uint32(sbox0[t0>>16&0xff])<<16 | uint32(sbox0[t1>>8&0xff])<<8 | uint32(sbox0[t2&0xff]) + + s0 ^= xk[k+0] + s1 ^= xk[k+1] + s2 ^= xk[k+2] + s3 ^= xk[k+3] + + dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0) + dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1) + dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2) + dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3) } // Decrypt one block from src into dst, using the expanded key xk. func decryptBlock(xk []uint32, src, dst []byte) { - var s0, s1, s2, s3, t0, t1, t2, t3 uint32; + var s0, s1, s2, s3, t0, t1, t2, t3 uint32 - s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]); - s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]); - s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]); - s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]); + s0 = uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]) + s1 = uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]) + s2 = uint32(src[8])<<24 | uint32(src[9])<<16 | uint32(src[10])<<8 | uint32(src[11]) + s3 = uint32(src[12])<<24 | uint32(src[13])<<16 | uint32(src[14])<<8 | uint32(src[15]) // First round just XORs input with key. - s0 ^= xk[0]; - s1 ^= xk[1]; - s2 ^= xk[2]; - s3 ^= xk[3]; + s0 ^= xk[0] + s1 ^= xk[1] + s2 ^= xk[2] + s3 ^= xk[3] // Middle rounds shuffle using tables. // Number of rounds is set by length of expanded key. - nr := len(xk)/4 - 2; // - 2: one above, one more below - k := 4; + nr := len(xk)/4 - 2 // - 2: one above, one more below + k := 4 for r := 0; r < nr; r++ { - t0 = xk[k+0] ^ td[0][s0>>24] ^ td[1][s3>>16&0xff] ^ td[2][s2>>8&0xff] ^ td[3][s1&0xff]; - t1 = xk[k+1] ^ td[0][s1>>24] ^ td[1][s0>>16&0xff] ^ td[2][s3>>8&0xff] ^ td[3][s2&0xff]; - t2 = xk[k+2] ^ td[0][s2>>24] ^ td[1][s1>>16&0xff] ^ td[2][s0>>8&0xff] ^ td[3][s3&0xff]; - t3 = xk[k+3] ^ td[0][s3>>24] ^ td[1][s2>>16&0xff] ^ td[2][s1>>8&0xff] ^ td[3][s0&0xff]; - k += 4; - s0, s1, s2, s3 = t0, t1, t2, t3; + t0 = xk[k+0] ^ td[0][s0>>24] ^ td[1][s3>>16&0xff] ^ td[2][s2>>8&0xff] ^ td[3][s1&0xff] + t1 = xk[k+1] ^ td[0][s1>>24] ^ td[1][s0>>16&0xff] ^ td[2][s3>>8&0xff] ^ td[3][s2&0xff] + t2 = xk[k+2] ^ td[0][s2>>24] ^ td[1][s1>>16&0xff] ^ td[2][s0>>8&0xff] ^ td[3][s3&0xff] + t3 = xk[k+3] ^ td[0][s3>>24] ^ td[1][s2>>16&0xff] ^ td[2][s1>>8&0xff] ^ td[3][s0&0xff] + k += 4 + s0, s1, s2, s3 = t0, t1, t2, t3 } // Last round uses s-box directly and XORs to produce output. - s0 = uint32(sbox1[t0>>24])<<24 | uint32(sbox1[t3>>16&0xff])<<16 | uint32(sbox1[t2>>8&0xff])<<8 | uint32(sbox1[t1&0xff]); - s1 = uint32(sbox1[t1>>24])<<24 | uint32(sbox1[t0>>16&0xff])<<16 | uint32(sbox1[t3>>8&0xff])<<8 | uint32(sbox1[t2&0xff]); - s2 = uint32(sbox1[t2>>24])<<24 | uint32(sbox1[t1>>16&0xff])<<16 | uint32(sbox1[t0>>8&0xff])<<8 | uint32(sbox1[t3&0xff]); - s3 = uint32(sbox1[t3>>24])<<24 | uint32(sbox1[t2>>16&0xff])<<16 | uint32(sbox1[t1>>8&0xff])<<8 | uint32(sbox1[t0&0xff]); - - s0 ^= xk[k+0]; - s1 ^= xk[k+1]; - s2 ^= xk[k+2]; - s3 ^= xk[k+3]; - - dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0); - dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1); - dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2); - dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3); + s0 = uint32(sbox1[t0>>24])<<24 | uint32(sbox1[t3>>16&0xff])<<16 | uint32(sbox1[t2>>8&0xff])<<8 | uint32(sbox1[t1&0xff]) + s1 = uint32(sbox1[t1>>24])<<24 | uint32(sbox1[t0>>16&0xff])<<16 | uint32(sbox1[t3>>8&0xff])<<8 | uint32(sbox1[t2&0xff]) + s2 = uint32(sbox1[t2>>24])<<24 | uint32(sbox1[t1>>16&0xff])<<16 | uint32(sbox1[t0>>8&0xff])<<8 | uint32(sbox1[t3&0xff]) + s3 = uint32(sbox1[t3>>24])<<24 | uint32(sbox1[t2>>16&0xff])<<16 | uint32(sbox1[t1>>8&0xff])<<8 | uint32(sbox1[t0&0xff]) + + s0 ^= xk[k+0] + s1 ^= xk[k+1] + s2 ^= xk[k+2] + s3 ^= xk[k+3] + + dst[0], dst[1], dst[2], dst[3] = byte(s0>>24), byte(s0>>16), byte(s0>>8), byte(s0) + dst[4], dst[5], dst[6], dst[7] = byte(s1>>24), byte(s1>>16), byte(s1>>8), byte(s1) + dst[8], dst[9], dst[10], dst[11] = byte(s2>>24), byte(s2>>16), byte(s2>>8), byte(s2) + dst[12], dst[13], dst[14], dst[15] = byte(s3>>24), byte(s3>>16), byte(s3>>8), byte(s3) } // Apply sbox0 to each byte in w. @@ -135,25 +135,25 @@ func subw(w uint32) uint32 { } // Rotate -func rotw(w uint32) uint32 { return w<<8 | w>>24 } +func rotw(w uint32) uint32 { return w<<8 | w>>24 } // Key expansion algorithm. See FIPS-197, Figure 11. // Their rcon[i] is our powx[i-1] << 24. func expandKey(key []byte, enc, dec []uint32) { // Encryption key setup. - var i int; - nk := len(key) / 4; + var i int + nk := len(key) / 4 for i = 0; i < nk; i++ { enc[i] = uint32(key[4*i])<<24 | uint32(key[4*i+1])<<16 | uint32(key[4*i+2])<<8 | uint32(key[4*i+3]) } for ; i < len(enc); i++ { - t := enc[i-1]; + t := enc[i-1] if i%nk == 0 { t = subw(rotw(t)) ^ (uint32(powx[i/nk-1]) << 24) } else if nk > 6 && i%nk == 4 { t = subw(t) } - enc[i] = enc[i-nk] ^ t; + enc[i] = enc[i-nk] ^ t } // Derive decryption key from encryption key. @@ -162,15 +162,15 @@ func expandKey(key []byte, enc, dec []uint32) { if dec == nil { return } - n := len(enc); + n := len(enc) for i := 0; i < n; i += 4 { - ei := n - i - 4; + ei := n - i - 4 for j := 0; j < 4; j++ { - x := enc[ei+j]; + x := enc[ei+j] if i > 0 && i+4 < n { x = td[0][sbox0[x>>24]] ^ td[1][sbox0[x>>16&0xff]] ^ td[2][sbox0[x>>8&0xff]] ^ td[3][sbox0[x&0xff]] } - dec[i+j] = x; + dec[i+j] = x } } } diff --git a/src/pkg/crypto/aes/cipher.go b/src/pkg/crypto/aes/cipher.go index 651c2651e..a7caf5576 100644 --- a/src/pkg/crypto/aes/cipher.go +++ b/src/pkg/crypto/aes/cipher.go @@ -5,8 +5,8 @@ package aes import ( - "os"; - "strconv"; + "os" + "strconv" ) // The AES block size in bytes. @@ -14,8 +14,8 @@ const BlockSize = 16 // A Cipher is an instance of AES encryption using a particular key. type Cipher struct { - enc []uint32; - dec []uint32; + enc []uint32 + dec []uint32 } type KeySizeError int @@ -29,7 +29,7 @@ func (k KeySizeError) String() string { // either 16, 24, or 32 bytes to select // AES-128, AES-192, or AES-256. func NewCipher(key []byte) (*Cipher, os.Error) { - k := len(key); + k := len(key) switch k { default: return nil, KeySizeError(k) @@ -37,27 +37,27 @@ func NewCipher(key []byte) (*Cipher, os.Error) { break } - n := k + 28; - c := &Cipher{make([]uint32, n), make([]uint32, n)}; - expandKey(key, c.enc, c.dec); - return c, nil; + n := k + 28 + c := &Cipher{make([]uint32, n), make([]uint32, n)} + expandKey(key, c.enc, c.dec) + return c, nil } // BlockSize returns the AES block size, 16 bytes. // It is necessary to satisfy the Key interface in the // package "crypto/modes". -func (c *Cipher) BlockSize() int { return BlockSize } +func (c *Cipher) BlockSize() int { return BlockSize } // Encrypt encrypts the 16-byte buffer src using the key k // and stores the result in dst. // Note that for amounts of data larger than a block, // it is not safe to just call Encrypt on successive blocks; // instead, use an encryption mode like AESCBC (see modes.go). -func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c.enc, src, dst) } +func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c.enc, src, dst) } // Decrypt decrypts the 16-byte buffer src using the key k // and stores the result in dst. -func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c.dec, src, dst) } +func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c.dec, src, dst) } // Reset zeros the key data, so that it will no longer // appear in the process's memory. diff --git a/src/pkg/crypto/aes/const.go b/src/pkg/crypto/aes/const.go index 862be087b..8ddcaff26 100644 --- a/src/pkg/crypto/aes/const.go +++ b/src/pkg/crypto/aes/const.go @@ -15,7 +15,7 @@ package aes // Addition of these binary polynomials corresponds to binary xor. // Reducing mod poly corresponds to binary xor with poly every // time a 0x100 bit appears. -const poly = 1<<8 | 1<<4 | 1<<3 | 1<<1 | 1<<0 // x⁸ + x⁴ + x² + x + 1 +const poly = 1<<8 | 1<<4 | 1<<3 | 1<<1 | 1<<0 // x⁸ + x⁴ + x² + x + 1 // Powers of x mod poly in GF(2). var powx = [16]byte{ diff --git a/src/pkg/crypto/block/cbc.go b/src/pkg/crypto/block/cbc.go index ac41ab1fb..10235f541 100644 --- a/src/pkg/crypto/block/cbc.go +++ b/src/pkg/crypto/block/cbc.go @@ -12,44 +12,44 @@ package block import ( - "io"; + "io" ) type cbcCipher struct { - c Cipher; - blockSize int; - iv []byte; - tmp []byte; + c Cipher + blockSize int + iv []byte + tmp []byte } func newCBC(c Cipher, iv []byte) *cbcCipher { - n := c.BlockSize(); - x := new(cbcCipher); - x.c = c; - x.blockSize = n; - x.iv = copy(iv); - x.tmp = make([]byte, n); - return x; + n := c.BlockSize() + x := new(cbcCipher) + x.c = c + x.blockSize = n + x.iv = copy(iv) + x.tmp = make([]byte, n) + return x } -func (x *cbcCipher) BlockSize() int { return x.blockSize } +func (x *cbcCipher) BlockSize() int { return x.blockSize } func (x *cbcCipher) Encrypt(src, dst []byte) { for i := 0; i < x.blockSize; i++ { x.iv[i] ^= src[i] } - x.c.Encrypt(x.iv, x.iv); + x.c.Encrypt(x.iv, x.iv) for i := 0; i < x.blockSize; i++ { dst[i] = x.iv[i] } } func (x *cbcCipher) Decrypt(src, dst []byte) { - x.c.Decrypt(src, x.tmp); + x.c.Decrypt(src, x.tmp) for i := 0; i < x.blockSize; i++ { - x.tmp[i] ^= x.iv[i]; - x.iv[i] = src[i]; - dst[i] = x.tmp[i]; + x.tmp[i] ^= x.iv[i] + x.iv[i] = src[i] + dst[i] = x.tmp[i] } } diff --git a/src/pkg/crypto/block/cbc_aes_test.go b/src/pkg/crypto/block/cbc_aes_test.go index 02c58fabd..5531f3ab9 100644 --- a/src/pkg/crypto/block/cbc_aes_test.go +++ b/src/pkg/crypto/block/cbc_aes_test.go @@ -11,18 +11,18 @@ package block import ( - "bytes"; - "crypto/aes"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "io" + "testing" ) type cbcTest struct { - name string; - key []byte; - iv []byte; - in []byte; - out []byte; + name string + key []byte + iv []byte + in []byte + out []byte } var cbcAESTests = []cbcTest{ @@ -67,28 +67,28 @@ var cbcAESTests = []cbcTest{ func TestCBC_AES(t *testing.T) { for _, tt := range cbcAESTests { - test := tt.name; + test := tt.name - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err); - continue; + t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) + continue } - var crypt bytes.Buffer; - w := NewCBCEncrypter(c, tt.iv, &crypt); - var r io.Reader = bytes.NewBuffer(tt.in); - n, err := io.Copy(w, r); + var crypt bytes.Buffer + w := NewCBCEncrypter(c, tt.iv, &crypt) + var r io.Reader = bytes.NewBuffer(tt.in) + n, err := io.Copy(w, r) if n != int64(len(tt.in)) || err != nil { t.Errorf("%s: CBCEncrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in)) } else if d := crypt.Bytes(); !same(tt.out, d) { t.Errorf("%s: CBCEncrypter\nhave %x\nwant %x", test, d, tt.out) } - var plain bytes.Buffer; - r = NewCBCDecrypter(c, tt.iv, bytes.NewBuffer(tt.out)); - w = &plain; - n, err = io.Copy(w, r); + var plain bytes.Buffer + r = NewCBCDecrypter(c, tt.iv, bytes.NewBuffer(tt.out)) + w = &plain + n, err = io.Copy(w, r) if n != int64(len(tt.out)) || err != nil { t.Errorf("%s: CBCDecrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out)) } else if d := plain.Bytes(); !same(tt.in, d) { diff --git a/src/pkg/crypto/block/cfb.go b/src/pkg/crypto/block/cfb.go index d3c8852d7..82b289ac4 100644 --- a/src/pkg/crypto/block/cfb.go +++ b/src/pkg/crypto/block/cfb.go @@ -13,36 +13,36 @@ package block import ( - "io"; + "io" ) type cfbCipher struct { - c Cipher; - blockSize int; // our block size (s/8) - cipherSize int; // underlying cipher block size - iv []byte; - tmp []byte; + c Cipher + blockSize int // our block size (s/8) + cipherSize int // underlying cipher block size + iv []byte + tmp []byte } func newCFB(c Cipher, s int, iv []byte) *cfbCipher { if s == 0 || s%8 != 0 { panicln("crypto/block: invalid CFB mode", s) } - b := c.BlockSize(); - x := new(cfbCipher); - x.c = c; - x.blockSize = s / 8; - x.cipherSize = b; - x.iv = copy(iv); - x.tmp = make([]byte, b); - return x; + b := c.BlockSize() + x := new(cfbCipher) + x.c = c + x.blockSize = s / 8 + x.cipherSize = b + x.iv = copy(iv) + x.tmp = make([]byte, b) + return x } -func (x *cfbCipher) BlockSize() int { return x.blockSize } +func (x *cfbCipher) BlockSize() int { return x.blockSize } func (x *cfbCipher) Encrypt(src, dst []byte) { // Encrypt old IV and xor prefix with src to make dst. - x.c.Encrypt(x.iv, x.tmp); + x.c.Encrypt(x.iv, x.tmp) for i := 0; i < x.blockSize; i++ { dst[i] = src[i] ^ x.tmp[i] } @@ -51,7 +51,7 @@ func (x *cfbCipher) Encrypt(src, dst []byte) { for i := 0; i < x.cipherSize-x.blockSize; i++ { x.iv[i] = x.iv[i+x.blockSize] } - off := x.cipherSize - x.blockSize; + off := x.cipherSize - x.blockSize for i := off; i < x.cipherSize; i++ { x.iv[i] = dst[i-off] } @@ -59,7 +59,7 @@ func (x *cfbCipher) Encrypt(src, dst []byte) { func (x *cfbCipher) Decrypt(src, dst []byte) { // Encrypt [sic] old IV and xor prefix with src to make dst. - x.c.Encrypt(x.iv, x.tmp); + x.c.Encrypt(x.iv, x.tmp) for i := 0; i < x.blockSize; i++ { dst[i] = src[i] ^ x.tmp[i] } @@ -68,7 +68,7 @@ func (x *cfbCipher) Decrypt(src, dst []byte) { for i := 0; i < x.cipherSize-x.blockSize; i++ { x.iv[i] = x.iv[i+x.blockSize] } - off := x.cipherSize - x.blockSize; + off := x.cipherSize - x.blockSize for i := off; i < x.cipherSize; i++ { // Reconstruct src = dst ^ x.tmp // in case we overwrote src (src == dst). diff --git a/src/pkg/crypto/block/cfb_aes_test.go b/src/pkg/crypto/block/cfb_aes_test.go index f1913691b..8a245a2cb 100644 --- a/src/pkg/crypto/block/cfb_aes_test.go +++ b/src/pkg/crypto/block/cfb_aes_test.go @@ -11,19 +11,19 @@ package block import ( - "bytes"; - "crypto/aes"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "io" + "testing" ) type cfbTest struct { - name string; - s int; - key []byte; - iv []byte; - in []byte; - out []byte; + name string + s int + key []byte + iv []byte + in []byte + out []byte } var cfbAESTests = []cfbTest{ @@ -271,33 +271,33 @@ var cfbAESTests = []cfbTest{ func TestCFB_AES(t *testing.T) { for _, tt := range cfbAESTests { - test := tt.name; + test := tt.name if tt.s == 1 { // 1-bit CFB not implemented continue } - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err); - continue; + t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) + continue } - var crypt bytes.Buffer; - w := NewCFBEncrypter(c, tt.s, tt.iv, &crypt); - var r io.Reader = bytes.NewBuffer(tt.in); - n, err := io.Copy(w, r); + var crypt bytes.Buffer + w := NewCFBEncrypter(c, tt.s, tt.iv, &crypt) + var r io.Reader = bytes.NewBuffer(tt.in) + n, err := io.Copy(w, r) if n != int64(len(tt.in)) || err != nil { t.Errorf("%s: CFBEncrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in)) } else if d := crypt.Bytes(); !same(tt.out, d) { t.Errorf("%s: CFBEncrypter\nhave %x\nwant %x", test, d, tt.out) } - var plain bytes.Buffer; - r = NewCFBDecrypter(c, tt.s, tt.iv, bytes.NewBuffer(tt.out)); - w = &plain; - n, err = io.Copy(w, r); + var plain bytes.Buffer + r = NewCFBDecrypter(c, tt.s, tt.iv, bytes.NewBuffer(tt.out)) + w = &plain + n, err = io.Copy(w, r) if n != int64(len(tt.out)) || err != nil { t.Errorf("%s: CFBDecrypter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out)) } else if d := plain.Bytes(); !same(tt.in, d) { diff --git a/src/pkg/crypto/block/cipher.go b/src/pkg/crypto/block/cipher.go index 2ca15c129..1b786cca4 100644 --- a/src/pkg/crypto/block/cipher.go +++ b/src/pkg/crypto/block/cipher.go @@ -14,27 +14,27 @@ package block // extend that capability to streams of blocks. type Cipher interface { // BlockSize returns the cipher's block size. - BlockSize() int; + BlockSize() int // Encrypt encrypts the first block in src into dst. // Src and dst may point at the same memory. - Encrypt(src, dst []byte); + Encrypt(src, dst []byte) // Decrypt decrypts the first block in src into dst. // Src and dst may point at the same memory. - Decrypt(src, dst []byte); + Decrypt(src, dst []byte) } // Utility routines func shift1(src, dst []byte) byte { - var b byte; + var b byte for i := len(src) - 1; i >= 0; i-- { - bb := src[i] >> 7; - dst[i] = src[i]<<1 | b; - b = bb; + bb := src[i] >> 7 + dst[i] = src[i]<<1 | b + b = bb } - return b; + return b } func same(p, q []byte) bool { @@ -46,13 +46,13 @@ func same(p, q []byte) bool { return false } } - return true; + return true } func copy(p []byte) []byte { - q := make([]byte, len(p)); + q := make([]byte, len(p)) for i, b := range p { q[i] = b } - return q; + return q } diff --git a/src/pkg/crypto/block/cmac.go b/src/pkg/crypto/block/cmac.go index 5b00b3727..a2f80fe4b 100644 --- a/src/pkg/crypto/block/cmac.go +++ b/src/pkg/crypto/block/cmac.go @@ -8,20 +8,20 @@ package block import ( - "hash"; - "os"; + "hash" + "os" ) const ( // minimal irreducible polynomial of degree b - r64 = 0x1b; - r128 = 0x87; + r64 = 0x1b + r128 = 0x87 ) type cmac struct { - k1, k2, ci, digest []byte; - p int; // position in ci - c Cipher; + k1, k2, ci, digest []byte + p int // position in ci + c Cipher } // TODO(rsc): Should this return an error instead of panic? @@ -29,8 +29,8 @@ type cmac struct { // NewCMAC returns a new instance of a CMAC message authentication code // digest using the given Cipher. func NewCMAC(c Cipher) hash.Hash { - var r byte; - n := c.BlockSize(); + var r byte + n := c.BlockSize() switch n { case 64 / 8: r = r64 @@ -40,15 +40,15 @@ func NewCMAC(c Cipher) hash.Hash { panic("crypto/block: NewCMAC: invalid cipher block size", n) } - d := new(cmac); - d.c = c; - d.k1 = make([]byte, n); - d.k2 = make([]byte, n); - d.ci = make([]byte, n); - d.digest = make([]byte, n); + d := new(cmac) + d.c = c + d.k1 = make([]byte, n) + d.k2 = make([]byte, n) + d.ci = make([]byte, n) + d.digest = make([]byte, n) // Subkey generation, p. 7 - c.Encrypt(d.k1, d.k1); + c.Encrypt(d.k1, d.k1) if shift1(d.k1, d.k1) != 0 { d.k1[n-1] ^= r } @@ -56,7 +56,7 @@ func NewCMAC(c Cipher) hash.Hash { d.k2[n-1] ^= r } - return d; + return d } // Reset clears the digest state, starting a new digest. @@ -64,7 +64,7 @@ func (d *cmac) Reset() { for i := range d.ci { d.ci[i] = 0 } - d.p = 0; + d.p = 0 } // Write adds the given data to the digest state. @@ -73,13 +73,13 @@ func (d *cmac) Write(p []byte) (n int, err os.Error) { for _, c := range p { // If ci is full, encrypt and start over. if d.p >= len(d.ci) { - d.c.Encrypt(d.ci, d.ci); - d.p = 0; + d.c.Encrypt(d.ci, d.ci) + d.p = 0 } - d.ci[d.p] ^= c; - d.p++; + d.ci[d.p] ^= c + d.p++ } - return len(p), nil; + return len(p), nil } // Sum returns the CMAC digest, one cipher block in length, @@ -88,7 +88,7 @@ func (d *cmac) Sum() []byte { // Finish last block, mix in key, encrypt. // Don't edit ci, in case caller wants // to keep digesting after call to Sum. - k := d.k1; + k := d.k1 if d.p < len(d.digest) { k = d.k2 } @@ -98,8 +98,8 @@ func (d *cmac) Sum() []byte { if d.p < len(d.digest) { d.digest[d.p] ^= 0x80 } - d.c.Encrypt(d.digest, d.digest); - return d.digest; + d.c.Encrypt(d.digest, d.digest) + return d.digest } -func (d *cmac) Size() int { return len(d.digest) } +func (d *cmac) Size() int { return len(d.digest) } diff --git a/src/pkg/crypto/block/cmac_aes_test.go b/src/pkg/crypto/block/cmac_aes_test.go index 8e727ed9c..a9cbc71a6 100644 --- a/src/pkg/crypto/block/cmac_aes_test.go +++ b/src/pkg/crypto/block/cmac_aes_test.go @@ -7,14 +7,14 @@ package block import ( - "crypto/aes"; - "testing"; + "crypto/aes" + "testing" ) type cmacAESTest struct { - key []byte; - in []byte; - digest []byte; + key []byte + in []byte + digest []byte } var cmacAESTests = []cmacAESTest{ @@ -109,22 +109,22 @@ var cmacAESTests = []cmacAESTest{ func TestCMAC_AES(t *testing.T) { for i, tt := range cmacAESTests { - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("test %d: NewCipher: %s", i, err); - continue; + t.Errorf("test %d: NewCipher: %s", i, err) + continue } - d := NewCMAC(c); - n, err := d.Write(tt.in); + d := NewCMAC(c) + n, err := d.Write(tt.in) if err != nil || n != len(tt.in) { - t.Errorf("test %d: Write %d: %d, %s", i, len(tt.in), n, err); - continue; + t.Errorf("test %d: Write %d: %d, %s", i, len(tt.in), n, err) + continue } - sum := d.Sum(); + sum := d.Sum() if !same(sum, tt.digest) { - x := d.(*cmac); - t.Errorf("test %d: digest mismatch\n\twant %x\n\thave %x\n\tk1 %x\n\tk2 %x", i, tt.digest, sum, x.k1, x.k2); - continue; + x := d.(*cmac) + t.Errorf("test %d: digest mismatch\n\twant %x\n\thave %x\n\tk1 %x\n\tk2 %x", i, tt.digest, sum, x.k1, x.k2) + continue } } } diff --git a/src/pkg/crypto/block/ctr.go b/src/pkg/crypto/block/ctr.go index bfb0fc23e..085ae05b1 100644 --- a/src/pkg/crypto/block/ctr.go +++ b/src/pkg/crypto/block/ctr.go @@ -13,36 +13,36 @@ package block import ( - "io"; + "io" ) type ctrStream struct { - c Cipher; - ctr []byte; - out []byte; + c Cipher + ctr []byte + out []byte } func newCTRStream(c Cipher, ctr []byte) *ctrStream { - x := new(ctrStream); - x.c = c; - x.ctr = copy(ctr); - x.out = make([]byte, len(ctr)); - return x; + x := new(ctrStream) + x.c = c + x.ctr = copy(ctr) + x.out = make([]byte, len(ctr)) + return x } func (x *ctrStream) Next() []byte { // Next block is encryption of counter. - x.c.Encrypt(x.ctr, x.out); + x.c.Encrypt(x.ctr, x.out) // Increment counter for i := len(x.ctr) - 1; i >= 0; i-- { - x.ctr[i]++; + x.ctr[i]++ if x.ctr[i] != 0 { break } } - return x.out; + return x.out } // NewCTRReader returns a reader that reads data from r, decrypts (or encrypts) diff --git a/src/pkg/crypto/block/ctr_aes_test.go b/src/pkg/crypto/block/ctr_aes_test.go index 456c07131..adb996c1d 100644 --- a/src/pkg/crypto/block/ctr_aes_test.go +++ b/src/pkg/crypto/block/ctr_aes_test.go @@ -11,18 +11,18 @@ package block import ( - "bytes"; - "crypto/aes"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "io" + "testing" ) type ctrTest struct { - name string; - key []byte; - iv []byte; - in []byte; - out []byte; + name string + key []byte + iv []byte + in []byte + out []byte } var commonCounter = []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff} @@ -69,20 +69,20 @@ var ctrAESTests = []ctrTest{ func TestCTR_AES(t *testing.T) { for _, tt := range ctrAESTests { - test := tt.name; + test := tt.name - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err); - continue; + t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) + continue } for j := 0; j <= 5; j += 5 { - var crypt bytes.Buffer; - in := tt.in[0 : len(tt.in)-j]; - w := NewCTRWriter(c, tt.iv, &crypt); - var r io.Reader = bytes.NewBuffer(in); - n, err := io.Copy(w, r); + var crypt bytes.Buffer + in := tt.in[0 : len(tt.in)-j] + w := NewCTRWriter(c, tt.iv, &crypt) + var r io.Reader = bytes.NewBuffer(in) + n, err := io.Copy(w, r) if n != int64(len(in)) || err != nil { t.Errorf("%s/%d: CTRWriter io.Copy = %d, %v want %d, nil", test, len(in), n, err, len(in)) } else if d, out := crypt.Bytes(), tt.out[0:len(in)]; !same(out, d) { @@ -91,11 +91,11 @@ func TestCTR_AES(t *testing.T) { } for j := 0; j <= 7; j += 7 { - var plain bytes.Buffer; - out := tt.out[0 : len(tt.out)-j]; - r := NewCTRReader(c, tt.iv, bytes.NewBuffer(out)); - w := &plain; - n, err := io.Copy(w, r); + var plain bytes.Buffer + out := tt.out[0 : len(tt.out)-j] + r := NewCTRReader(c, tt.iv, bytes.NewBuffer(out)) + w := &plain + n, err := io.Copy(w, r) if n != int64(len(out)) || err != nil { t.Errorf("%s/%d: CTRReader io.Copy = %d, %v want %d, nil", test, len(out), n, err, len(out)) } else if d, in := plain.Bytes(), tt.in[0:len(out)]; !same(in, d) { diff --git a/src/pkg/crypto/block/eax.go b/src/pkg/crypto/block/eax.go index 07919e4ae..fcd5fe20f 100644 --- a/src/pkg/crypto/block/eax.go +++ b/src/pkg/crypto/block/eax.go @@ -15,18 +15,18 @@ package block import ( - "fmt"; - "hash"; - "io"; - "os"; + "fmt" + "hash" + "io" + "os" ) // An EAXTagError is returned when the message has failed to authenticate, // because the tag at the end of the message stream (Read) does not match // the tag computed from the message itself (Computed). type EAXTagError struct { - Read []byte; - Computed []byte; + Read []byte + Computed []byte } func (e *EAXTagError) String() string { @@ -34,39 +34,39 @@ func (e *EAXTagError) String() string { } func setupEAX(c Cipher, iv, hdr []byte, tagBytes int) (ctrIV, tag []byte, cmac hash.Hash) { - n := len(iv); + n := len(iv) if n != c.BlockSize() { panicln("crypto/block: EAX: iv length", n, "!=", c.BlockSize()) } - buf := make([]byte, n); // zeroed + buf := make([]byte, n) // zeroed // tag = CMAC(0 + iv) ^ CMAC(1 + hdr) ^ CMAC(2 + data) - cmac = NewCMAC(c); - cmac.Write(buf); // 0 - cmac.Write(iv); - sum := cmac.Sum(); - ctrIV = copy(sum); - tag = copy(sum[0:tagBytes]); - - cmac.Reset(); - buf[n-1] = 1; - cmac.Write(buf); // 1 - cmac.Write(hdr); - sum = cmac.Sum(); + cmac = NewCMAC(c) + cmac.Write(buf) // 0 + cmac.Write(iv) + sum := cmac.Sum() + ctrIV = copy(sum) + tag = copy(sum[0:tagBytes]) + + cmac.Reset() + buf[n-1] = 1 + cmac.Write(buf) // 1 + cmac.Write(hdr) + sum = cmac.Sum() for i := 0; i < tagBytes; i++ { tag[i] ^= sum[i] } - cmac.Reset(); - buf[n-1] = 2; // 2 - cmac.Write(buf); + cmac.Reset() + buf[n-1] = 2 // 2 + cmac.Write(buf) - return; + return } func finishEAX(tag []byte, cmac hash.Hash) { // Finish CMAC #2 and xor into tag. - sum := cmac.Sum(); + sum := cmac.Sum() for i := range tag { tag[i] ^= sum[i] } @@ -75,21 +75,21 @@ func finishEAX(tag []byte, cmac hash.Hash) { // Writer adapter. Tees writes into both w and cmac. // Knows that cmac never returns write errors. type cmacWriter struct { - w io.Writer; - cmac hash.Hash; + w io.Writer + cmac hash.Hash } func (cw *cmacWriter) Write(p []byte) (n int, err os.Error) { - n, err = cw.w.Write(p); - cw.cmac.Write(p[0:n]); - return; + n, err = cw.w.Write(p) + cw.cmac.Write(p[0:n]) + return } // An eaxEncrypter implements the EAX encryption mode. type eaxEncrypter struct { - ctr io.Writer; // CTR encrypter - cw cmacWriter; // CTR's output stream - tag []byte; + ctr io.Writer // CTR encrypter + cw cmacWriter // CTR's output stream + tag []byte } // NewEAXEncrypter creates and returns a new EAX encrypter @@ -98,15 +98,15 @@ type eaxEncrypter struct { // the data it receives and writes that data to w. // The encrypter's Close method writes a final authenticating tag to w. func NewEAXEncrypter(c Cipher, iv []byte, hdr []byte, tagBytes int, w io.Writer) io.WriteCloser { - x := new(eaxEncrypter); + x := new(eaxEncrypter) // Create new CTR instance writing to both // w for encrypted output and cmac for digesting. - x.cw.w = w; - var ctrIV []byte; - ctrIV, x.tag, x.cw.cmac = setupEAX(c, iv, hdr, tagBytes); - x.ctr = NewCTRWriter(c, ctrIV, &x.cw); - return x; + x.cw.w = w + var ctrIV []byte + ctrIV, x.tag, x.cw.cmac = setupEAX(c, iv, hdr, tagBytes) + x.ctr = NewCTRWriter(c, ctrIV, &x.cw) + return x } func (x *eaxEncrypter) Write(p []byte) (n int, err os.Error) { @@ -114,16 +114,16 @@ func (x *eaxEncrypter) Write(p []byte) (n int, err os.Error) { } func (x *eaxEncrypter) Close() os.Error { - x.ctr = nil; // crash if Write is called again + x.ctr = nil // crash if Write is called again // Write tag. - finishEAX(x.tag, x.cw.cmac); - n, err := x.cw.w.Write(x.tag); + finishEAX(x.tag, x.cw.cmac) + n, err := x.cw.w.Write(x.tag) if n != len(x.tag) && err == nil { err = io.ErrShortWrite } - return err; + return err } // Reader adapter. Returns data read from r but hangs @@ -133,10 +133,10 @@ func (x *eaxEncrypter) Close() os.Error { // and the "tee into digest" functionality could be separated, // but the latter half is trivial. type cmacReader struct { - r io.Reader; - cmac hash.Hash; - tag []byte; - tmp []byte; + r io.Reader + cmac hash.Hash + tag []byte + tmp []byte } func (cr *cmacReader) Read(p []byte) (n int, err os.Error) { @@ -147,21 +147,21 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) { // First, read a tag-sized chunk. // It's probably not the tag (unless there's no data). - tag := cr.tag; + tag := cr.tag if len(tag) < cap(tag) { - nt := len(tag); - nn, err1 := io.ReadFull(cr.r, tag[nt:cap(tag)]); - tag = tag[0 : nt+nn]; - cr.tag = tag; + nt := len(tag) + nn, err1 := io.ReadFull(cr.r, tag[nt:cap(tag)]) + tag = tag[0 : nt+nn] + cr.tag = tag if err1 != nil { return 0, err1 } } - tagBytes := len(tag); + tagBytes := len(tag) if len(p) > 4*tagBytes { // If p is big, try to read directly into p to avoid a copy. - n, err = cr.r.Read(p[tagBytes:]); + n, err = cr.r.Read(p[tagBytes:]) if n == 0 { goto out } @@ -173,19 +173,19 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) { for i := 0; i < tagBytes; i++ { tag[i] = p[n+i] } - goto out; + goto out } // Otherwise, read into p and then slide data - n, err = cr.r.Read(p); + n, err = cr.r.Read(p) if n == 0 { goto out } // copy tag+p into p+tmp and then swap tmp, tag - tmp := cr.tmp; + tmp := cr.tmp for i := n + tagBytes - 1; i >= 0; i-- { - var c byte; + var c byte if i < tagBytes { c = tag[i] } else { @@ -197,17 +197,17 @@ func (cr *cmacReader) Read(p []byte) (n int, err os.Error) { tmp[i] = c } } - cr.tmp, cr.tag = tag, tmp; + cr.tmp, cr.tag = tag, tmp out: - cr.cmac.Write(p[0:n]); - return; + cr.cmac.Write(p[0:n]) + return } type eaxDecrypter struct { - ctr io.Reader; - cr cmacReader; - tag []byte; + ctr io.Reader + cr cmacReader + tag []byte } // NewEAXDecrypter creates and returns a new EAX decrypter @@ -220,34 +220,34 @@ type eaxDecrypter struct { // assumed to be valid, authenticated data until Read returns // 0, nil to signal the end of the data. func NewEAXDecrypter(c Cipher, iv []byte, hdr []byte, tagBytes int, r io.Reader) io.Reader { - x := new(eaxDecrypter); + x := new(eaxDecrypter) - x.cr.r = r; - x.cr.tag = make([]byte, 0, tagBytes); - x.cr.tmp = make([]byte, 0, tagBytes); - var ctrIV []byte; - ctrIV, x.tag, x.cr.cmac = setupEAX(c, iv, hdr, tagBytes); - x.ctr = NewCTRReader(c, ctrIV, &x.cr); - return x; + x.cr.r = r + x.cr.tag = make([]byte, 0, tagBytes) + x.cr.tmp = make([]byte, 0, tagBytes) + var ctrIV []byte + ctrIV, x.tag, x.cr.cmac = setupEAX(c, iv, hdr, tagBytes) + x.ctr = NewCTRReader(c, ctrIV, &x.cr) + return x } func (x *eaxDecrypter) checkTag() os.Error { - x.ctr = nil; // crash if Read is called again + x.ctr = nil // crash if Read is called again - finishEAX(x.tag, x.cr.cmac); + finishEAX(x.tag, x.cr.cmac) if !same(x.tag, x.cr.tag) { - e := new(EAXTagError); - e.Computed = copy(x.tag); - e.Read = copy(x.cr.tag); - return e; + e := new(EAXTagError) + e.Computed = copy(x.tag) + e.Read = copy(x.cr.tag) + return e } - return nil; + return nil } func (x *eaxDecrypter) Read(p []byte) (n int, err os.Error) { - n, err = x.ctr.Read(p); + n, err = x.ctr.Read(p) if n == 0 && err == nil { err = x.checkTag() } - return n, err; + return n, err } diff --git a/src/pkg/crypto/block/eax_aes_test.go b/src/pkg/crypto/block/eax_aes_test.go index 43f126d21..a1a099429 100644 --- a/src/pkg/crypto/block/eax_aes_test.go +++ b/src/pkg/crypto/block/eax_aes_test.go @@ -5,21 +5,21 @@ package block import ( - "bytes"; - "crypto/aes"; - "fmt"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "fmt" + "io" + "testing" ) // Test vectors from http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf type eaxAESTest struct { - msg []byte; - key []byte; - nonce []byte; - header []byte; - cipher []byte; + msg []byte + key []byte + nonce []byte + header []byte + cipher []byte } var eaxAESTests = []eaxAESTest{ @@ -96,20 +96,20 @@ var eaxAESTests = []eaxAESTest{ } func TestEAXEncrypt_AES(t *testing.T) { - b := new(bytes.Buffer); + b := new(bytes.Buffer) for i, tt := range eaxAESTests { - test := fmt.Sprintf("test %d", i); - c, err := aes.NewCipher(tt.key); + test := fmt.Sprintf("test %d", i) + c, err := aes.NewCipher(tt.key) if err != nil { t.Fatalf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) } - b.Reset(); - enc := NewEAXEncrypter(c, tt.nonce, tt.header, 16, b); - n, err := io.Copy(enc, bytes.NewBuffer(tt.msg)); + b.Reset() + enc := NewEAXEncrypter(c, tt.nonce, tt.header, 16, b) + n, err := io.Copy(enc, bytes.NewBuffer(tt.msg)) if n != int64(len(tt.msg)) || err != nil { t.Fatalf("%s: io.Copy into encrypter: %d, %s", test, n, err) } - err = enc.Close(); + err = enc.Close() if err != nil { t.Fatalf("%s: enc.Close: %s", test, err) } @@ -120,16 +120,16 @@ func TestEAXEncrypt_AES(t *testing.T) { } func TestEAXDecrypt_AES(t *testing.T) { - b := new(bytes.Buffer); + b := new(bytes.Buffer) for i, tt := range eaxAESTests { - test := fmt.Sprintf("test %d", i); - c, err := aes.NewCipher(tt.key); + test := fmt.Sprintf("test %d", i) + c, err := aes.NewCipher(tt.key) if err != nil { t.Fatalf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) } - b.Reset(); - dec := NewEAXDecrypter(c, tt.nonce, tt.header, 16, bytes.NewBuffer(tt.cipher)); - n, err := io.Copy(b, dec); + b.Reset() + dec := NewEAXDecrypter(c, tt.nonce, tt.header, 16, bytes.NewBuffer(tt.cipher)) + n, err := io.Copy(b, dec) if n != int64(len(tt.msg)) || err != nil { t.Fatalf("%s: io.Copy into decrypter: %d, %s", test, n, err) } diff --git a/src/pkg/crypto/block/ecb.go b/src/pkg/crypto/block/ecb.go index c7491eb9c..73d1d63f7 100644 --- a/src/pkg/crypto/block/ecb.go +++ b/src/pkg/crypto/block/ecb.go @@ -14,32 +14,32 @@ package block import ( - "io"; - "os"; - "strconv"; + "io" + "os" + "strconv" ) type ecbDecrypter struct { - c Cipher; - r io.Reader; - blockSize int; // block size + c Cipher + r io.Reader + blockSize int // block size // Buffered data. // The buffer buf is used as storage for both // plain or crypt; at least one of those is nil at any given time. - buf []byte; - plain []byte; // plain text waiting to be read - crypt []byte; // ciphertext waiting to be decrypted + buf []byte + plain []byte // plain text waiting to be read + crypt []byte // ciphertext waiting to be decrypted } // Read into x.crypt until it has a full block or EOF or an error happens. func (x *ecbDecrypter) fillCrypt() os.Error { - var err os.Error; + var err os.Error for len(x.crypt) < x.blockSize { - off := len(x.crypt); - var m int; - m, err = x.r.Read(x.crypt[off:x.blockSize]); - x.crypt = x.crypt[0 : off+m]; + off := len(x.crypt) + var m int + m, err = x.r.Read(x.crypt[off:x.blockSize]) + x.crypt = x.crypt[0 : off+m] if m == 0 { break } @@ -53,12 +53,12 @@ func (x *ecbDecrypter) fillCrypt() os.Error { break } } - return err; + return err } // Read from plain text buffer into p. func (x *ecbDecrypter) readPlain(p []byte) int { - n := len(x.plain); + n := len(x.plain) if n > len(p) { n = len(p) } @@ -70,7 +70,7 @@ func (x *ecbDecrypter) readPlain(p []byte) int { } else { x.plain = nil } - return n; + return n } type ecbFragmentError int @@ -95,46 +95,46 @@ func (x *ecbDecrypter) Read(p []byte) (n int, err os.Error) { // If there is a leftover cipher text buffer, // try to accumulate a full block. if x.crypt != nil { - err = x.fillCrypt(); + err = x.fillCrypt() if err != nil || len(x.crypt) == 0 { return } - x.c.Decrypt(x.crypt, x.crypt); - x.plain = x.crypt; - x.crypt = nil; + x.c.Decrypt(x.crypt, x.crypt) + x.plain = x.crypt + x.crypt = nil } // If there is a leftover plain text buffer, read from it. if x.plain != nil { - n = x.readPlain(p); - return; + n = x.readPlain(p) + return } // Read and decrypt directly in caller's buffer. - n, err = io.ReadAtLeast(x.r, p, x.blockSize); + n, err = io.ReadAtLeast(x.r, p, x.blockSize) if err == os.EOF && n > 0 { // EOF is only okay on block boundary - err = os.ErrorString("block fragment at EOF during decryption"); - return; + err = os.ErrorString("block fragment at EOF during decryption") + return } - var i int; + var i int for i = 0; i+x.blockSize <= n; i += x.blockSize { - a := p[i : i+x.blockSize]; - x.c.Decrypt(a, a); + a := p[i : i+x.blockSize] + x.c.Decrypt(a, a) } // There might be an encrypted fringe remaining. // Save it for next time. if i < n { - p = p[i:n]; + p = p[i:n] for j, v := range p { x.buf[j] = v } - x.crypt = x.buf[0:len(p)]; - n = i; + x.crypt = x.buf[0:len(p)] + n = i } - return; + return } // NewECBDecrypter returns a reader that reads data from r and decrypts it using c. @@ -143,26 +143,26 @@ func (x *ecbDecrypter) Read(p []byte) (n int, err os.Error) { // The returned Reader does not buffer or read ahead except // as required by the cipher's block size. func NewECBDecrypter(c Cipher, r io.Reader) io.Reader { - x := new(ecbDecrypter); - x.c = c; - x.r = r; - x.blockSize = c.BlockSize(); - x.buf = make([]byte, x.blockSize); - return x; + x := new(ecbDecrypter) + x.c = c + x.r = r + x.blockSize = c.BlockSize() + x.buf = make([]byte, x.blockSize) + return x } type ecbEncrypter struct { - c Cipher; - w io.Writer; - blockSize int; + c Cipher + w io.Writer + blockSize int // Buffered data. // The buffer buf is used as storage for both // plain or crypt. If both are non-nil, plain // follows crypt in buf. - buf []byte; - plain []byte; // plain text waiting to be encrypted - crypt []byte; // encrypted text waiting to be written + buf []byte + plain []byte // plain text waiting to be encrypted + crypt []byte // encrypted text waiting to be written } // Flush the x.crypt buffer to x.w. @@ -170,9 +170,9 @@ func (x *ecbEncrypter) flushCrypt() os.Error { if len(x.crypt) == 0 { return nil } - n, err := x.w.Write(x.crypt); + n, err := x.w.Write(x.crypt) if n < len(x.crypt) { - x.crypt = x.crypt[n:]; + x.crypt = x.crypt[n:] if err == nil { err = io.ErrShortWrite } @@ -180,8 +180,8 @@ func (x *ecbEncrypter) flushCrypt() os.Error { if err != nil { return err } - x.crypt = nil; - return nil; + x.crypt = nil + return nil } // Slide x.plain down to the beginning of x.buf. @@ -196,35 +196,35 @@ func (x *ecbEncrypter) slidePlain() { for i := 0; i < len(x.plain); i++ { x.buf[i] = x.plain[i] } - x.plain = x.buf[0:len(x.plain)]; + x.plain = x.buf[0:len(x.plain)] } } // Fill x.plain from the data in p. // Return the number of bytes copied. func (x *ecbEncrypter) fillPlain(p []byte) int { - off := len(x.plain); - n := len(p); + off := len(x.plain) + n := len(p) if max := cap(x.plain) - off; n > max { n = max } - x.plain = x.plain[0 : off+n]; + x.plain = x.plain[0 : off+n] for i := 0; i < n; i++ { x.plain[off+i] = p[i] } - return n; + return n } // Encrypt x.plain; record encrypted range as x.crypt. func (x *ecbEncrypter) encrypt() { - var i int; - n := len(x.plain); + var i int + n := len(x.plain) for i = 0; i+x.blockSize <= n; i += x.blockSize { - a := x.plain[i : i+x.blockSize]; - x.c.Encrypt(a, a); + a := x.plain[i : i+x.blockSize] + x.c.Encrypt(a, a) } - x.crypt = x.plain[0:i]; - x.plain = x.plain[i:n]; + x.crypt = x.plain[0:i] + x.plain = x.plain[i:n] } func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) { @@ -238,25 +238,25 @@ func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) { // Now that encrypted data is gone (flush ran), // perhaps we need to slide the plaintext down. - x.slidePlain(); + x.slidePlain() // Fill plaintext buffer from p. - m := x.fillPlain(p); + m := x.fillPlain(p) if m == 0 { break } - n += m; - p = p[m:]; + n += m + p = p[m:] // Encrypt, adjusting crypt and plain. - x.encrypt(); + x.encrypt() // Write x.crypt. if err = x.flushCrypt(); err != nil { break } } - return; + return } // NewECBEncrypter returns a writer that encrypts data using c and writes it to w. @@ -265,12 +265,12 @@ func (x *ecbEncrypter) Write(p []byte) (n int, err os.Error) { // The returned Writer does no buffering except as required // by the cipher's block size, so there is no need for a Flush method. func NewECBEncrypter(c Cipher, w io.Writer) io.Writer { - x := new(ecbEncrypter); - x.c = c; - x.w = w; - x.blockSize = c.BlockSize(); + x := new(ecbEncrypter) + x.c = c + x.w = w + x.blockSize = c.BlockSize() // Create a buffer that is an integral number of blocks. - x.buf = make([]byte, 8192/x.blockSize*x.blockSize); - return x; + x.buf = make([]byte, 8192/x.blockSize*x.blockSize) + return x } diff --git a/src/pkg/crypto/block/ecb_aes_test.go b/src/pkg/crypto/block/ecb_aes_test.go index 315ec213d..db0e085fa 100644 --- a/src/pkg/crypto/block/ecb_aes_test.go +++ b/src/pkg/crypto/block/ecb_aes_test.go @@ -11,17 +11,17 @@ package block import ( - "bytes"; - "crypto/aes"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "io" + "testing" ) type ecbTest struct { - name string; - key []byte; - in []byte; - out []byte; + name string + key []byte + in []byte + out []byte } var commonInput = []byte{ @@ -92,28 +92,28 @@ var ecbAESTests = []ecbTest{ func TestECB_AES(t *testing.T) { for _, tt := range ecbAESTests { - test := tt.name; + test := tt.name - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err); - continue; + t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) + continue } - var crypt bytes.Buffer; - w := NewECBEncrypter(c, &crypt); - var r io.Reader = bytes.NewBuffer(tt.in); - n, err := io.Copy(w, r); + var crypt bytes.Buffer + w := NewECBEncrypter(c, &crypt) + var r io.Reader = bytes.NewBuffer(tt.in) + n, err := io.Copy(w, r) if n != int64(len(tt.in)) || err != nil { t.Errorf("%s: ECBReader io.Copy = %d, %v want %d, nil", test, n, err, len(tt.in)) } else if d := crypt.Bytes(); !same(tt.out, d) { t.Errorf("%s: ECBReader\nhave %x\nwant %x", test, d, tt.out) } - var plain bytes.Buffer; - r = NewECBDecrypter(c, bytes.NewBuffer(tt.out)); - w = &plain; - n, err = io.Copy(w, r); + var plain bytes.Buffer + r = NewECBDecrypter(c, bytes.NewBuffer(tt.out)) + w = &plain + n, err = io.Copy(w, r) if n != int64(len(tt.out)) || err != nil { t.Errorf("%s: ECBWriter io.Copy = %d, %v want %d, nil", test, n, err, len(tt.out)) } else if d := plain.Bytes(); !same(tt.in, d) { diff --git a/src/pkg/crypto/block/ecb_test.go b/src/pkg/crypto/block/ecb_test.go index d07afbe94..0d7c4035f 100644 --- a/src/pkg/crypto/block/ecb_test.go +++ b/src/pkg/crypto/block/ecb_test.go @@ -5,22 +5,22 @@ package block import ( - "bytes"; - "fmt"; - "io"; - "testing"; - "testing/iotest"; + "bytes" + "fmt" + "io" + "testing" + "testing/iotest" ) // Simple Cipher for testing: adds an incrementing amount // to each byte in each type IncCipher struct { - blockSize int; - delta byte; - encrypting bool; + blockSize int + delta byte + encrypting bool } -func (c *IncCipher) BlockSize() int { return c.blockSize } +func (c *IncCipher) BlockSize() int { return c.blockSize } func (c *IncCipher) Encrypt(src, dst []byte) { if !c.encrypting { @@ -29,7 +29,7 @@ func (c *IncCipher) Encrypt(src, dst []byte) { if len(src) != c.blockSize || len(dst) != c.blockSize { panicln("encrypt: wrong block size", c.blockSize, len(src), len(dst)) } - c.delta++; + c.delta++ for i, b := range src { dst[i] = b + c.delta } @@ -42,62 +42,62 @@ func (c *IncCipher) Decrypt(src, dst []byte) { if len(src) != c.blockSize || len(dst) != c.blockSize { panicln("decrypt: wrong block size", c.blockSize, len(src), len(dst)) } - c.delta--; + c.delta-- for i, b := range src { dst[i] = b + c.delta } } func TestECBEncrypter(t *testing.T) { - var plain, crypt [256]byte; + var plain, crypt [256]byte for i := 0; i < len(plain); i++ { plain[i] = byte(i) } - b := new(bytes.Buffer); + b := new(bytes.Buffer) for block := 1; block <= 64; block *= 2 { // compute encrypted version - delta := byte(0); + delta := byte(0) for i := 0; i < len(crypt); i++ { if i%block == 0 { delta++ } - crypt[i] = plain[i] + delta; + crypt[i] = plain[i] + delta } for frag := 0; frag < 2; frag++ { - c := &IncCipher{block, 0, true}; - b.Reset(); - r := bytes.NewBuffer(&plain); - w := NewECBEncrypter(c, b); + c := &IncCipher{block, 0, true} + b.Reset() + r := bytes.NewBuffer(&plain) + w := NewECBEncrypter(c, b) // copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ... // if frag != 0, move the 1 to the end to cause fragmentation. if frag == 0 { - _, err := io.Copyn(w, r, 1); + _, err := io.Copyn(w, r, 1) if err != nil { - t.Errorf("block=%d frag=0: first Copyn: %s", block, err); - continue; + t.Errorf("block=%d frag=0: first Copyn: %s", block, err) + continue } } for n := 1; n <= len(plain)/2; n *= 2 { - _, err := io.Copyn(w, r, int64(n)); + _, err := io.Copyn(w, r, int64(n)) if err != nil { t.Errorf("block=%d frag=%d: Copyn %d: %s", block, frag, n, err) } } if frag != 0 { - _, err := io.Copyn(w, r, 1); + _, err := io.Copyn(w, r, 1) if err != nil { - t.Errorf("block=%d frag=1: last Copyn: %s", block, err); - continue; + t.Errorf("block=%d frag=1: last Copyn: %s", block, err) + continue } } // check output - data := b.Bytes(); + data := b.Bytes() if len(data) != len(crypt) { - t.Errorf("block=%d frag=%d: want %d bytes, got %d", block, frag, len(crypt), len(data)); - continue; + t.Errorf("block=%d frag=%d: want %d bytes, got %d", block, frag, len(crypt), len(data)) + continue } if string(data) != string(&crypt) { @@ -112,57 +112,57 @@ func testECBDecrypter(t *testing.T, maxio int) { func(r io.Reader) io.Reader { return r }, iotest.OneByteReader, iotest.HalfReader, - }; - var plain, crypt [256]byte; + } + var plain, crypt [256]byte for i := 0; i < len(plain); i++ { plain[i] = byte(255 - i) } - b := new(bytes.Buffer); + b := new(bytes.Buffer) for block := 1; block <= 64 && block <= maxio; block *= 2 { // compute encrypted version - delta := byte(0); + delta := byte(0) for i := 0; i < len(crypt); i++ { if i%block == 0 { delta++ } - crypt[i] = plain[i] + delta; + crypt[i] = plain[i] + delta } for mode := 0; mode < len(readers); mode++ { for frag := 0; frag < 2; frag++ { - test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio); - c := &IncCipher{block, 0, false}; - b.Reset(); - r := NewECBDecrypter(c, readers[mode](bytes.NewBuffer(crypt[0:maxio]))); + test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio) + c := &IncCipher{block, 0, false} + b.Reset() + r := NewECBDecrypter(c, readers[mode](bytes.NewBuffer(crypt[0:maxio]))) // read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ... // if frag == 1, move the 1 to the end to cause fragmentation. if frag == 0 { - _, err := io.Copyn(b, r, 1); + _, err := io.Copyn(b, r, 1) if err != nil { - t.Errorf("%s: first Copyn: %s", test, err); - continue; + t.Errorf("%s: first Copyn: %s", test, err) + continue } } for n := 1; n <= maxio/2; n *= 2 { - _, err := io.Copyn(b, r, int64(n)); + _, err := io.Copyn(b, r, int64(n)) if err != nil { t.Errorf("%s: Copyn %d: %s", test, n, err) } } if frag != 0 { - _, err := io.Copyn(b, r, 1); + _, err := io.Copyn(b, r, 1) if err != nil { - t.Errorf("%s: last Copyn: %s", test, err); - continue; + t.Errorf("%s: last Copyn: %s", test, err) + continue } } // check output - data := b.Bytes(); + data := b.Bytes() if len(data) != maxio { - t.Errorf("%s: want %d bytes, got %d", test, maxio, len(data)); - continue; + t.Errorf("%s: want %d bytes, got %d", test, maxio, len(data)) + continue } if string(data) != string(plain[0:maxio]) { diff --git a/src/pkg/crypto/block/ofb.go b/src/pkg/crypto/block/ofb.go index c297541e3..bffdc53db 100644 --- a/src/pkg/crypto/block/ofb.go +++ b/src/pkg/crypto/block/ofb.go @@ -13,28 +13,28 @@ package block import ( - "io"; + "io" ) type ofbStream struct { - c Cipher; - iv []byte; + c Cipher + iv []byte } func newOFBStream(c Cipher, iv []byte) *ofbStream { - x := new(ofbStream); - x.c = c; - n := len(iv); + x := new(ofbStream) + x.c = c + n := len(iv) if n != c.BlockSize() { panicln("crypto/block: newOFBStream: invalid iv size", n, "!=", c.BlockSize()) } - x.iv = copy(iv); - return x; + x.iv = copy(iv) + return x } func (x *ofbStream) Next() []byte { - x.c.Encrypt(x.iv, x.iv); - return x.iv; + x.c.Encrypt(x.iv, x.iv) + return x.iv } // NewOFBReader returns a reader that reads data from r, decrypts (or encrypts) diff --git a/src/pkg/crypto/block/ofb_aes_test.go b/src/pkg/crypto/block/ofb_aes_test.go index 80af78fe4..f2faa4432 100644 --- a/src/pkg/crypto/block/ofb_aes_test.go +++ b/src/pkg/crypto/block/ofb_aes_test.go @@ -11,18 +11,18 @@ package block import ( - "bytes"; - "crypto/aes"; - "io"; - "testing"; + "bytes" + "crypto/aes" + "io" + "testing" ) type ofbTest struct { - name string; - key []byte; - iv []byte; - in []byte; - out []byte; + name string + key []byte + iv []byte + in []byte + out []byte } var ofbAESTests = []ofbTest{ @@ -67,20 +67,20 @@ var ofbAESTests = []ofbTest{ func TestOFB_AES(t *testing.T) { for _, tt := range ofbAESTests { - test := tt.name; + test := tt.name - c, err := aes.NewCipher(tt.key); + c, err := aes.NewCipher(tt.key) if err != nil { - t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err); - continue; + t.Errorf("%s: NewCipher(%d bytes) = %s", test, len(tt.key), err) + continue } for j := 0; j <= 5; j += 5 { - var crypt bytes.Buffer; - in := tt.in[0 : len(tt.in)-j]; - w := NewOFBWriter(c, tt.iv, &crypt); - var r io.Reader = bytes.NewBuffer(in); - n, err := io.Copy(w, r); + var crypt bytes.Buffer + in := tt.in[0 : len(tt.in)-j] + w := NewOFBWriter(c, tt.iv, &crypt) + var r io.Reader = bytes.NewBuffer(in) + n, err := io.Copy(w, r) if n != int64(len(in)) || err != nil { t.Errorf("%s/%d: OFBWriter io.Copy = %d, %v want %d, nil", test, len(in), n, err, len(in)) } else if d, out := crypt.Bytes(), tt.out[0:len(in)]; !same(out, d) { @@ -89,11 +89,11 @@ func TestOFB_AES(t *testing.T) { } for j := 0; j <= 7; j += 7 { - var plain bytes.Buffer; - out := tt.out[0 : len(tt.out)-j]; - r := NewOFBReader(c, tt.iv, bytes.NewBuffer(out)); - w := &plain; - n, err := io.Copy(w, r); + var plain bytes.Buffer + out := tt.out[0 : len(tt.out)-j] + r := NewOFBReader(c, tt.iv, bytes.NewBuffer(out)) + w := &plain + n, err := io.Copy(w, r) if n != int64(len(out)) || err != nil { t.Errorf("%s/%d: OFBReader io.Copy = %d, %v want %d, nil", test, len(out), n, err, len(out)) } else if d, in := plain.Bytes(), tt.in[0:len(out)]; !same(in, d) { diff --git a/src/pkg/crypto/block/xor.go b/src/pkg/crypto/block/xor.go index ffb76c5c4..9d8b17224 100644 --- a/src/pkg/crypto/block/xor.go +++ b/src/pkg/crypto/block/xor.go @@ -7,8 +7,8 @@ package block import ( - "io"; - "os"; + "io" + "os" ) // A dataStream is an interface to an unending stream of data, @@ -16,62 +16,62 @@ import ( // Calls to Next() return sequential blocks of data from the stream. // Each call must return at least one byte: there is no EOF. type dataStream interface { - Next() []byte; + Next() []byte } type xorReader struct { - r io.Reader; - rand dataStream; // pseudo-random - buf []byte; // data available from last call to rand + r io.Reader + rand dataStream // pseudo-random + buf []byte // data available from last call to rand } func newXorReader(rand dataStream, r io.Reader) io.Reader { - x := new(xorReader); - x.r = r; - x.rand = rand; - return x; + x := new(xorReader) + x.r = r + x.rand = rand + return x } func (x *xorReader) Read(p []byte) (n int, err os.Error) { - n, err = x.r.Read(p); + n, err = x.r.Read(p) // xor input with stream. - bp := 0; - buf := x.buf; + bp := 0 + buf := x.buf for i := 0; i < n; i++ { if bp >= len(buf) { - buf = x.rand.Next(); - bp = 0; + buf = x.rand.Next() + bp = 0 } - p[i] ^= buf[bp]; - bp++; + p[i] ^= buf[bp] + bp++ } - x.buf = buf[bp:]; - return n, err; + x.buf = buf[bp:] + return n, err } type xorWriter struct { - w io.Writer; - rand dataStream; // pseudo-random - buf []byte; // last buffer returned by rand - extra []byte; // extra random data (use before buf) - work []byte; // work space + w io.Writer + rand dataStream // pseudo-random + buf []byte // last buffer returned by rand + extra []byte // extra random data (use before buf) + work []byte // work space } func newXorWriter(rand dataStream, w io.Writer) io.Writer { - x := new(xorWriter); - x.w = w; - x.rand = rand; - x.work = make([]byte, 4096); - return x; + x := new(xorWriter) + x.w = w + x.rand = rand + x.work = make([]byte, 4096) + return x } func (x *xorWriter) Write(p []byte) (n int, err os.Error) { for len(p) > 0 { // Determine next chunk of random data // and xor with p into x.work. - var chunk []byte; - m := len(p); + var chunk []byte + m := len(p) if nn := len(x.extra); nn > 0 { // extra points into work, so edit directly if m > nn { @@ -80,29 +80,29 @@ func (x *xorWriter) Write(p []byte) (n int, err os.Error) { for i := 0; i < m; i++ { x.extra[i] ^= p[i] } - chunk = x.extra[0:m]; + chunk = x.extra[0:m] } else { // xor p ^ buf into work, refreshing buf as needed if nn := len(x.work); m > nn { m = nn } - bp := 0; - buf := x.buf; + bp := 0 + buf := x.buf for i := 0; i < m; i++ { if bp >= len(buf) { - buf = x.rand.Next(); - bp = 0; + buf = x.rand.Next() + bp = 0 } - x.work[i] = buf[bp] ^ p[i]; - bp++; + x.work[i] = buf[bp] ^ p[i] + bp++ } - x.buf = buf[bp:]; - chunk = x.work[0:m]; + x.buf = buf[bp:] + chunk = x.work[0:m] } // Write chunk. - var nn int; - nn, err = x.w.Write(chunk); + var nn int + nn, err = x.w.Write(chunk) if nn != len(chunk) && err == nil { err = io.ErrShortWrite } @@ -112,13 +112,13 @@ func (x *xorWriter) Write(p []byte) (n int, err os.Error) { for i := nn; i < m; i++ { chunk[i] ^= p[i] } - x.extra = chunk[nn:]; + x.extra = chunk[nn:] } - n += nn; + n += nn if err != nil { return } - p = p[m:]; + p = p[m:] } - return; + return } diff --git a/src/pkg/crypto/block/xor_test.go b/src/pkg/crypto/block/xor_test.go index 1815be3fc..87b493a40 100644 --- a/src/pkg/crypto/block/xor_test.go +++ b/src/pkg/crypto/block/xor_test.go @@ -5,80 +5,80 @@ package block import ( - "bytes"; - "fmt"; - "io"; - "testing"; - "testing/iotest"; + "bytes" + "fmt" + "io" + "testing" + "testing/iotest" ) // Simple "pseudo-random" stream for testing. type incStream struct { - buf []byte; - n byte; + buf []byte + n byte } func newIncStream(blockSize int) *incStream { - x := new(incStream); - x.buf = make([]byte, blockSize); - return x; + x := new(incStream) + x.buf = make([]byte, blockSize) + return x } func (x *incStream) Next() []byte { - x.n++; + x.n++ for i := range x.buf { - x.buf[i] = x.n; - x.n++; + x.buf[i] = x.n + x.n++ } - return x.buf; + return x.buf } func testXorWriter(t *testing.T, maxio int) { - var plain, crypt [256]byte; + var plain, crypt [256]byte for i := 0; i < len(plain); i++ { plain[i] = byte(i) } - b := new(bytes.Buffer); + b := new(bytes.Buffer) for block := 1; block <= 64 && block <= maxio; block *= 2 { // compute encrypted version - n := byte(0); + n := byte(0) for i := 0; i < len(crypt); i++ { if i%block == 0 { n++ } - crypt[i] = plain[i] ^ n; - n++; + crypt[i] = plain[i] ^ n + n++ } for frag := 0; frag < 2; frag++ { - test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio); - b.Reset(); - r := bytes.NewBuffer(&plain); - s := newIncStream(block); - w := newXorWriter(s, b); + test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio) + b.Reset() + r := bytes.NewBuffer(&plain) + s := newIncStream(block) + w := newXorWriter(s, b) // copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ... // if frag != 0, move the 1 to the end to cause fragmentation. if frag == 0 { - _, err := io.Copyn(w, r, 1); + _, err := io.Copyn(w, r, 1) if err != nil { - t.Errorf("%s: first Copyn: %s", test, err); - continue; + t.Errorf("%s: first Copyn: %s", test, err) + continue } } for n := 1; n <= len(plain)/2; n *= 2 { - _, err := io.Copyn(w, r, int64(n)); + _, err := io.Copyn(w, r, int64(n)) if err != nil { t.Errorf("%s: Copyn %d: %s", test, n, err) } } // check output - crypt := crypt[0 : len(crypt)-frag]; - data := b.Bytes(); + crypt := crypt[0 : len(crypt)-frag] + data := b.Bytes() if len(data) != len(crypt) { - t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data)); - continue; + t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data)) + continue } if string(data) != string(crypt) { @@ -101,53 +101,53 @@ func testXorReader(t *testing.T, maxio int) { func(r io.Reader) io.Reader { return r }, iotest.OneByteReader, iotest.HalfReader, - }; - var plain, crypt [256]byte; + } + var plain, crypt [256]byte for i := 0; i < len(plain); i++ { plain[i] = byte(255 - i) } - b := new(bytes.Buffer); + b := new(bytes.Buffer) for block := 1; block <= 64 && block <= maxio; block *= 2 { // compute encrypted version - n := byte(0); + n := byte(0) for i := 0; i < len(crypt); i++ { if i%block == 0 { n++ } - crypt[i] = plain[i] ^ n; - n++; + crypt[i] = plain[i] ^ n + n++ } for mode := 0; mode < len(readers); mode++ { for frag := 0; frag < 2; frag++ { - test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio); - s := newIncStream(block); - b.Reset(); - r := newXorReader(s, readers[mode](bytes.NewBuffer(crypt[0:maxio]))); + test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio) + s := newIncStream(block) + b.Reset() + r := newXorReader(s, readers[mode](bytes.NewBuffer(crypt[0:maxio]))) // read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ... // if frag == 1, move the 1 to the end to cause fragmentation. if frag == 0 { - _, err := io.Copyn(b, r, 1); + _, err := io.Copyn(b, r, 1) if err != nil { - t.Errorf("%s: first Copyn: %s", test, err); - continue; + t.Errorf("%s: first Copyn: %s", test, err) + continue } } for n := 1; n <= maxio/2; n *= 2 { - _, err := io.Copyn(b, r, int64(n)); + _, err := io.Copyn(b, r, int64(n)) if err != nil { t.Errorf("%s: Copyn %d: %s", test, n, err) } } // check output - data := b.Bytes(); - crypt := crypt[0 : maxio-frag]; - plain := plain[0 : maxio-frag]; + data := b.Bytes() + crypt := crypt[0 : maxio-frag] + plain := plain[0 : maxio-frag] if len(data) != len(plain) { - t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data)); - continue; + t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data)) + continue } if string(data) != string(plain) { diff --git a/src/pkg/crypto/hmac/hmac.go b/src/pkg/crypto/hmac/hmac.go index 8a9a4cbb5..38d13738d 100644 --- a/src/pkg/crypto/hmac/hmac.go +++ b/src/pkg/crypto/hmac/hmac.go @@ -9,10 +9,10 @@ package hmac import ( - "crypto/md5"; - "crypto/sha1"; - "hash"; - "os"; + "crypto/md5" + "crypto/sha1" + "hash" + "os" ) // FIPS 198: @@ -30,14 +30,14 @@ const ( // MD5 and SHA1, and both use 64-byte blocks. // The hash.Hash interface doesn't provide a // way to find out the block size. - padSize = 64; + padSize = 64 ) type hmac struct { - size int; - key []byte; - tmp []byte; - inner hash.Hash; + size int + key []byte + tmp []byte + inner hash.Hash } func (h *hmac) tmpPad(xor byte) { @@ -50,49 +50,49 @@ func (h *hmac) tmpPad(xor byte) { } func (h *hmac) Sum() []byte { - h.tmpPad(0x5c); - sum := h.inner.Sum(); + h.tmpPad(0x5c) + sum := h.inner.Sum() for i, b := range sum { h.tmp[padSize+i] = b } - h.inner.Reset(); - h.inner.Write(h.tmp); - return h.inner.Sum(); + h.inner.Reset() + h.inner.Write(h.tmp) + return h.inner.Sum() } func (h *hmac) Write(p []byte) (n int, err os.Error) { return h.inner.Write(p) } -func (h *hmac) Size() int { return h.size } +func (h *hmac) Size() int { return h.size } func (h *hmac) Reset() { - h.inner.Reset(); - h.tmpPad(0x36); - h.inner.Write(h.tmp[0:padSize]); + h.inner.Reset() + h.tmpPad(0x36) + h.inner.Write(h.tmp[0:padSize]) } // New returns a new HMAC hash using the given hash and key. func New(h hash.Hash, key []byte) hash.Hash { if len(key) > padSize { // If key is too big, hash it. - h.Write(key); - key = h.Sum(); + h.Write(key) + key = h.Sum() } - hm := new(hmac); - hm.inner = h; - hm.size = h.Size(); - hm.key = make([]byte, len(key)); + hm := new(hmac) + hm.inner = h + hm.size = h.Size() + hm.key = make([]byte, len(key)) for i, k := range key { hm.key[i] = k } - hm.tmp = make([]byte, padSize+hm.size); - hm.Reset(); - return hm; + hm.tmp = make([]byte, padSize+hm.size) + hm.Reset() + return hm } // NewMD5 returns a new HMAC-MD5 hash using the given key. -func NewMD5(key []byte) hash.Hash { return New(md5.New(), key) } +func NewMD5(key []byte) hash.Hash { return New(md5.New(), key) } // NewSHA1 returns a new HMAC-SHA1 hash using the given key. -func NewSHA1(key []byte) hash.Hash { return New(sha1.New(), key) } +func NewSHA1(key []byte) hash.Hash { return New(sha1.New(), key) } diff --git a/src/pkg/crypto/hmac/hmac_test.go b/src/pkg/crypto/hmac/hmac_test.go index 1c81fd990..98e32df01 100644 --- a/src/pkg/crypto/hmac/hmac_test.go +++ b/src/pkg/crypto/hmac/hmac_test.go @@ -5,17 +5,17 @@ package hmac import ( - "hash"; - "fmt"; - "strings"; - "testing"; + "hash" + "fmt" + "strings" + "testing" ) type hmacTest struct { - hash func([]byte) hash.Hash; - key []byte; - in []byte; - out string; + hash func([]byte) hash.Hash + key []byte + in []byte + out string } // Tests from US FIPS 198 @@ -78,20 +78,20 @@ var hmacTests = []hmacTest{ func TestHMAC(t *testing.T) { for i, tt := range hmacTests { - h := tt.hash(tt.key); + h := tt.hash(tt.key) for j := 0; j < 2; j++ { - n, err := h.Write(tt.in); + n, err := h.Write(tt.in) if n != len(tt.in) || err != nil { - t.Errorf("test %d.%d: Write(%d) = %d, %v", i, j, len(tt.in), n, err); - continue; + t.Errorf("test %d.%d: Write(%d) = %d, %v", i, j, len(tt.in), n, err) + continue } - sum := fmt.Sprintf("%x", h.Sum()); + sum := fmt.Sprintf("%x", h.Sum()) if sum != tt.out { t.Errorf("test %d.%d: have %s want %s\n", i, j, sum, tt.out) } // Second iteration: make sure reset works. - h.Reset(); + h.Reset() } } } diff --git a/src/pkg/crypto/md4/md4.go b/src/pkg/crypto/md4/md4.go index 8efb74e47..650fce313 100644 --- a/src/pkg/crypto/md4/md4.go +++ b/src/pkg/crypto/md4/md4.go @@ -6,81 +6,81 @@ package md4 import ( - "hash"; - "os"; + "hash" + "os" ) // The size of an MD4 checksum in bytes. const Size = 16 const ( - _Chunk = 64; - _Init0 = 0x67452301; - _Init1 = 0xEFCDAB89; - _Init2 = 0x98BADCFE; - _Init3 = 0x10325476; + _Chunk = 64 + _Init0 = 0x67452301 + _Init1 = 0xEFCDAB89 + _Init2 = 0x98BADCFE + _Init3 = 0x10325476 ) // digest represents the partial evaluation of a checksum. type digest struct { - s [4]uint32; - x [_Chunk]byte; - nx int; - len uint64; + s [4]uint32 + x [_Chunk]byte + nx int + len uint64 } func (d *digest) Reset() { - d.s[0] = _Init0; - d.s[1] = _Init1; - d.s[2] = _Init2; - d.s[3] = _Init3; - d.nx = 0; - d.len = 0; + d.s[0] = _Init0 + d.s[1] = _Init1 + d.s[2] = _Init2 + d.s[3] = _Init3 + d.nx = 0 + d.len = 0 } // New returns a new hash.Hash computing the MD4 checksum. func New() hash.Hash { - d := new(digest); - d.Reset(); - return d; + d := new(digest) + d.Reset() + return d } -func (d *digest) Size() int { return Size } +func (d *digest) Size() int { return Size } func (d *digest) Write(p []byte) (nn int, err os.Error) { - nn = len(p); - d.len += uint64(nn); + nn = len(p) + d.len += uint64(nn) if d.nx > 0 { - n := len(p); + n := len(p) if n > _Chunk-d.nx { n = _Chunk - d.nx } for i := 0; i < n; i++ { d.x[d.nx+i] = p[i] } - d.nx += n; + d.nx += n if d.nx == _Chunk { - _Block(d, &d.x); - d.nx = 0; + _Block(d, &d.x) + d.nx = 0 } - p = p[n:]; + p = p[n:] } - n := _Block(d, p); - p = p[n:]; + n := _Block(d, p) + p = p[n:] if len(p) > 0 { for i := 0; i < len(p); i++ { d.x[i] = p[i] } - d.nx = len(p); + d.nx = len(p) } - return; + return } func (d *digest) Sum() []byte { // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - len := d.len; - var tmp [64]byte; - tmp[0] = 0x80; + len := d.len + var tmp [64]byte + tmp[0] = 0x80 if len%64 < 56 { d.Write(tmp[0 : 56-len%64]) } else { @@ -88,28 +88,28 @@ func (d *digest) Sum() []byte { } // Length in bits. - len <<= 3; + len <<= 3 for i := uint(0); i < 8; i++ { tmp[i] = byte(len >> (8 * i)) } - d.Write(tmp[0:8]); + d.Write(tmp[0:8]) if d.nx != 0 { panicln("oops") } - p := make([]byte, 16); - j := 0; + p := make([]byte, 16) + j := 0 for i := 0; i < 4; i++ { - s := d.s[i]; - p[j] = byte(s); - j++; - p[j] = byte(s >> 8); - j++; - p[j] = byte(s >> 16); - j++; - p[j] = byte(s >> 24); - j++; + s := d.s[i] + p[j] = byte(s) + j++ + p[j] = byte(s >> 8) + j++ + p[j] = byte(s >> 16) + j++ + p[j] = byte(s >> 24) + j++ } - return p; + return p } diff --git a/src/pkg/crypto/md4/md4_test.go b/src/pkg/crypto/md4/md4_test.go index 31aa67527..9cab80c63 100644 --- a/src/pkg/crypto/md4/md4_test.go +++ b/src/pkg/crypto/md4/md4_test.go @@ -5,14 +5,14 @@ package md4 import ( - "fmt"; - "io"; - "testing"; + "fmt" + "io" + "testing" ) type md4Test struct { - out string; - in string; + out string + in string } var golden = []md4Test{ @@ -51,16 +51,16 @@ var golden = []md4Test{ func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { - g := golden[i]; - c := New(); + g := golden[i] + c := New() for j := 0; j < 2; j++ { - io.WriteString(c, g.in); - s := fmt.Sprintf("%x", c.Sum()); + io.WriteString(c, g.in) + s := fmt.Sprintf("%x", c.Sum()) if s != g.out { - t.Errorf("md4[%d](%s) = %s want %s", j, g.in, s, g.out); - t.FailNow(); + t.Errorf("md4[%d](%s) = %s want %s", j, g.in, s, g.out) + t.FailNow() } - c.Reset(); + c.Reset() } } } diff --git a/src/pkg/crypto/md4/md4block.go b/src/pkg/crypto/md4/md4block.go index 6f2c2d5a2..492e960ca 100644 --- a/src/pkg/crypto/md4/md4block.go +++ b/src/pkg/crypto/md4/md4block.go @@ -16,18 +16,18 @@ var xIndex2 = []uint{0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15} var xIndex3 = []uint{0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15} func _Block(dig *digest, p []byte) int { - a := dig.s[0]; - b := dig.s[1]; - c := dig.s[2]; - d := dig.s[3]; - n := 0; - var X [16]uint32; + a := dig.s[0] + b := dig.s[1] + c := dig.s[2] + d := dig.s[3] + n := 0 + var X [16]uint32 for len(p) >= _Chunk { - aa, bb, cc, dd := a, b, c, d; + aa, bb, cc, dd := a, b, c, d for i := 0; i < 16; i++ { - j := i * 4; - X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24; + j := i * 4 + X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24 } // If this needs to be made faster in the future, @@ -40,46 +40,46 @@ func _Block(dig *digest, p []byte) int { // Round 1. for i := 0; i < 16; i++ { - x := i; - s := shift1[i%4]; - f := ((c ^ d) & b) ^ d; - a += f + X[x]; - a = a<<s | a>>(32-s); - a, b, c, d = d, a, b, c; + x := i + s := shift1[i%4] + f := ((c ^ d) & b) ^ d + a += f + X[x] + a = a<<s | a>>(32-s) + a, b, c, d = d, a, b, c } // Round 2. for i := 0; i < 16; i++ { - x := xIndex2[i]; - s := shift2[i%4]; - g := (b & c) | (b & d) | (c & d); - a += g + X[x] + 0x5a827999; - a = a<<s | a>>(32-s); - a, b, c, d = d, a, b, c; + x := xIndex2[i] + s := shift2[i%4] + g := (b & c) | (b & d) | (c & d) + a += g + X[x] + 0x5a827999 + a = a<<s | a>>(32-s) + a, b, c, d = d, a, b, c } // Round 3. for i := 0; i < 16; i++ { - x := xIndex3[i]; - s := shift3[i%4]; - h := b ^ c ^ d; - a += h + X[x] + 0x6ed9eba1; - a = a<<s | a>>(32-s); - a, b, c, d = d, a, b, c; + x := xIndex3[i] + s := shift3[i%4] + h := b ^ c ^ d + a += h + X[x] + 0x6ed9eba1 + a = a<<s | a>>(32-s) + a, b, c, d = d, a, b, c } - a += aa; - b += bb; - c += cc; - d += dd; + a += aa + b += bb + c += cc + d += dd - p = p[_Chunk:]; - n += _Chunk; + p = p[_Chunk:] + n += _Chunk } - dig.s[0] = a; - dig.s[1] = b; - dig.s[2] = c; - dig.s[3] = d; - return n; + dig.s[0] = a + dig.s[1] = b + dig.s[2] = c + dig.s[3] = d + return n } diff --git a/src/pkg/crypto/md5/md5.go b/src/pkg/crypto/md5/md5.go index 375288691..2ee57f421 100644 --- a/src/pkg/crypto/md5/md5.go +++ b/src/pkg/crypto/md5/md5.go @@ -6,81 +6,81 @@ package md5 import ( - "hash"; - "os"; + "hash" + "os" ) // The size of an MD5 checksum in bytes. const Size = 16 const ( - _Chunk = 64; - _Init0 = 0x67452301; - _Init1 = 0xEFCDAB89; - _Init2 = 0x98BADCFE; - _Init3 = 0x10325476; + _Chunk = 64 + _Init0 = 0x67452301 + _Init1 = 0xEFCDAB89 + _Init2 = 0x98BADCFE + _Init3 = 0x10325476 ) // digest represents the partial evaluation of a checksum. type digest struct { - s [4]uint32; - x [_Chunk]byte; - nx int; - len uint64; + s [4]uint32 + x [_Chunk]byte + nx int + len uint64 } func (d *digest) Reset() { - d.s[0] = _Init0; - d.s[1] = _Init1; - d.s[2] = _Init2; - d.s[3] = _Init3; - d.nx = 0; - d.len = 0; + d.s[0] = _Init0 + d.s[1] = _Init1 + d.s[2] = _Init2 + d.s[3] = _Init3 + d.nx = 0 + d.len = 0 } // New returns a new hash.Hash computing the MD5 checksum. func New() hash.Hash { - d := new(digest); - d.Reset(); - return d; + d := new(digest) + d.Reset() + return d } -func (d *digest) Size() int { return Size } +func (d *digest) Size() int { return Size } func (d *digest) Write(p []byte) (nn int, err os.Error) { - nn = len(p); - d.len += uint64(nn); + nn = len(p) + d.len += uint64(nn) if d.nx > 0 { - n := len(p); + n := len(p) if n > _Chunk-d.nx { n = _Chunk - d.nx } for i := 0; i < n; i++ { d.x[d.nx+i] = p[i] } - d.nx += n; + d.nx += n if d.nx == _Chunk { - _Block(d, &d.x); - d.nx = 0; + _Block(d, &d.x) + d.nx = 0 } - p = p[n:]; + p = p[n:] } - n := _Block(d, p); - p = p[n:]; + n := _Block(d, p) + p = p[n:] if len(p) > 0 { for i := 0; i < len(p); i++ { d.x[i] = p[i] } - d.nx = len(p); + d.nx = len(p) } - return; + return } func (d *digest) Sum() []byte { // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - len := d.len; - var tmp [64]byte; - tmp[0] = 0x80; + len := d.len + var tmp [64]byte + tmp[0] = 0x80 if len%64 < 56 { d.Write(tmp[0 : 56-len%64]) } else { @@ -88,28 +88,28 @@ func (d *digest) Sum() []byte { } // Length in bits. - len <<= 3; + len <<= 3 for i := uint(0); i < 8; i++ { tmp[i] = byte(len >> (8 * i)) } - d.Write(tmp[0:8]); + d.Write(tmp[0:8]) if d.nx != 0 { panicln("oops") } - p := make([]byte, 16); - j := 0; + p := make([]byte, 16) + j := 0 for i := 0; i < 4; i++ { - s := d.s[i]; - p[j] = byte(s); - j++; - p[j] = byte(s >> 8); - j++; - p[j] = byte(s >> 16); - j++; - p[j] = byte(s >> 24); - j++; + s := d.s[i] + p[j] = byte(s) + j++ + p[j] = byte(s >> 8) + j++ + p[j] = byte(s >> 16) + j++ + p[j] = byte(s >> 24) + j++ } - return p; + return p } diff --git a/src/pkg/crypto/md5/md5_test.go b/src/pkg/crypto/md5/md5_test.go index 51fd5a53a..7d5737b26 100644 --- a/src/pkg/crypto/md5/md5_test.go +++ b/src/pkg/crypto/md5/md5_test.go @@ -5,14 +5,14 @@ package md5 import ( - "fmt"; - "io"; - "testing"; + "fmt" + "io" + "testing" ) type md5Test struct { - out string; - in string; + out string + in string } var golden = []md5Test{ @@ -51,16 +51,16 @@ var golden = []md5Test{ func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { - g := golden[i]; - c := New(); + g := golden[i] + c := New() for j := 0; j < 2; j++ { - io.WriteString(c, g.in); - s := fmt.Sprintf("%x", c.Sum()); + io.WriteString(c, g.in) + s := fmt.Sprintf("%x", c.Sum()) if s != g.out { - t.Errorf("md5[%d](%s) = %s want %s", j, g.in, s, g.out); - t.FailNow(); + t.Errorf("md5[%d](%s) = %s want %s", j, g.in, s, g.out) + t.FailNow() } - c.Reset(); + c.Reset() } } } diff --git a/src/pkg/crypto/md5/md5block.go b/src/pkg/crypto/md5/md5block.go index 4421acf8e..f35096d50 100644 --- a/src/pkg/crypto/md5/md5block.go +++ b/src/pkg/crypto/md5/md5block.go @@ -89,18 +89,18 @@ var shift3 = []uint{4, 11, 16, 23} var shift4 = []uint{6, 10, 15, 21} func _Block(dig *digest, p []byte) int { - a := dig.s[0]; - b := dig.s[1]; - c := dig.s[2]; - d := dig.s[3]; - n := 0; - var X [16]uint32; + a := dig.s[0] + b := dig.s[1] + c := dig.s[2] + d := dig.s[3] + n := 0 + var X [16]uint32 for len(p) >= _Chunk { - aa, bb, cc, dd := a, b, c, d; + aa, bb, cc, dd := a, b, c, d for i := 0; i < 16; i++ { - j := i * 4; - X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24; + j := i * 4 + X[i] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24 } // If this needs to be made faster in the future, @@ -113,64 +113,64 @@ func _Block(dig *digest, p []byte) int { // Round 1. for i := 0; i < 16; i++ { - x := i; - t := i; - s := shift1[i%4]; - f := ((c ^ d) & b) ^ d; - a += f + X[x] + table[t]; - a = a<<s | a>>(32-s); - a += b; - a, b, c, d = d, a, b, c; + x := i + t := i + s := shift1[i%4] + f := ((c ^ d) & b) ^ d + a += f + X[x] + table[t] + a = a<<s | a>>(32-s) + a += b + a, b, c, d = d, a, b, c } // Round 2. for i := 0; i < 16; i++ { - x := (1 + 5*i) % 16; - t := 16 + i; - s := shift2[i%4]; - g := ((b ^ c) & d) ^ c; - a += g + X[x] + table[t]; - a = a<<s | a>>(32-s); - a += b; - a, b, c, d = d, a, b, c; + x := (1 + 5*i) % 16 + t := 16 + i + s := shift2[i%4] + g := ((b ^ c) & d) ^ c + a += g + X[x] + table[t] + a = a<<s | a>>(32-s) + a += b + a, b, c, d = d, a, b, c } // Round 3. for i := 0; i < 16; i++ { - x := (5 + 3*i) % 16; - t := 32 + i; - s := shift3[i%4]; - h := b ^ c ^ d; - a += h + X[x] + table[t]; - a = a<<s | a>>(32-s); - a += b; - a, b, c, d = d, a, b, c; + x := (5 + 3*i) % 16 + t := 32 + i + s := shift3[i%4] + h := b ^ c ^ d + a += h + X[x] + table[t] + a = a<<s | a>>(32-s) + a += b + a, b, c, d = d, a, b, c } // Round 4. for i := 0; i < 16; i++ { - x := (7 * i) % 16; - s := shift4[i%4]; - t := 48 + i; - ii := c ^ (b | ^d); - a += ii + X[x] + table[t]; - a = a<<s | a>>(32-s); - a += b; - a, b, c, d = d, a, b, c; + x := (7 * i) % 16 + s := shift4[i%4] + t := 48 + i + ii := c ^ (b | ^d) + a += ii + X[x] + table[t] + a = a<<s | a>>(32-s) + a += b + a, b, c, d = d, a, b, c } - a += aa; - b += bb; - c += cc; - d += dd; + a += aa + b += bb + c += cc + d += dd - p = p[_Chunk:]; - n += _Chunk; + p = p[_Chunk:] + n += _Chunk } - dig.s[0] = a; - dig.s[1] = b; - dig.s[2] = c; - dig.s[3] = d; - return n; + dig.s[0] = a + dig.s[1] = b + dig.s[2] = c + dig.s[3] = d + return n } diff --git a/src/pkg/crypto/rc4/rc4.go b/src/pkg/crypto/rc4/rc4.go index d965f827b..e47a01513 100644 --- a/src/pkg/crypto/rc4/rc4.go +++ b/src/pkg/crypto/rc4/rc4.go @@ -10,14 +10,14 @@ package rc4 // it a poor choice for new protocols. import ( - "os"; - "strconv"; + "os" + "strconv" ) // A Cipher is an instance of RC4 using a particular key. type Cipher struct { - s [256]byte; - i, j uint8; + s [256]byte + i, j uint8 } type KeySizeError int @@ -29,30 +29,30 @@ func (k KeySizeError) String() string { // NewCipher creates and returns a new Cipher. The key argument should be the // RC4 key, at least 1 byte and at most 256 bytes. func NewCipher(key []byte) (*Cipher, os.Error) { - k := len(key); + k := len(key) if k < 1 || k > 256 { return nil, KeySizeError(k) } - var c Cipher; + var c Cipher for i := 0; i < 256; i++ { c.s[i] = uint8(i) } - var j uint8 = 0; + var j uint8 = 0 for i := 0; i < 256; i++ { - j += c.s[i] + key[i%k]; - c.s[i], c.s[j] = c.s[j], c.s[i]; + j += c.s[i] + key[i%k] + c.s[i], c.s[j] = c.s[j], c.s[i] } - return &c, nil; + return &c, nil } // XORKeyStream will XOR each byte of the given buffer with a byte of the // generated keystream. func (c *Cipher) XORKeyStream(buf []byte) { for i := range buf { - c.i += 1; - c.j += c.s[c.i]; - c.s[c.i], c.s[c.j] = c.s[c.j], c.s[c.i]; - buf[i] ^= c.s[c.s[c.i]+c.s[c.j]]; + c.i += 1 + c.j += c.s[c.i] + c.s[c.i], c.s[c.j] = c.s[c.j], c.s[c.i] + buf[i] ^= c.s[c.s[c.i]+c.s[c.j]] } } @@ -62,5 +62,5 @@ func (c *Cipher) Reset() { for i := range c.s { c.s[i] = 0 } - c.i, c.j = 0, 0; + c.i, c.j = 0, 0 } diff --git a/src/pkg/crypto/rc4/rc4_test.go b/src/pkg/crypto/rc4/rc4_test.go index e0ca4a4ae..1d39b2f17 100644 --- a/src/pkg/crypto/rc4/rc4_test.go +++ b/src/pkg/crypto/rc4/rc4_test.go @@ -5,11 +5,11 @@ package rc4 import ( - "testing"; + "testing" ) type rc4Test struct { - key, keystream []byte; + key, keystream []byte } var golden = []rc4Test{ @@ -41,18 +41,18 @@ var golden = []rc4Test{ func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { - g := golden[i]; - c, err := NewCipher(g.key); + g := golden[i] + c, err := NewCipher(g.key) if err != nil { - t.Errorf("Failed to create cipher at golden index %d", i); - return; + t.Errorf("Failed to create cipher at golden index %d", i) + return } - keystream := make([]byte, len(g.keystream)); - c.XORKeyStream(keystream); + keystream := make([]byte, len(g.keystream)) + c.XORKeyStream(keystream) for j, v := range keystream { if g.keystream[j] != v { - t.Errorf("Failed at golden index %d", i); - break; + t.Errorf("Failed at golden index %d", i) + break } } } diff --git a/src/pkg/crypto/rsa/pkcs1v15.go b/src/pkg/crypto/rsa/pkcs1v15.go index 9dbc20f29..cfad95454 100644 --- a/src/pkg/crypto/rsa/pkcs1v15.go +++ b/src/pkg/crypto/rsa/pkcs1v15.go @@ -5,10 +5,10 @@ package rsa import ( - "big"; - "crypto/subtle"; - "io"; - "os"; + "big" + "crypto/subtle" + "io" + "os" ) // This file implements encryption and decryption using PKCS#1 v1.5 padding. @@ -18,38 +18,38 @@ import ( // WARNING: use of this function to encrypt plaintexts other than session keys // is dangerous. Use RSA OAEP in new protocols. func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err os.Error) { - k := (pub.N.Len() + 7) / 8; + k := (pub.N.Len() + 7) / 8 if len(msg) > k-11 { - err = MessageTooLongError{}; - return; + err = MessageTooLongError{} + return } // EM = 0x02 || PS || 0x00 || M - em := make([]byte, k-1); - em[0] = 2; - ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):]; - err = nonZeroRandomBytes(ps, rand); + em := make([]byte, k-1) + em[0] = 2 + ps, mm := em[1:len(em)-len(msg)-1], em[len(em)-len(msg):] + err = nonZeroRandomBytes(ps, rand) if err != nil { return } - em[len(em)-len(msg)-1] = 0; - copy(mm, msg); + em[len(em)-len(msg)-1] = 0 + copy(mm, msg) - m := new(big.Int).SetBytes(em); - c := encrypt(new(big.Int), pub, m); - out = c.Bytes(); - return; + m := new(big.Int).SetBytes(em) + c := encrypt(new(big.Int), pub, m) + out = c.Bytes() + return } // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS#1 v1.5. // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks. func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err os.Error) { - valid, out, err := decryptPKCS1v15(rand, priv, ciphertext); + valid, out, err := decryptPKCS1v15(rand, priv, ciphertext) if err == nil && valid == 0 { err = DecryptionError{} } - return; + return } // DecryptPKCS1v15SessionKey decrypts a session key using RSA and the padding scheme from PKCS#1 v1.5. @@ -66,74 +66,74 @@ func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out [ // Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology // (Crypto '98), func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err os.Error) { - k := (priv.N.Len() + 7) / 8; + k := (priv.N.Len() + 7) / 8 if k-(len(key)+3+8) < 0 { - err = DecryptionError{}; - return; + err = DecryptionError{} + return } - valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext); + valid, msg, err := decryptPKCS1v15(rand, priv, ciphertext) if err != nil { return } - valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key))); - subtle.ConstantTimeCopy(valid, key, msg); - return; + valid &= subtle.ConstantTimeEq(int32(len(msg)), int32(len(key))) + subtle.ConstantTimeCopy(valid, key, msg) + return } func decryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (valid int, msg []byte, err os.Error) { - k := (priv.N.Len() + 7) / 8; + k := (priv.N.Len() + 7) / 8 if k < 11 { - err = DecryptionError{}; - return; + err = DecryptionError{} + return } - c := new(big.Int).SetBytes(ciphertext); - m, err := decrypt(rand, priv, c); + c := new(big.Int).SetBytes(ciphertext) + m, err := decrypt(rand, priv, c) if err != nil { return } - em := leftPad(m.Bytes(), k); - firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0); - secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2); + em := leftPad(m.Bytes(), k) + firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0) + secondByteIsTwo := subtle.ConstantTimeByteEq(em[1], 2) // The remainder of the plaintext must be a string of non-zero random // octets, followed by a 0, followed by the message. // lookingForIndex: 1 iff we are still looking for the zero. // index: the offset of the first zero byte. - var lookingForIndex, index int; - lookingForIndex = 1; + var lookingForIndex, index int + lookingForIndex = 1 for i := 2; i < len(em); i++ { - equals0 := subtle.ConstantTimeByteEq(em[i], 0); - index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index); - lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex); + equals0 := subtle.ConstantTimeByteEq(em[i], 0) + index = subtle.ConstantTimeSelect(lookingForIndex&equals0, i, index) + lookingForIndex = subtle.ConstantTimeSelect(equals0, 0, lookingForIndex) } - valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1); - msg = em[index+1:]; - return; + valid = firstByteIsZero & secondByteIsTwo & (^lookingForIndex & 1) + msg = em[index+1:] + return } // nonZeroRandomBytes fills the given slice with non-zero random octets. func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) { - _, err = io.ReadFull(rand, s); + _, err = io.ReadFull(rand, s) if err != nil { return } for i := 0; i < len(s); i++ { for s[i] == 0 { - _, err = rand.Read(s[i : i+1]); + _, err = rand.Read(s[i : i+1]) if err != nil { return } } } - return; + return } // Due to the design of PKCS#1 v1.5, we need to know the exact hash function in @@ -141,11 +141,11 @@ func nonZeroRandomBytes(s []byte, rand io.Reader) (err os.Error) { type PKCS1v15Hash int const ( - HashMD5 PKCS1v15Hash = iota; - HashSHA1; - HashSHA256; - HashSHA384; - HashSHA512; + HashMD5 PKCS1v15Hash = iota + HashSHA1 + HashSHA256 + HashSHA384 + HashSHA512 ) // These are ASN1 DER structures: @@ -173,32 +173,32 @@ var hashPrefixes = [][]byte{ // Note that hashed must be the result of hashing the input message using the // given hash function. func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash PKCS1v15Hash, hashed []byte) (s []byte, err os.Error) { - hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)); + hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)) if err != nil { return } - tLen := len(prefix) + hashLen; - k := (priv.N.Len() + 7) / 8; + tLen := len(prefix) + hashLen + k := (priv.N.Len() + 7) / 8 if k < tLen+11 { return nil, MessageTooLongError{} } // EM = 0x00 || 0x01 || PS || 0x00 || T - em := make([]byte, k); - em[1] = 1; + em := make([]byte, k) + em[1] = 1 for i := 2; i < k-tLen-1; i++ { em[i] = 0xff } - copy(em[k-tLen:k-hashLen], prefix); - copy(em[k-hashLen:k], hashed); + copy(em[k-tLen:k-hashLen], prefix) + copy(em[k-hashLen:k], hashed) - m := new(big.Int).SetBytes(em); - c, err := decrypt(rand, priv, m); + m := new(big.Int).SetBytes(em) + c, err := decrypt(rand, priv, m) if err == nil { s = c.Bytes() } - return; + return } // VerifyPKCS1v15 verifies an RSA PKCS#1 v1.5 signature. @@ -206,28 +206,28 @@ func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash PKCS1v15Hash, hashed [] // function and sig is the signature. A valid signature is indicated by // returning a nil error. func VerifyPKCS1v15(pub *PublicKey, hash PKCS1v15Hash, hashed []byte, sig []byte) (err os.Error) { - hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)); + hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed)) if err != nil { return } - tLen := len(prefix) + hashLen; - k := (pub.N.Len() + 7) / 8; + tLen := len(prefix) + hashLen + k := (pub.N.Len() + 7) / 8 if k < tLen+11 { - err = VerificationError{}; - return; + err = VerificationError{} + return } - c := new(big.Int).SetBytes(sig); - m := encrypt(new(big.Int), pub, c); - em := leftPad(m.Bytes(), k); + c := new(big.Int).SetBytes(sig) + m := encrypt(new(big.Int), pub, c) + em := leftPad(m.Bytes(), k) // EM = 0x00 || 0x01 || PS || 0x00 || T - ok := subtle.ConstantTimeByteEq(em[0], 0); - ok &= subtle.ConstantTimeByteEq(em[1], 1); - ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed); - ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix); - ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0); + ok := subtle.ConstantTimeByteEq(em[0], 0) + ok &= subtle.ConstantTimeByteEq(em[1], 1) + ok &= subtle.ConstantTimeCompare(em[k-hashLen:k], hashed) + ok &= subtle.ConstantTimeCompare(em[k-tLen:k-hashLen], prefix) + ok &= subtle.ConstantTimeByteEq(em[k-tLen-1], 0) for i := 2; i < k-tLen-1; i++ { ok &= subtle.ConstantTimeByteEq(em[i], 0xff) @@ -237,7 +237,7 @@ func VerifyPKCS1v15(pub *PublicKey, hash PKCS1v15Hash, hashed []byte, sig []byte return VerificationError{} } - return nil; + return nil } func pkcs1v15HashInfo(hash PKCS1v15Hash, inLen int) (hashLen int, prefix []byte, err os.Error) { @@ -260,6 +260,6 @@ func pkcs1v15HashInfo(hash PKCS1v15Hash, inLen int) (hashLen int, prefix []byte, return 0, nil, os.ErrorString("input must be hashed message") } - prefix = hashPrefixes[int(hash)]; - return; + prefix = hashPrefixes[int(hash)] + return } diff --git a/src/pkg/crypto/rsa/pkcs1v15_test.go b/src/pkg/crypto/rsa/pkcs1v15_test.go index 4d62deac1..6bdd64876 100644 --- a/src/pkg/crypto/rsa/pkcs1v15_test.go +++ b/src/pkg/crypto/rsa/pkcs1v15_test.go @@ -5,29 +5,29 @@ package rsa import ( - "big"; - "bytes"; - "crypto/sha1"; - "encoding/base64"; - "encoding/hex"; - "os"; - "io"; - "strings"; - "testing"; - "testing/quick"; + "big" + "bytes" + "crypto/sha1" + "encoding/base64" + "encoding/hex" + "os" + "io" + "strings" + "testing" + "testing/quick" ) func decodeBase64(in string) []byte { - out := make([]byte, base64.StdEncoding.DecodedLen(len(in))); - n, err := base64.StdEncoding.Decode(out, strings.Bytes(in)); + out := make([]byte, base64.StdEncoding.DecodedLen(len(in))) + n, err := base64.StdEncoding.Decode(out, strings.Bytes(in)) if err != nil { return nil } - return out[0:n]; + return out[0:n] } type DecryptPKCS1v15Test struct { - in, out string; + in, out string } // These test vectors were generated with `openssl rsautl -pkcs -encrypt` @@ -52,11 +52,11 @@ var decryptPKCS1v15Tests = []DecryptPKCS1v15Test{ func TestDecryptPKCS1v15(t *testing.T) { for i, test := range decryptPKCS1v15Tests { - out, err := DecryptPKCS1v15(nil, rsaPrivateKey, decodeBase64(test.in)); + out, err := DecryptPKCS1v15(nil, rsaPrivateKey, decodeBase64(test.in)) if err != nil { t.Errorf("#%d error decrypting", i) } - want := strings.Bytes(test.out); + want := strings.Bytes(test.out) if bytes.Compare(out, want) != 0 { t.Errorf("#%d got:%#v want:%#v", i, out, want) } @@ -64,43 +64,43 @@ func TestDecryptPKCS1v15(t *testing.T) { } func TestEncryptPKCS1v15(t *testing.T) { - urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0); + urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0) if err != nil { t.Errorf("Failed to open /dev/urandom") } - k := (rsaPrivateKey.N.Len() + 7) / 8; + k := (rsaPrivateKey.N.Len() + 7) / 8 tryEncryptDecrypt := func(in []byte, blind bool) bool { if len(in) > k-11 { in = in[0 : k-11] } - ciphertext, err := EncryptPKCS1v15(urandom, &rsaPrivateKey.PublicKey, in); + ciphertext, err := EncryptPKCS1v15(urandom, &rsaPrivateKey.PublicKey, in) if err != nil { - t.Errorf("error encrypting: %s", err); - return false; + t.Errorf("error encrypting: %s", err) + return false } - var rand io.Reader; + var rand io.Reader if !blind { rand = nil } else { rand = urandom } - plaintext, err := DecryptPKCS1v15(rand, rsaPrivateKey, ciphertext); + plaintext, err := DecryptPKCS1v15(rand, rsaPrivateKey, ciphertext) if err != nil { - t.Errorf("error decrypting: %s", err); - return false; + t.Errorf("error decrypting: %s", err) + return false } if bytes.Compare(plaintext, in) != 0 { - t.Errorf("output mismatch: %#v %#v", plaintext, in); - return false; + t.Errorf("output mismatch: %#v %#v", plaintext, in) + return false } - return true; - }; + return true + } - quick.Check(tryEncryptDecrypt, nil); + quick.Check(tryEncryptDecrypt, nil) } // These test vectors were generated with `openssl rsautl -pkcs -encrypt` @@ -125,12 +125,12 @@ var decryptPKCS1v15SessionKeyTests = []DecryptPKCS1v15Test{ func TestEncryptPKCS1v15SessionKey(t *testing.T) { for i, test := range decryptPKCS1v15SessionKeyTests { - key := strings.Bytes("FAIL"); - err := DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, decodeBase64(test.in), key); + key := strings.Bytes("FAIL") + err := DecryptPKCS1v15SessionKey(nil, rsaPrivateKey, decodeBase64(test.in), key) if err != nil { t.Errorf("#%d error decrypting", i) } - want := strings.Bytes(test.out); + want := strings.Bytes(test.out) if bytes.Compare(key, want) != 0 { t.Errorf("#%d got:%#v want:%#v", i, key, want) } @@ -138,26 +138,26 @@ func TestEncryptPKCS1v15SessionKey(t *testing.T) { } func TestNonZeroRandomBytes(t *testing.T) { - urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0); + urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0) if err != nil { t.Errorf("Failed to open /dev/urandom") } - b := make([]byte, 512); - err = nonZeroRandomBytes(b, urandom); + b := make([]byte, 512) + err = nonZeroRandomBytes(b, urandom) if err != nil { t.Errorf("returned error: %s", err) } for _, b := range b { if b == 0 { - t.Errorf("Zero octet found"); - return; + t.Errorf("Zero octet found") + return } } } type signPKCS1v15Test struct { - in, out string; + in, out string } // These vectors have been tested with @@ -168,16 +168,16 @@ var signPKCS1v15Tests = []signPKCS1v15Test{ func TestSignPKCS1v15(t *testing.T) { for i, test := range signPKCS1v15Tests { - h := sha1.New(); - h.Write(strings.Bytes(test.in)); - digest := h.Sum(); + h := sha1.New() + h.Write(strings.Bytes(test.in)) + digest := h.Sum() - s, err := SignPKCS1v15(nil, rsaPrivateKey, HashSHA1, digest); + s, err := SignPKCS1v15(nil, rsaPrivateKey, HashSHA1, digest) if err != nil { t.Errorf("#%d %s", i, err) } - expected, _ := hex.DecodeString(test.out); + expected, _ := hex.DecodeString(test.out) if bytes.Compare(s, expected) != 0 { t.Errorf("#%d got: %x want: %x", i, s, expected) } @@ -186,13 +186,13 @@ func TestSignPKCS1v15(t *testing.T) { func TestVerifyPKCS1v15(t *testing.T) { for i, test := range signPKCS1v15Tests { - h := sha1.New(); - h.Write(strings.Bytes(test.in)); - digest := h.Sum(); + h := sha1.New() + h.Write(strings.Bytes(test.in)) + digest := h.Sum() - sig, _ := hex.DecodeString(test.out); + sig, _ := hex.DecodeString(test.out) - err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, HashSHA1, digest, sig); + err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, HashSHA1, digest, sig) if err != nil { t.Errorf("#%d %s", i, err) } @@ -200,9 +200,9 @@ func TestVerifyPKCS1v15(t *testing.T) { } func bigFromString(s string) *big.Int { - ret := new(big.Int); - ret.SetString(s, 10); - return ret; + ret := new(big.Int) + ret.SetString(s, 10) + return ret } // In order to generate new test vectors you'll need the PEM form of this key: diff --git a/src/pkg/crypto/rsa/rsa.go b/src/pkg/crypto/rsa/rsa.go index e47b02060..a4a3cfd38 100644 --- a/src/pkg/crypto/rsa/rsa.go +++ b/src/pkg/crypto/rsa/rsa.go @@ -8,11 +8,11 @@ package rsa // TODO(agl): Add support for PSS padding. import ( - "big"; - "crypto/subtle"; - "hash"; - "io"; - "os"; + "big" + "crypto/subtle" + "hash" + "io" + "os" ) var bigZero = big.NewInt(0) @@ -25,77 +25,77 @@ func randomSafePrime(rand io.Reader, bits int) (p *big.Int, err os.Error) { err = os.EINVAL } - bytes := make([]byte, (bits+7)/8); - p = new(big.Int); - p2 := new(big.Int); + bytes := make([]byte, (bits+7)/8) + p = new(big.Int) + p2 := new(big.Int) for { - _, err = io.ReadFull(rand, bytes); + _, err = io.ReadFull(rand, bytes) if err != nil { return } // Don't let the value be too small. - bytes[0] |= 0x80; + bytes[0] |= 0x80 // Make the value odd since an even number this large certainly isn't prime. - bytes[len(bytes)-1] |= 1; + bytes[len(bytes)-1] |= 1 - p.SetBytes(bytes); + p.SetBytes(bytes) if big.ProbablyPrime(p, 20) { - p2.Rsh(p, 1); // p2 = (p - 1)/2 + p2.Rsh(p, 1) // p2 = (p - 1)/2 if big.ProbablyPrime(p2, 20) { return } } } - return; + return } // randomNumber returns a uniform random value in [0, max). func randomNumber(rand io.Reader, max *big.Int) (n *big.Int, err os.Error) { - k := (max.Len() + 7) / 8; + k := (max.Len() + 7) / 8 // r is the number of bits in the used in the most significant byte of // max. - r := uint(max.Len() % 8); + r := uint(max.Len() % 8) if r == 0 { r = 8 } - bytes := make([]byte, k); - n = new(big.Int); + bytes := make([]byte, k) + n = new(big.Int) for { - _, err = io.ReadFull(rand, bytes); + _, err = io.ReadFull(rand, bytes) if err != nil { return } // Clear bits in the first byte to increase the probability // that the candidate is < max. - bytes[0] &= uint8(int(1<<r) - 1); + bytes[0] &= uint8(int(1<<r) - 1) - n.SetBytes(bytes); + n.SetBytes(bytes) if n.Cmp(max) < 0 { return } } - return; + return } // A PublicKey represents the public part of an RSA key. type PublicKey struct { - N *big.Int; // modulus - E int; // public exponent + N *big.Int // modulus + E int // public exponent } // A PrivateKey represents an RSA key type PrivateKey struct { - PublicKey; // public part. - D *big.Int; // private exponent - P, Q *big.Int; // prime factors of N + PublicKey // public part. + D *big.Int // private exponent + P, Q *big.Int // prime factors of N } // Validate performs basic sanity checks on the key. @@ -114,34 +114,34 @@ func (priv PrivateKey) Validate() os.Error { } // Check that p*q == n. - modulus := new(big.Int).Mul(priv.P, priv.Q); + modulus := new(big.Int).Mul(priv.P, priv.Q) if modulus.Cmp(priv.N) != 0 { return os.ErrorString("invalid modulus") } // Check that e and totient(p, q) are coprime. - pminus1 := new(big.Int).Sub(priv.P, bigOne); - qminus1 := new(big.Int).Sub(priv.Q, bigOne); - totient := new(big.Int).Mul(pminus1, qminus1); - e := big.NewInt(int64(priv.E)); - gcd := new(big.Int); - x := new(big.Int); - y := new(big.Int); - big.GcdInt(gcd, x, y, totient, e); + pminus1 := new(big.Int).Sub(priv.P, bigOne) + qminus1 := new(big.Int).Sub(priv.Q, bigOne) + totient := new(big.Int).Mul(pminus1, qminus1) + e := big.NewInt(int64(priv.E)) + gcd := new(big.Int) + x := new(big.Int) + y := new(big.Int) + big.GcdInt(gcd, x, y, totient, e) if gcd.Cmp(bigOne) != 0 { return os.ErrorString("invalid public exponent E") } // Check that de ≡ 1 (mod totient(p, q)) - de := new(big.Int).Mul(priv.D, e); - de.Mod(de, totient); + de := new(big.Int).Mul(priv.D, e) + de.Mod(de, totient) if de.Cmp(bigOne) != 0 { return os.ErrorString("invalid private exponent D") } - return nil; + return nil } // GenerateKeyPair generates an RSA keypair of the given bit size. func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) { - priv = new(PrivateKey); + priv = new(PrivateKey) // Smaller public exponents lead to faster public key // operations. Since the exponent must be coprime to // (p-1)(q-1), the smallest possible value is 3. Some have @@ -150,19 +150,19 @@ func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) { // was the case. However, there are no current reasons not to use // small exponents. // [1] http://marc.info/?l=cryptography&m=115694833312008&w=2 - priv.E = 3; + priv.E = 3 - pminus1 := new(big.Int); - qminus1 := new(big.Int); - totient := new(big.Int); + pminus1 := new(big.Int) + qminus1 := new(big.Int) + totient := new(big.Int) for { - p, err := randomSafePrime(rand, bits/2); + p, err := randomSafePrime(rand, bits/2) if err != nil { return nil, err } - q, err := randomSafePrime(rand, bits/2); + q, err := randomSafePrime(rand, bits/2) if err != nil { return nil, err } @@ -171,28 +171,28 @@ func GenerateKey(rand io.Reader, bits int) (priv *PrivateKey, err os.Error) { continue } - n := new(big.Int).Mul(p, q); - pminus1.Sub(p, bigOne); - qminus1.Sub(q, bigOne); - totient.Mul(pminus1, qminus1); + n := new(big.Int).Mul(p, q) + pminus1.Sub(p, bigOne) + qminus1.Sub(q, bigOne) + totient.Mul(pminus1, qminus1) - g := new(big.Int); - priv.D = new(big.Int); - y := new(big.Int); - e := big.NewInt(int64(priv.E)); - big.GcdInt(g, priv.D, y, e, totient); + g := new(big.Int) + priv.D = new(big.Int) + y := new(big.Int) + e := big.NewInt(int64(priv.E)) + big.GcdInt(g, priv.D, y, e, totient) if g.Cmp(bigOne) == 0 { - priv.D.Add(priv.D, totient); - priv.P = p; - priv.Q = q; - priv.N = n; + priv.D.Add(priv.D, totient) + priv.P = p + priv.Q = q + priv.N = n - break; + break } } - return; + return } // incCounter increments a four byte, big-endian counter. @@ -206,26 +206,26 @@ func incCounter(c *[4]byte) { if c[1]++; c[1] != 0 { return } - c[0]++; + c[0]++ } // mgf1XOR XORs the bytes in out with a mask generated using the MGF1 function // specified in PKCS#1 v2.1. func mgf1XOR(out []byte, hash hash.Hash, seed []byte) { - var counter [4]byte; + var counter [4]byte - done := 0; + done := 0 for done < len(out) { - hash.Write(seed); - hash.Write(counter[0:4]); - digest := hash.Sum(); - hash.Reset(); + hash.Write(seed) + hash.Write(counter[0:4]) + digest := hash.Sum() + hash.Reset() for i := 0; i < len(digest) && done < len(out); i++ { - out[done] ^= digest[i]; - done++; + out[done] ^= digest[i] + done++ } - incCounter(&counter); + incCounter(&counter) } } @@ -238,68 +238,68 @@ func (MessageTooLongError) String() string { } func encrypt(c *big.Int, pub *PublicKey, m *big.Int) *big.Int { - e := big.NewInt(int64(pub.E)); - c.Exp(m, e, pub.N); - return c; + e := big.NewInt(int64(pub.E)) + c.Exp(m, e, pub.N) + return c } // EncryptOAEP encrypts the given message with RSA-OAEP. // The message must be no longer than the length of the public modulus less // twice the hash length plus 2. func EncryptOAEP(hash hash.Hash, rand io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err os.Error) { - hash.Reset(); - k := (pub.N.Len() + 7) / 8; + hash.Reset() + k := (pub.N.Len() + 7) / 8 if len(msg) > k-2*hash.Size()-2 { - err = MessageTooLongError{}; - return; + err = MessageTooLongError{} + return } - hash.Write(label); - lHash := hash.Sum(); - hash.Reset(); + hash.Write(label) + lHash := hash.Sum() + hash.Reset() - em := make([]byte, k); - seed := em[1 : 1+hash.Size()]; - db := em[1+hash.Size():]; + em := make([]byte, k) + seed := em[1 : 1+hash.Size()] + db := em[1+hash.Size():] - copy(db[0:hash.Size()], lHash); - db[len(db)-len(msg)-1] = 1; - copy(db[len(db)-len(msg):], msg); + copy(db[0:hash.Size()], lHash) + db[len(db)-len(msg)-1] = 1 + copy(db[len(db)-len(msg):], msg) - _, err = io.ReadFull(rand, seed); + _, err = io.ReadFull(rand, seed) if err != nil { return } - mgf1XOR(db, hash, seed); - mgf1XOR(seed, hash, db); + mgf1XOR(db, hash, seed) + mgf1XOR(seed, hash, db) - m := new(big.Int); - m.SetBytes(em); - c := encrypt(new(big.Int), pub, m); - out = c.Bytes(); - return; + m := new(big.Int) + m.SetBytes(em) + c := encrypt(new(big.Int), pub, m) + out = c.Bytes() + return } // A DecryptionError represents a failure to decrypt a message. // It is deliberately vague to avoid adaptive attacks. type DecryptionError struct{} -func (DecryptionError) String() string { return "RSA decryption error" } +func (DecryptionError) String() string { return "RSA decryption error" } // A VerificationError represents a failure to verify a signature. // It is deliberately vague to avoid adaptive attacks. type VerificationError struct{} -func (VerificationError) String() string { return "RSA verification error" } +func (VerificationError) String() string { return "RSA verification error" } // modInverse returns ia, the inverse of a in the multiplicative group of prime // order n. It requires that a be a member of the group (i.e. less than n). func modInverse(a, n *big.Int) (ia *big.Int, ok bool) { - g := new(big.Int); - x := new(big.Int); - y := new(big.Int); - big.GcdInt(g, x, y, a, n); + g := new(big.Int) + x := new(big.Int) + y := new(big.Int) + big.GcdInt(g, x, y, a, n) if g.Cmp(bigOne) != 0 { // In this case, a and n aren't coprime and we cannot calculate // the inverse. This happens because the values of n are nearly @@ -314,7 +314,7 @@ func modInverse(a, n *big.Int) (ia *big.Int, ok bool) { x.Add(x, n) } - return x, true; + return x, true } // decrypt performs an RSA decryption, resulting in a plaintext integer. If a @@ -322,128 +322,128 @@ func modInverse(a, n *big.Int) (ia *big.Int, ok bool) { func decrypt(rand io.Reader, priv *PrivateKey, c *big.Int) (m *big.Int, err os.Error) { // TODO(agl): can we get away with reusing blinds? if c.Cmp(priv.N) > 0 { - err = DecryptionError{}; - return; + err = DecryptionError{} + return } - var ir *big.Int; + var ir *big.Int if rand != nil { // Blinding enabled. Blinding involves multiplying c by r^e. // Then the decryption operation performs (m^e * r^e)^d mod n // which equals mr mod n. The factor of r can then be removed // by multipling by the multiplicative inverse of r. - var r *big.Int; + var r *big.Int for { - r, err = randomNumber(rand, priv.N); + r, err = randomNumber(rand, priv.N) if err != nil { return } if r.Cmp(bigZero) == 0 { r = bigOne } - var ok bool; - ir, ok = modInverse(r, priv.N); + var ok bool + ir, ok = modInverse(r, priv.N) if ok { break } } - bigE := big.NewInt(int64(priv.E)); - rpowe := new(big.Int).Exp(r, bigE, priv.N); - c.Mul(c, rpowe); - c.Mod(c, priv.N); + bigE := big.NewInt(int64(priv.E)) + rpowe := new(big.Int).Exp(r, bigE, priv.N) + c.Mul(c, rpowe) + c.Mod(c, priv.N) } - m = new(big.Int).Exp(c, priv.D, priv.N); + m = new(big.Int).Exp(c, priv.D, priv.N) if ir != nil { // Unblind. - m.Mul(m, ir); - m.Mod(m, priv.N); + m.Mul(m, ir) + m.Mod(m, priv.N) } - return; + return } // DecryptOAEP decrypts ciphertext using RSA-OAEP. // If rand != nil, DecryptOAEP uses RSA blinding to avoid timing side-channel attacks. func DecryptOAEP(hash hash.Hash, rand io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err os.Error) { - k := (priv.N.Len() + 7) / 8; + k := (priv.N.Len() + 7) / 8 if len(ciphertext) > k || k < hash.Size()*2+2 { - err = DecryptionError{}; - return; + err = DecryptionError{} + return } - c := new(big.Int).SetBytes(ciphertext); + c := new(big.Int).SetBytes(ciphertext) - m, err := decrypt(rand, priv, c); + m, err := decrypt(rand, priv, c) if err != nil { return } - hash.Write(label); - lHash := hash.Sum(); - hash.Reset(); + hash.Write(label) + lHash := hash.Sum() + hash.Reset() // Converting the plaintext number to bytes will strip any // leading zeros so we may have to left pad. We do this unconditionally // to avoid leaking timing information. (Although we still probably // leak the number of leading zeros. It's not clear that we can do // anything about this.) - em := leftPad(m.Bytes(), k); + em := leftPad(m.Bytes(), k) - firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0); + firstByteIsZero := subtle.ConstantTimeByteEq(em[0], 0) - seed := em[1 : hash.Size()+1]; - db := em[hash.Size()+1:]; + seed := em[1 : hash.Size()+1] + db := em[hash.Size()+1:] - mgf1XOR(seed, hash, db); - mgf1XOR(db, hash, seed); + mgf1XOR(seed, hash, db) + mgf1XOR(db, hash, seed) - lHash2 := db[0:hash.Size()]; + lHash2 := db[0:hash.Size()] // We have to validate the plaintext in contanst time in order to avoid // attacks like: J. Manger. A Chosen Ciphertext Attack on RSA Optimal // Asymmetric Encryption Padding (OAEP) as Standardized in PKCS #1 // v2.0. In J. Kilian, editor, Advances in Cryptology. - lHash2Good := subtle.ConstantTimeCompare(lHash, lHash2); + lHash2Good := subtle.ConstantTimeCompare(lHash, lHash2) // The remainder of the plaintext must be zero or more 0x00, followed // by 0x01, followed by the message. // lookingForIndex: 1 iff we are still looking for the 0x01 // index: the offset of the first 0x01 byte // invalid: 1 iff we saw a non-zero byte before the 0x01. - var lookingForIndex, index, invalid int; - lookingForIndex = 1; - rest := db[hash.Size():]; + var lookingForIndex, index, invalid int + lookingForIndex = 1 + rest := db[hash.Size():] for i := 0; i < len(rest); i++ { - equals0 := subtle.ConstantTimeByteEq(rest[i], 0); - equals1 := subtle.ConstantTimeByteEq(rest[i], 1); - index = subtle.ConstantTimeSelect(lookingForIndex&equals1, i, index); - lookingForIndex = subtle.ConstantTimeSelect(equals1, 0, lookingForIndex); - invalid = subtle.ConstantTimeSelect(lookingForIndex&^equals0, 1, invalid); + equals0 := subtle.ConstantTimeByteEq(rest[i], 0) + equals1 := subtle.ConstantTimeByteEq(rest[i], 1) + index = subtle.ConstantTimeSelect(lookingForIndex&equals1, i, index) + lookingForIndex = subtle.ConstantTimeSelect(equals1, 0, lookingForIndex) + invalid = subtle.ConstantTimeSelect(lookingForIndex&^equals0, 1, invalid) } if firstByteIsZero&lHash2Good&^invalid&^lookingForIndex != 1 { - err = DecryptionError{}; - return; + err = DecryptionError{} + return } - msg = rest[index+1:]; - return; + msg = rest[index+1:] + return } // leftPad returns a new slice of length size. The contents of input are right // aligned in the new slice. func leftPad(input []byte, size int) (out []byte) { - n := len(input); + n := len(input) if n > size { n = size } - out = make([]byte, size); - copy(out[len(out)-n:], input); - return; + out = make([]byte, size) + copy(out[len(out)-n:], input) + return } diff --git a/src/pkg/crypto/rsa/rsa_test.go b/src/pkg/crypto/rsa/rsa_test.go index cc15b8674..21acf6ed6 100644 --- a/src/pkg/crypto/rsa/rsa_test.go +++ b/src/pkg/crypto/rsa/rsa_test.go @@ -5,27 +5,27 @@ package rsa import ( - "big"; - "bytes"; - "crypto/sha1"; - "os"; - "testing"; + "big" + "bytes" + "crypto/sha1" + "os" + "testing" ) func TestKeyGeneration(t *testing.T) { - urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0); + urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0) if err != nil { t.Errorf("failed to open /dev/urandom") } - priv, err := GenerateKey(urandom, 32); + priv, err := GenerateKey(urandom, 32) if err != nil { t.Errorf("failed to generate key") } - pub := &priv.PublicKey; - m := big.NewInt(42); - c := encrypt(new(big.Int), pub, m); - m2, err := decrypt(nil, priv, c); + pub := &priv.PublicKey + m := big.NewInt(42) + c := encrypt(new(big.Int), pub, m) + m2, err := decrypt(nil, priv, c) if err != nil { t.Errorf("error while decrypting: %s", err) } @@ -33,7 +33,7 @@ func TestKeyGeneration(t *testing.T) { t.Errorf("got:%v, want:%v (%s)", m2, m, priv) } - m3, err := decrypt(urandom, priv, c); + m3, err := decrypt(urandom, priv, c) if err != nil { t.Errorf("error while decrypting (blind): %s", err) } @@ -43,28 +43,28 @@ func TestKeyGeneration(t *testing.T) { } type testEncryptOAEPMessage struct { - in []byte; - seed []byte; - out []byte; + in []byte + seed []byte + out []byte } type testEncryptOAEPStruct struct { - modulus string; - e int; - d string; - msgs []testEncryptOAEPMessage; + modulus string + e int + d string + msgs []testEncryptOAEPMessage } func TestEncryptOAEP(t *testing.T) { - sha1 := sha1.New(); - n := new(big.Int); + sha1 := sha1.New() + n := new(big.Int) for i, test := range testEncryptOAEPData { - n.SetString(test.modulus, 16); - public := PublicKey{n, test.e}; + n.SetString(test.modulus, 16) + public := PublicKey{n, test.e} for j, message := range test.msgs { - randomSource := bytes.NewBuffer(message.seed); - out, err := EncryptOAEP(sha1, randomSource, &public, message.in, nil); + randomSource := bytes.NewBuffer(message.seed) + out, err := EncryptOAEP(sha1, randomSource, &public, message.in, nil) if err != nil { t.Errorf("#%d,%d error: %s", i, j, err) } @@ -76,21 +76,21 @@ func TestEncryptOAEP(t *testing.T) { } func TestDecryptOAEP(t *testing.T) { - urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0); + urandom, err := os.Open("/dev/urandom", os.O_RDONLY, 0) if err != nil { t.Errorf("Failed to open /dev/urandom") } - sha1 := sha1.New(); - n := new(big.Int); - d := new(big.Int); + sha1 := sha1.New() + n := new(big.Int) + d := new(big.Int) for i, test := range testEncryptOAEPData { - n.SetString(test.modulus, 16); - d.SetString(test.d, 16); - private := PrivateKey{PublicKey{n, test.e}, d, nil, nil}; + n.SetString(test.modulus, 16) + d.SetString(test.d, 16) + private := PrivateKey{PublicKey{n, test.e}, d, nil, nil} for j, message := range test.msgs { - out, err := DecryptOAEP(sha1, nil, &private, message.out, nil); + out, err := DecryptOAEP(sha1, nil, &private, message.out, nil) if err != nil { t.Errorf("#%d,%d error: %s", i, j, err) } else if bytes.Compare(out, message.in) != 0 { @@ -98,7 +98,7 @@ func TestDecryptOAEP(t *testing.T) { } // Decrypt with blinding. - out, err = DecryptOAEP(sha1, urandom, &private, message.out, nil); + out, err = DecryptOAEP(sha1, urandom, &private, message.out, nil) if err != nil { t.Errorf("#%d,%d (blind) error: %s", i, j, err) } else if bytes.Compare(out, message.in) != 0 { diff --git a/src/pkg/crypto/sha1/sha1.go b/src/pkg/crypto/sha1/sha1.go index ad648d15d..da70b7314 100644 --- a/src/pkg/crypto/sha1/sha1.go +++ b/src/pkg/crypto/sha1/sha1.go @@ -6,83 +6,83 @@ package sha1 import ( - "hash"; - "os"; + "hash" + "os" ) // The size of a SHA1 checksum in bytes. const Size = 20 const ( - _Chunk = 64; - _Init0 = 0x67452301; - _Init1 = 0xEFCDAB89; - _Init2 = 0x98BADCFE; - _Init3 = 0x10325476; - _Init4 = 0xC3D2E1F0; + _Chunk = 64 + _Init0 = 0x67452301 + _Init1 = 0xEFCDAB89 + _Init2 = 0x98BADCFE + _Init3 = 0x10325476 + _Init4 = 0xC3D2E1F0 ) // digest represents the partial evaluation of a checksum. type digest struct { - h [5]uint32; - x [_Chunk]byte; - nx int; - len uint64; + h [5]uint32 + x [_Chunk]byte + nx int + len uint64 } func (d *digest) Reset() { - d.h[0] = _Init0; - d.h[1] = _Init1; - d.h[2] = _Init2; - d.h[3] = _Init3; - d.h[4] = _Init4; - d.nx = 0; - d.len = 0; + d.h[0] = _Init0 + d.h[1] = _Init1 + d.h[2] = _Init2 + d.h[3] = _Init3 + d.h[4] = _Init4 + d.nx = 0 + d.len = 0 } // New returns a new hash.Hash computing the SHA1 checksum. func New() hash.Hash { - d := new(digest); - d.Reset(); - return d; + d := new(digest) + d.Reset() + return d } -func (d *digest) Size() int { return Size } +func (d *digest) Size() int { return Size } func (d *digest) Write(p []byte) (nn int, err os.Error) { - nn = len(p); - d.len += uint64(nn); + nn = len(p) + d.len += uint64(nn) if d.nx > 0 { - n := len(p); + n := len(p) if n > _Chunk-d.nx { n = _Chunk - d.nx } for i := 0; i < n; i++ { d.x[d.nx+i] = p[i] } - d.nx += n; + d.nx += n if d.nx == _Chunk { - _Block(d, &d.x); - d.nx = 0; + _Block(d, &d.x) + d.nx = 0 } - p = p[n:]; + p = p[n:] } - n := _Block(d, p); - p = p[n:]; + n := _Block(d, p) + p = p[n:] if len(p) > 0 { for i := 0; i < len(p); i++ { d.x[i] = p[i] } - d.nx = len(p); + d.nx = len(p) } - return; + return } func (d *digest) Sum() []byte { // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - len := d.len; - var tmp [64]byte; - tmp[0] = 0x80; + len := d.len + var tmp [64]byte + tmp[0] = 0x80 if len%64 < 56 { d.Write(tmp[0 : 56-len%64]) } else { @@ -90,28 +90,28 @@ func (d *digest) Sum() []byte { } // Length in bits. - len <<= 3; + len <<= 3 for i := uint(0); i < 8; i++ { tmp[i] = byte(len >> (56 - 8*i)) } - d.Write(tmp[0:8]); + d.Write(tmp[0:8]) if d.nx != 0 { panicln("oops") } - p := make([]byte, 20); - j := 0; + p := make([]byte, 20) + j := 0 for i := 0; i < 5; i++ { - s := d.h[i]; - p[j] = byte(s >> 24); - j++; - p[j] = byte(s >> 16); - j++; - p[j] = byte(s >> 8); - j++; - p[j] = byte(s); - j++; + s := d.h[i] + p[j] = byte(s >> 24) + j++ + p[j] = byte(s >> 16) + j++ + p[j] = byte(s >> 8) + j++ + p[j] = byte(s) + j++ } - return p; + return p } diff --git a/src/pkg/crypto/sha1/sha1_test.go b/src/pkg/crypto/sha1/sha1_test.go index 7536300c2..8d4485282 100644 --- a/src/pkg/crypto/sha1/sha1_test.go +++ b/src/pkg/crypto/sha1/sha1_test.go @@ -7,14 +7,14 @@ package sha1 import ( - "fmt"; - "io"; - "testing"; + "fmt" + "io" + "testing" ) type sha1Test struct { - out string; - in string; + out string + in string } var golden = []sha1Test{ @@ -53,16 +53,16 @@ var golden = []sha1Test{ func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { - g := golden[i]; - c := New(); + g := golden[i] + c := New() for j := 0; j < 2; j++ { - io.WriteString(c, g.in); - s := fmt.Sprintf("%x", c.Sum()); + io.WriteString(c, g.in) + s := fmt.Sprintf("%x", c.Sum()) if s != g.out { - t.Errorf("sha1[%d](%s) = %s want %s", j, g.in, s, g.out); - t.FailNow(); + t.Errorf("sha1[%d](%s) = %s want %s", j, g.in, s, g.out) + t.FailNow() } - c.Reset(); + c.Reset() } } } diff --git a/src/pkg/crypto/sha1/sha1block.go b/src/pkg/crypto/sha1/sha1block.go index ff11520c0..b5d32af70 100644 --- a/src/pkg/crypto/sha1/sha1block.go +++ b/src/pkg/crypto/sha1/sha1block.go @@ -9,73 +9,73 @@ package sha1 const ( - _K0 = 0x5A827999; - _K1 = 0x6ED9EBA1; - _K2 = 0x8F1BBCDC; - _K3 = 0xCA62C1D6; + _K0 = 0x5A827999 + _K1 = 0x6ED9EBA1 + _K2 = 0x8F1BBCDC + _K3 = 0xCA62C1D6 ) func _Block(dig *digest, p []byte) int { - var w [80]uint32; + var w [80]uint32 - n := 0; - h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4]; + n := 0 + h0, h1, h2, h3, h4 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] for len(p) >= _Chunk { // Can interlace the computation of w with the // rounds below if needed for speed. for i := 0; i < 16; i++ { - j := i * 4; - w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]); + j := i * 4 + w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]) } for i := 16; i < 80; i++ { - tmp := w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]; - w[i] = tmp<<1 | tmp>>(32-1); + tmp := w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16] + w[i] = tmp<<1 | tmp>>(32-1) } - a, b, c, d, e := h0, h1, h2, h3, h4; + a, b, c, d, e := h0, h1, h2, h3, h4 // Each of the four 20-iteration rounds // differs only in the computation of f and // the choice of K (_K0, _K1, etc). for i := 0; i < 20; i++ { - f := b&c | (^b)&d; - a5 := a<<5 | a>>(32-5); - b30 := b<<30 | b>>(32-30); - t := a5 + f + e + w[i] + _K0; - a, b, c, d, e = t, a, b30, c, d; + f := b&c | (^b)&d + a5 := a<<5 | a>>(32-5) + b30 := b<<30 | b>>(32-30) + t := a5 + f + e + w[i] + _K0 + a, b, c, d, e = t, a, b30, c, d } for i := 20; i < 40; i++ { - f := b ^ c ^ d; - a5 := a<<5 | a>>(32-5); - b30 := b<<30 | b>>(32-30); - t := a5 + f + e + w[i] + _K1; - a, b, c, d, e = t, a, b30, c, d; + f := b ^ c ^ d + a5 := a<<5 | a>>(32-5) + b30 := b<<30 | b>>(32-30) + t := a5 + f + e + w[i] + _K1 + a, b, c, d, e = t, a, b30, c, d } for i := 40; i < 60; i++ { - f := b&c | b&d | c&d; - a5 := a<<5 | a>>(32-5); - b30 := b<<30 | b>>(32-30); - t := a5 + f + e + w[i] + _K2; - a, b, c, d, e = t, a, b30, c, d; + f := b&c | b&d | c&d + a5 := a<<5 | a>>(32-5) + b30 := b<<30 | b>>(32-30) + t := a5 + f + e + w[i] + _K2 + a, b, c, d, e = t, a, b30, c, d } for i := 60; i < 80; i++ { - f := b ^ c ^ d; - a5 := a<<5 | a>>(32-5); - b30 := b<<30 | b>>(32-30); - t := a5 + f + e + w[i] + _K3; - a, b, c, d, e = t, a, b30, c, d; + f := b ^ c ^ d + a5 := a<<5 | a>>(32-5) + b30 := b<<30 | b>>(32-30) + t := a5 + f + e + w[i] + _K3 + a, b, c, d, e = t, a, b30, c, d } - h0 += a; - h1 += b; - h2 += c; - h3 += d; - h4 += e; + h0 += a + h1 += b + h2 += c + h3 += d + h4 += e - p = p[_Chunk:]; - n += _Chunk; + p = p[_Chunk:] + n += _Chunk } - dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4; - return n; + dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4] = h0, h1, h2, h3, h4 + return n } diff --git a/src/pkg/crypto/sha256/sha256.go b/src/pkg/crypto/sha256/sha256.go index a4dbcf912..050dd2211 100644 --- a/src/pkg/crypto/sha256/sha256.go +++ b/src/pkg/crypto/sha256/sha256.go @@ -6,89 +6,89 @@ package sha256 import ( - "hash"; - "os"; + "hash" + "os" ) // The size of a SHA256 checksum in bytes. const Size = 32 const ( - _Chunk = 64; - _Init0 = 0x6A09E667; - _Init1 = 0xBB67AE85; - _Init2 = 0x3C6EF372; - _Init3 = 0xA54FF53A; - _Init4 = 0x510E527F; - _Init5 = 0x9B05688C; - _Init6 = 0x1F83D9AB; - _Init7 = 0x5BE0CD19; + _Chunk = 64 + _Init0 = 0x6A09E667 + _Init1 = 0xBB67AE85 + _Init2 = 0x3C6EF372 + _Init3 = 0xA54FF53A + _Init4 = 0x510E527F + _Init5 = 0x9B05688C + _Init6 = 0x1F83D9AB + _Init7 = 0x5BE0CD19 ) // digest represents the partial evaluation of a checksum. type digest struct { - h [8]uint32; - x [_Chunk]byte; - nx int; - len uint64; + h [8]uint32 + x [_Chunk]byte + nx int + len uint64 } func (d *digest) Reset() { - d.h[0] = _Init0; - d.h[1] = _Init1; - d.h[2] = _Init2; - d.h[3] = _Init3; - d.h[4] = _Init4; - d.h[5] = _Init5; - d.h[6] = _Init6; - d.h[7] = _Init7; - d.nx = 0; - d.len = 0; + d.h[0] = _Init0 + d.h[1] = _Init1 + d.h[2] = _Init2 + d.h[3] = _Init3 + d.h[4] = _Init4 + d.h[5] = _Init5 + d.h[6] = _Init6 + d.h[7] = _Init7 + d.nx = 0 + d.len = 0 } // New returns a new hash.Hash computing the SHA256 checksum. func New() hash.Hash { - d := new(digest); - d.Reset(); - return d; + d := new(digest) + d.Reset() + return d } -func (d *digest) Size() int { return Size } +func (d *digest) Size() int { return Size } func (d *digest) Write(p []byte) (nn int, err os.Error) { - nn = len(p); - d.len += uint64(nn); + nn = len(p) + d.len += uint64(nn) if d.nx > 0 { - n := len(p); + n := len(p) if n > _Chunk-d.nx { n = _Chunk - d.nx } for i := 0; i < n; i++ { d.x[d.nx+i] = p[i] } - d.nx += n; + d.nx += n if d.nx == _Chunk { - _Block(d, &d.x); - d.nx = 0; + _Block(d, &d.x) + d.nx = 0 } - p = p[n:]; + p = p[n:] } - n := _Block(d, p); - p = p[n:]; + n := _Block(d, p) + p = p[n:] if len(p) > 0 { for i := 0; i < len(p); i++ { d.x[i] = p[i] } - d.nx = len(p); + d.nx = len(p) } - return; + return } func (d *digest) Sum() []byte { // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. - len := d.len; - var tmp [64]byte; - tmp[0] = 0x80; + len := d.len + var tmp [64]byte + tmp[0] = 0x80 if len%64 < 56 { d.Write(tmp[0 : 56-len%64]) } else { @@ -96,28 +96,28 @@ func (d *digest) Sum() []byte { } // Length in bits. - len <<= 3; + len <<= 3 for i := uint(0); i < 8; i++ { tmp[i] = byte(len >> (56 - 8*i)) } - d.Write(tmp[0:8]); + d.Write(tmp[0:8]) if d.nx != 0 { panicln("oops") } - p := make([]byte, 32); - j := 0; + p := make([]byte, 32) + j := 0 for i := 0; i < 8; i++ { - s := d.h[i]; - p[j] = byte(s >> 24); - j++; - p[j] = byte(s >> 16); - j++; - p[j] = byte(s >> 8); - j++; - p[j] = byte(s); - j++; + s := d.h[i] + p[j] = byte(s >> 24) + j++ + p[j] = byte(s >> 16) + j++ + p[j] = byte(s >> 8) + j++ + p[j] = byte(s) + j++ } - return p; + return p } diff --git a/src/pkg/crypto/sha256/sha256_test.go b/src/pkg/crypto/sha256/sha256_test.go index 5f1c96924..29c0bce60 100644 --- a/src/pkg/crypto/sha256/sha256_test.go +++ b/src/pkg/crypto/sha256/sha256_test.go @@ -7,14 +7,14 @@ package sha256 import ( - "fmt"; - "io"; - "testing"; + "fmt" + "io" + "testing" ) type sha256Test struct { - out string; - in string; + out string + in string } var golden = []sha256Test{ @@ -53,16 +53,16 @@ var golden = []sha256Test{ func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { - g := golden[i]; - c := New(); + g := golden[i] + c := New() for j := 0; j < 2; j++ { - io.WriteString(c, g.in); - s := fmt.Sprintf("%x", c.Sum()); + io.WriteString(c, g.in) + s := fmt.Sprintf("%x", c.Sum()) if s != g.out { - t.Errorf("sha256[%d](%s) = %s want %s", j, g.in, s, g.out); - t.FailNow(); + t.Errorf("sha256[%d](%s) = %s want %s", j, g.in, s, g.out) + t.FailNow() } - c.Reset(); + c.Reset() } } } diff --git a/src/pkg/crypto/sha256/sha256block.go b/src/pkg/crypto/sha256/sha256block.go index a00170859..7b0f55444 100644 --- a/src/pkg/crypto/sha256/sha256block.go +++ b/src/pkg/crypto/sha256/sha256block.go @@ -76,54 +76,54 @@ var _K = []uint32{ } func _Block(dig *digest, p []byte) int { - var w [64]uint32; - n := 0; - h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7]; + var w [64]uint32 + n := 0 + h0, h1, h2, h3, h4, h5, h6, h7 := dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] for len(p) >= _Chunk { // Can interlace the computation of w with the // rounds below if needed for speed. for i := 0; i < 16; i++ { - j := i * 4; - w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]); + j := i * 4 + w[i] = uint32(p[j])<<24 | uint32(p[j+1])<<16 | uint32(p[j+2])<<8 | uint32(p[j+3]) } for i := 16; i < 64; i++ { - t1 := (w[i-2]>>17 | w[i-2]<<(32-17)) ^ (w[i-2]>>19 | w[i-2]<<(32-19)) ^ (w[i-2] >> 10); + t1 := (w[i-2]>>17 | w[i-2]<<(32-17)) ^ (w[i-2]>>19 | w[i-2]<<(32-19)) ^ (w[i-2] >> 10) - t2 := (w[i-15]>>7 | w[i-15]<<(32-7)) ^ (w[i-15]>>18 | w[i-15]<<(32-18)) ^ (w[i-15] >> 3); + t2 := (w[i-15]>>7 | w[i-15]<<(32-7)) ^ (w[i-15]>>18 | w[i-15]<<(32-18)) ^ (w[i-15] >> 3) - w[i] = t1 + w[i-7] + t2 + w[i-16]; + w[i] = t1 + w[i-7] + t2 + w[i-16] } - a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7; + a, b, c, d, e, f, g, h := h0, h1, h2, h3, h4, h5, h6, h7 for i := 0; i < 64; i++ { - t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i]; + t1 := h + ((e>>6 | e<<(32-6)) ^ (e>>11 | e<<(32-11)) ^ (e>>25 | e<<(32-25))) + ((e & f) ^ (^e & g)) + _K[i] + w[i] - t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c)); + t2 := ((a>>2 | a<<(32-2)) ^ (a>>13 | a<<(32-13)) ^ (a>>22 | a<<(32-22))) + ((a & b) ^ (a & c) ^ (b & c)) - h = g; - g = f; - f = e; - e = d + t1; - d = c; - c = b; - b = a; - a = t1 + t2; + h = g + g = f + f = e + e = d + t1 + d = c + c = b + b = a + a = t1 + t2 } - h0 += a; - h1 += b; - h2 += c; - h3 += d; - h4 += e; - h5 += f; - h6 += g; - h7 += h; + h0 += a + h1 += b + h2 += c + h3 += d + h4 += e + h5 += f + h6 += g + h7 += h - p = p[_Chunk:]; - n += _Chunk; + p = p[_Chunk:] + n += _Chunk } - dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7; - return n; + dig.h[0], dig.h[1], dig.h[2], dig.h[3], dig.h[4], dig.h[5], dig.h[6], dig.h[7] = h0, h1, h2, h3, h4, h5, h6, h7 + return n } diff --git a/src/pkg/crypto/subtle/constant_time.go b/src/pkg/crypto/subtle/constant_time.go index 79a96ec96..a3d70b9c9 100644 --- a/src/pkg/crypto/subtle/constant_time.go +++ b/src/pkg/crypto/subtle/constant_time.go @@ -10,48 +10,48 @@ package subtle // and y, have equal contents. The time taken is a function of the length of // the slices and is independent of the contents. func ConstantTimeCompare(x, y []byte) int { - var v byte; + var v byte for i := 0; i < len(x); i++ { v |= x[i] ^ y[i] } - return ConstantTimeByteEq(v, 0); + return ConstantTimeByteEq(v, 0) } // ConstantTimeSelect returns x if v is 1 and y if v is 0. // Its behavior is undefined if v takes any other value. -func ConstantTimeSelect(v, x, y int) int { return ^(v-1)&x | (v-1)&y } +func ConstantTimeSelect(v, x, y int) int { return ^(v-1)&x | (v-1)&y } // ConstantTimeByteEq returns 1 if x == y and 0 otherwise. func ConstantTimeByteEq(x, y uint8) int { - z := ^(x ^ y); - z &= z >> 4; - z &= z >> 2; - z &= z >> 1; + z := ^(x ^ y) + z &= z >> 4 + z &= z >> 2 + z &= z >> 1 - return int(z); + return int(z) } // ConstantTimeEq returns 1 if x == y and 0 otherwise. func ConstantTimeEq(x, y int32) int { - z := ^(x ^ y); - z &= z >> 16; - z &= z >> 8; - z &= z >> 4; - z &= z >> 2; - z &= z >> 1; - - return int(z & 1); + z := ^(x ^ y) + z &= z >> 16 + z &= z >> 8 + z &= z >> 4 + z &= z >> 2 + z &= z >> 1 + + return int(z & 1) } // ConstantTimeCopy copies the contents of y into x iff v == 1. If v == 0, x is left unchanged. // Its behavior is undefined if v takes any other value. func ConstantTimeCopy(v int, x, y []byte) { - xmask := byte(v - 1); - ymask := byte(^(v - 1)); + xmask := byte(v - 1) + ymask := byte(^(v - 1)) for i := 0; i < len(x); i++ { x[i] = x[i]&xmask | y[i]&ymask } - return; + return } diff --git a/src/pkg/crypto/subtle/constant_time_test.go b/src/pkg/crypto/subtle/constant_time_test.go index d9faafe5f..25962b9ae 100644 --- a/src/pkg/crypto/subtle/constant_time_test.go +++ b/src/pkg/crypto/subtle/constant_time_test.go @@ -5,13 +5,13 @@ package subtle import ( - "testing"; - "testing/quick"; + "testing" + "testing/quick" ) type TestConstantTimeCompareStruct struct { - a, b []byte; - out int; + a, b []byte + out int } var testConstandTimeCompareData = []TestConstantTimeCompareStruct{ @@ -29,8 +29,8 @@ func TestConstantTimeCompare(t *testing.T) { } type TestConstantTimeByteEqStruct struct { - a, b uint8; - out int; + a, b uint8 + out int } var testConstandTimeByteEqData = []TestConstantTimeByteEqStruct{ @@ -45,7 +45,7 @@ func byteEq(a, b uint8) int { if a == b { return 1 } - return 0; + return 0 } func TestConstantTimeByteEq(t *testing.T) { @@ -54,7 +54,7 @@ func TestConstantTimeByteEq(t *testing.T) { t.Errorf("#%d bad result (got %x, want %x)", i, r, test.out) } } - err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil); + err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil) if err != nil { t.Error(err) } @@ -64,11 +64,11 @@ func eq(a, b int32) int { if a == b { return 1 } - return 0; + return 0 } func TestConstantTimeEq(t *testing.T) { - err := quick.CheckEqual(ConstantTimeEq, eq, nil); + err := quick.CheckEqual(ConstantTimeEq, eq, nil) if err != nil { t.Error(err) } @@ -83,7 +83,7 @@ func makeCopy(v int, x, y []byte) []byte { if v == 1 { copy(x, y) } - return x; + return x } func constantTimeCopyWrapper(v int, x, y []byte) []byte { @@ -92,13 +92,13 @@ func constantTimeCopyWrapper(v int, x, y []byte) []byte { } else { y = y[0:len(x)] } - v &= 1; - ConstantTimeCopy(v, x, y); - return x; + v &= 1 + ConstantTimeCopy(v, x, y) + return x } func TestConstantTimeCopy(t *testing.T) { - err := quick.CheckEqual(constantTimeCopyWrapper, makeCopy, nil); + err := quick.CheckEqual(constantTimeCopyWrapper, makeCopy, nil) if err != nil { t.Error(err) } diff --git a/src/pkg/crypto/tls/alert.go b/src/pkg/crypto/tls/alert.go index 4cf62e7a4..2f740b39e 100644 --- a/src/pkg/crypto/tls/alert.go +++ b/src/pkg/crypto/tls/alert.go @@ -8,36 +8,36 @@ type alertLevel int type alertType int const ( - alertLevelWarning alertLevel = 1; - alertLevelError alertLevel = 2; + alertLevelWarning alertLevel = 1 + alertLevelError alertLevel = 2 ) const ( - alertCloseNotify alertType = 0; - alertUnexpectedMessage alertType = 10; - alertBadRecordMAC alertType = 20; - alertDecryptionFailed alertType = 21; - alertRecordOverflow alertType = 22; - alertDecompressionFailure alertType = 30; - alertHandshakeFailure alertType = 40; - alertBadCertificate alertType = 42; - alertUnsupportedCertificate alertType = 43; - alertCertificateRevoked alertType = 44; - alertCertificateExpired alertType = 45; - alertCertificateUnknown alertType = 46; - alertIllegalParameter alertType = 47; - alertUnknownCA alertType = 48; - alertAccessDenied alertType = 49; - alertDecodeError alertType = 50; - alertDecryptError alertType = 51; - alertProtocolVersion alertType = 70; - alertInsufficientSecurity alertType = 71; - alertInternalError alertType = 80; - alertUserCanceled alertType = 90; - alertNoRenegotiation alertType = 100; + alertCloseNotify alertType = 0 + alertUnexpectedMessage alertType = 10 + alertBadRecordMAC alertType = 20 + alertDecryptionFailed alertType = 21 + alertRecordOverflow alertType = 22 + alertDecompressionFailure alertType = 30 + alertHandshakeFailure alertType = 40 + alertBadCertificate alertType = 42 + alertUnsupportedCertificate alertType = 43 + alertCertificateRevoked alertType = 44 + alertCertificateExpired alertType = 45 + alertCertificateUnknown alertType = 46 + alertIllegalParameter alertType = 47 + alertUnknownCA alertType = 48 + alertAccessDenied alertType = 49 + alertDecodeError alertType = 50 + alertDecryptError alertType = 51 + alertProtocolVersion alertType = 70 + alertInsufficientSecurity alertType = 71 + alertInternalError alertType = 80 + alertUserCanceled alertType = 90 + alertNoRenegotiation alertType = 100 ) type alert struct { - level alertLevel; - error alertType; + level alertLevel + error alertType } diff --git a/src/pkg/crypto/tls/ca_set.go b/src/pkg/crypto/tls/ca_set.go index e8cddd6f4..00f6a8730 100644 --- a/src/pkg/crypto/tls/ca_set.go +++ b/src/pkg/crypto/tls/ca_set.go @@ -5,14 +5,14 @@ package tls import ( - "crypto/x509"; - "encoding/pem"; + "crypto/x509" + "encoding/pem" ) // A CASet is a set of certificates. type CASet struct { - bySubjectKeyId map[string]*x509.Certificate; - byName map[string]*x509.Certificate; + bySubjectKeyId map[string]*x509.Certificate + byName map[string]*x509.Certificate } func NewCASet() *CASet { @@ -29,7 +29,7 @@ func nameToKey(name *x509.Name) string { // FindParent attempts to find the certificate in s which signs the given // certificate. If no such certificate can be found, it returns nil. func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) { - var ok bool; + var ok bool if len(cert.AuthorityKeyId) > 0 { parent, ok = s.bySubjectKeyId[string(cert.AuthorityKeyId)] @@ -40,7 +40,7 @@ func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) { if !ok { return nil } - return parent; + return parent } // SetFromPEM attempts to parse a series of PEM encoded root certificates. It @@ -50,8 +50,8 @@ func (s *CASet) FindParent(cert *x509.Certificate) (parent *x509.Certificate) { // function. func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) { for len(pemCerts) > 0 { - var block *pem.Block; - block, pemCerts = pem.Decode(pemCerts); + var block *pem.Block + block, pemCerts = pem.Decode(pemCerts) if block == nil { break } @@ -59,7 +59,7 @@ func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) { continue } - cert, err := x509.ParseCertificate(block.Bytes); + cert, err := x509.ParseCertificate(block.Bytes) if err != nil { continue } @@ -67,9 +67,9 @@ func (s *CASet) SetFromPEM(pemCerts []byte) (ok bool) { if len(cert.SubjectKeyId) > 0 { s.bySubjectKeyId[string(cert.SubjectKeyId)] = cert } - s.byName[nameToKey(&cert.Subject)] = cert; - ok = true; + s.byName[nameToKey(&cert.Subject)] = cert + ok = true } - return; + return } diff --git a/src/pkg/crypto/tls/common.go b/src/pkg/crypto/tls/common.go index e1318a893..51de53389 100644 --- a/src/pkg/crypto/tls/common.go +++ b/src/pkg/crypto/tls/common.go @@ -5,21 +5,21 @@ package tls import ( - "crypto/rsa"; - "io"; - "os"; + "crypto/rsa" + "io" + "os" ) const ( // maxTLSCiphertext is the maximum length of a plaintext payload. - maxTLSPlaintext = 16384; + maxTLSPlaintext = 16384 // maxTLSCiphertext is the maximum length payload after compression and encryption. - maxTLSCiphertext = 16384 + 2048; + maxTLSCiphertext = 16384 + 2048 // maxHandshakeMsg is the largest single handshake message that we'll buffer. - maxHandshakeMsg = 65536; + maxHandshakeMsg = 65536 // defaultMajor and defaultMinor are the maximum TLS version that we support. - defaultMajor = 3; - defaultMinor = 2; + defaultMajor = 3 + defaultMinor = 2 ) @@ -27,68 +27,68 @@ const ( type recordType uint8 const ( - recordTypeChangeCipherSpec recordType = 20; - recordTypeAlert recordType = 21; - recordTypeHandshake recordType = 22; - recordTypeApplicationData recordType = 23; + recordTypeChangeCipherSpec recordType = 20 + recordTypeAlert recordType = 21 + recordTypeHandshake recordType = 22 + recordTypeApplicationData recordType = 23 ) // TLS handshake message types. const ( - typeClientHello uint8 = 1; - typeServerHello uint8 = 2; - typeCertificate uint8 = 11; - typeServerHelloDone uint8 = 14; - typeClientKeyExchange uint8 = 16; - typeFinished uint8 = 20; + typeClientHello uint8 = 1 + typeServerHello uint8 = 2 + typeCertificate uint8 = 11 + typeServerHelloDone uint8 = 14 + typeClientKeyExchange uint8 = 16 + typeFinished uint8 = 20 ) // TLS cipher suites. var ( - TLS_RSA_WITH_RC4_128_SHA uint16 = 5; + TLS_RSA_WITH_RC4_128_SHA uint16 = 5 ) // TLS compression types. var ( - compressionNone uint8 = 0; + compressionNone uint8 = 0 ) type ConnectionState struct { - HandshakeComplete bool; - CipherSuite string; - Error alertType; + HandshakeComplete bool + CipherSuite string + Error alertType } // A Config structure is used to configure a TLS client or server. After one // has been passed to a TLS function it must not be modified. type Config struct { // Rand provides the source of entropy for nonces and RSA blinding. - Rand io.Reader; + Rand io.Reader // Time returns the current time as the number of seconds since the epoch. - Time func() int64; - Certificates []Certificate; - RootCAs *CASet; + Time func() int64 + Certificates []Certificate + RootCAs *CASet } type Certificate struct { - Certificate [][]byte; - PrivateKey *rsa.PrivateKey; + Certificate [][]byte + PrivateKey *rsa.PrivateKey } // A TLS record. type record struct { - contentType recordType; - major, minor uint8; - payload []byte; + contentType recordType + major, minor uint8 + payload []byte } type handshakeMessage interface { - marshal() []byte; + marshal() []byte } type encryptor interface { // XORKeyStream xors the contents of the slice with bytes from the key stream. - XORKeyStream(buf []byte); + XORKeyStream(buf []byte) } // mutualVersion returns the protocol version to use given the advertised @@ -98,24 +98,24 @@ func mutualVersion(theirMajor, theirMinor uint8) (major, minor uint8, ok bool) { if theirMajor < 3 || theirMajor == 3 && theirMinor < 1 { return 0, 0, false } - major = 3; - minor = 2; + major = 3 + minor = 2 if theirMinor < minor { minor = theirMinor } - ok = true; - return; + ok = true + return } // A nop implements the NULL encryption and MAC algorithms. type nop struct{} -func (nop) XORKeyStream(buf []byte) {} +func (nop) XORKeyStream(buf []byte) {} -func (nop) Write(buf []byte) (int, os.Error) { return len(buf), nil } +func (nop) Write(buf []byte) (int, os.Error) { return len(buf), nil } -func (nop) Sum() []byte { return nil } +func (nop) Sum() []byte { return nil } -func (nop) Reset() {} +func (nop) Reset() {} -func (nop) Size() int { return 0 } +func (nop) Size() int { return 0 } diff --git a/src/pkg/crypto/tls/handshake_client.go b/src/pkg/crypto/tls/handshake_client.go index 1c6bd4b81..4e31e7094 100644 --- a/src/pkg/crypto/tls/handshake_client.go +++ b/src/pkg/crypto/tls/handshake_client.go @@ -5,33 +5,33 @@ package tls import ( - "crypto/hmac"; - "crypto/rc4"; - "crypto/rsa"; - "crypto/sha1"; - "crypto/subtle"; - "crypto/x509"; - "io"; + "crypto/hmac" + "crypto/rc4" + "crypto/rsa" + "crypto/sha1" + "crypto/subtle" + "crypto/x509" + "io" ) // A serverHandshake performs the server side of the TLS 1.1 handshake protocol. type clientHandshake struct { - writeChan chan<- interface{}; - controlChan chan<- interface{}; - msgChan <-chan interface{}; - config *Config; + writeChan chan<- interface{} + controlChan chan<- interface{} + msgChan <-chan interface{} + config *Config } func (h *clientHandshake) loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config) { - h.writeChan = writeChan; - h.controlChan = controlChan; - h.msgChan = msgChan; - h.config = config; + h.writeChan = writeChan + h.controlChan = controlChan + h.msgChan = msgChan + h.config = config - defer close(writeChan); - defer close(controlChan); + defer close(writeChan) + defer close(controlChan) - finishedHash := newFinishedHash(); + finishedHash := newFinishedHash() hello := &clientHelloMsg{ major: defaultMajor, @@ -39,175 +39,175 @@ func (h *clientHandshake) loop(writeChan chan<- interface{}, controlChan chan<- cipherSuites: []uint16{TLS_RSA_WITH_RC4_128_SHA}, compressionMethods: []uint8{compressionNone}, random: make([]byte, 32), - }; - - currentTime := uint32(config.Time()); - hello.random[0] = byte(currentTime >> 24); - hello.random[1] = byte(currentTime >> 16); - hello.random[2] = byte(currentTime >> 8); - hello.random[3] = byte(currentTime); - _, err := io.ReadFull(config.Rand, hello.random[4:]); + } + + currentTime := uint32(config.Time()) + hello.random[0] = byte(currentTime >> 24) + hello.random[1] = byte(currentTime >> 16) + hello.random[2] = byte(currentTime >> 8) + hello.random[3] = byte(currentTime) + _, err := io.ReadFull(config.Rand, hello.random[4:]) if err != nil { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - finishedHash.Write(hello.marshal()); - writeChan <- writerSetVersion{defaultMajor, defaultMinor}; - writeChan <- hello; + finishedHash.Write(hello.marshal()) + writeChan <- writerSetVersion{defaultMajor, defaultMinor} + writeChan <- hello - serverHello, ok := h.readHandshakeMsg().(*serverHelloMsg); + serverHello, ok := h.readHandshakeMsg().(*serverHelloMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - finishedHash.Write(serverHello.marshal()); - major, minor, ok := mutualVersion(serverHello.major, serverHello.minor); + finishedHash.Write(serverHello.marshal()) + major, minor, ok := mutualVersion(serverHello.major, serverHello.minor) if !ok { - h.error(alertProtocolVersion); - return; + h.error(alertProtocolVersion) + return } - writeChan <- writerSetVersion{major, minor}; + writeChan <- writerSetVersion{major, minor} if serverHello.cipherSuite != TLS_RSA_WITH_RC4_128_SHA || serverHello.compressionMethod != compressionNone { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - certMsg, ok := h.readHandshakeMsg().(*certificateMsg); + certMsg, ok := h.readHandshakeMsg().(*certificateMsg) if !ok || len(certMsg.certificates) == 0 { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - finishedHash.Write(certMsg.marshal()); + finishedHash.Write(certMsg.marshal()) - certs := make([]*x509.Certificate, len(certMsg.certificates)); + certs := make([]*x509.Certificate, len(certMsg.certificates)) for i, asn1Data := range certMsg.certificates { - cert, err := x509.ParseCertificate(asn1Data); + cert, err := x509.ParseCertificate(asn1Data) if err != nil { - h.error(alertBadCertificate); - return; + h.error(alertBadCertificate) + return } - certs[i] = cert; + certs[i] = cert } // TODO(agl): do better validation of certs: max path length, name restrictions etc. for i := 1; i < len(certs); i++ { if certs[i-1].CheckSignatureFrom(certs[i]) != nil { - h.error(alertBadCertificate); - return; + h.error(alertBadCertificate) + return } } if config.RootCAs != nil { - root := config.RootCAs.FindParent(certs[len(certs)-1]); + root := config.RootCAs.FindParent(certs[len(certs)-1]) if root == nil { - h.error(alertBadCertificate); - return; + h.error(alertBadCertificate) + return } if certs[len(certs)-1].CheckSignatureFrom(root) != nil { - h.error(alertBadCertificate); - return; + h.error(alertBadCertificate) + return } } - pub, ok := certs[0].PublicKey.(*rsa.PublicKey); + pub, ok := certs[0].PublicKey.(*rsa.PublicKey) if !ok { - h.error(alertUnsupportedCertificate); - return; + h.error(alertUnsupportedCertificate) + return } - shd, ok := h.readHandshakeMsg().(*serverHelloDoneMsg); + shd, ok := h.readHandshakeMsg().(*serverHelloDoneMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - finishedHash.Write(shd.marshal()); + finishedHash.Write(shd.marshal()) - ckx := new(clientKeyExchangeMsg); - preMasterSecret := make([]byte, 48); + ckx := new(clientKeyExchangeMsg) + preMasterSecret := make([]byte, 48) // Note that the version number in the preMasterSecret must be the // version offered in the ClientHello. - preMasterSecret[0] = defaultMajor; - preMasterSecret[1] = defaultMinor; - _, err = io.ReadFull(config.Rand, preMasterSecret[2:]); + preMasterSecret[0] = defaultMajor + preMasterSecret[1] = defaultMinor + _, err = io.ReadFull(config.Rand, preMasterSecret[2:]) if err != nil { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - ckx.ciphertext, err = rsa.EncryptPKCS1v15(config.Rand, pub, preMasterSecret); + ckx.ciphertext, err = rsa.EncryptPKCS1v15(config.Rand, pub, preMasterSecret) if err != nil { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - finishedHash.Write(ckx.marshal()); - writeChan <- ckx; + finishedHash.Write(ckx.marshal()) + writeChan <- ckx - suite := cipherSuites[0]; + suite := cipherSuites[0] masterSecret, clientMAC, serverMAC, clientKey, serverKey := - keysFromPreMasterSecret11(preMasterSecret, hello.random, serverHello.random, suite.hashLength, suite.cipherKeyLength); + keysFromPreMasterSecret11(preMasterSecret, hello.random, serverHello.random, suite.hashLength, suite.cipherKeyLength) - cipher, _ := rc4.NewCipher(clientKey); - writeChan <- writerChangeCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)}; + cipher, _ := rc4.NewCipher(clientKey) + writeChan <- writerChangeCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)} - finished := new(finishedMsg); - finished.verifyData = finishedHash.clientSum(masterSecret); - finishedHash.Write(finished.marshal()); - writeChan <- finished; + finished := new(finishedMsg) + finished.verifyData = finishedHash.clientSum(masterSecret) + finishedHash.Write(finished.marshal()) + writeChan <- finished // TODO(agl): this is cut-through mode which should probably be an option. - writeChan <- writerEnableApplicationData{}; + writeChan <- writerEnableApplicationData{} - _, ok = h.readHandshakeMsg().(changeCipherSpec); + _, ok = h.readHandshakeMsg().(changeCipherSpec) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - cipher2, _ := rc4.NewCipher(serverKey); - controlChan <- &newCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)}; + cipher2, _ := rc4.NewCipher(serverKey) + controlChan <- &newCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)} - serverFinished, ok := h.readHandshakeMsg().(*finishedMsg); + serverFinished, ok := h.readHandshakeMsg().(*finishedMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - verify := finishedHash.serverSum(masterSecret); + verify := finishedHash.serverSum(masterSecret) if len(verify) != len(serverFinished.verifyData) || subtle.ConstantTimeCompare(verify, serverFinished.verifyData) != 1 { - h.error(alertHandshakeFailure); - return; + h.error(alertHandshakeFailure) + return } - controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}; + controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0} // This should just block forever. - _ = h.readHandshakeMsg(); - h.error(alertUnexpectedMessage); - return; + _ = h.readHandshakeMsg() + h.error(alertUnexpectedMessage) + return } func (h *clientHandshake) readHandshakeMsg() interface{} { - v := <-h.msgChan; + v := <-h.msgChan if closed(h.msgChan) { // If the channel closed then the processor received an error // from the peer and we don't want to echo it back to them. - h.msgChan = nil; - return 0; + h.msgChan = nil + return 0 } if _, ok := v.(alert); ok { // We got an alert from the processor. We forward to the writer // and shutdown. - h.writeChan <- v; - h.msgChan = nil; - return 0; + h.writeChan <- v + h.msgChan = nil + return 0 } - return v; + return v } func (h *clientHandshake) error(e alertType) { @@ -217,9 +217,9 @@ func (h *clientHandshake) error(e alertType) { go func() { for _ = range h.msgChan { } - }(); - h.controlChan <- ConnectionState{false, "", e}; - close(h.controlChan); - h.writeChan <- alert{alertLevelError, e}; + }() + h.controlChan <- ConnectionState{false, "", e} + close(h.controlChan) + h.writeChan <- alert{alertLevelError, e} } } diff --git a/src/pkg/crypto/tls/handshake_messages.go b/src/pkg/crypto/tls/handshake_messages.go index b5f2aa731..2870969eb 100644 --- a/src/pkg/crypto/tls/handshake_messages.go +++ b/src/pkg/crypto/tls/handshake_messages.go @@ -5,12 +5,12 @@ package tls type clientHelloMsg struct { - raw []byte; - major, minor uint8; - random []byte; - sessionId []byte; - cipherSuites []uint16; - compressionMethods []uint8; + raw []byte + major, minor uint8 + random []byte + sessionId []byte + cipherSuites []uint16 + compressionMethods []uint8 } func (m *clientHelloMsg) marshal() []byte { @@ -18,81 +18,81 @@ func (m *clientHelloMsg) marshal() []byte { return m.raw } - length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods); - x := make([]byte, 4+length); - x[0] = typeClientHello; - x[1] = uint8(length >> 16); - x[2] = uint8(length >> 8); - x[3] = uint8(length); - x[4] = m.major; - x[5] = m.minor; - copy(x[6:38], m.random); - x[38] = uint8(len(m.sessionId)); - copy(x[39:39+len(m.sessionId)], m.sessionId); - y := x[39+len(m.sessionId):]; - y[0] = uint8(len(m.cipherSuites) >> 7); - y[1] = uint8(len(m.cipherSuites) << 1); + length := 2 + 32 + 1 + len(m.sessionId) + 2 + len(m.cipherSuites)*2 + 1 + len(m.compressionMethods) + x := make([]byte, 4+length) + x[0] = typeClientHello + x[1] = uint8(length >> 16) + x[2] = uint8(length >> 8) + x[3] = uint8(length) + x[4] = m.major + x[5] = m.minor + copy(x[6:38], m.random) + x[38] = uint8(len(m.sessionId)) + copy(x[39:39+len(m.sessionId)], m.sessionId) + y := x[39+len(m.sessionId):] + y[0] = uint8(len(m.cipherSuites) >> 7) + y[1] = uint8(len(m.cipherSuites) << 1) for i, suite := range m.cipherSuites { - y[2+i*2] = uint8(suite >> 8); - y[3+i*2] = uint8(suite); + y[2+i*2] = uint8(suite >> 8) + y[3+i*2] = uint8(suite) } - z := y[2+len(m.cipherSuites)*2:]; - z[0] = uint8(len(m.compressionMethods)); - copy(z[1:], m.compressionMethods); - m.raw = x; + z := y[2+len(m.cipherSuites)*2:] + z[0] = uint8(len(m.compressionMethods)) + copy(z[1:], m.compressionMethods) + m.raw = x - return x; + return x } func (m *clientHelloMsg) unmarshal(data []byte) bool { if len(data) < 43 { return false } - m.raw = data; - m.major = data[4]; - m.minor = data[5]; - m.random = data[6:38]; - sessionIdLen := int(data[38]); + m.raw = data + m.major = data[4] + m.minor = data[5] + m.random = data[6:38] + sessionIdLen := int(data[38]) if sessionIdLen > 32 || len(data) < 39+sessionIdLen { return false } - m.sessionId = data[39 : 39+sessionIdLen]; - data = data[39+sessionIdLen:]; + m.sessionId = data[39 : 39+sessionIdLen] + data = data[39+sessionIdLen:] if len(data) < 2 { return false } // cipherSuiteLen is the number of bytes of cipher suite numbers. Since // they are uint16s, the number must be even. - cipherSuiteLen := int(data[0])<<8 | int(data[1]); + cipherSuiteLen := int(data[0])<<8 | int(data[1]) if cipherSuiteLen%2 == 1 || len(data) < 2+cipherSuiteLen { return false } - numCipherSuites := cipherSuiteLen / 2; - m.cipherSuites = make([]uint16, numCipherSuites); + numCipherSuites := cipherSuiteLen / 2 + m.cipherSuites = make([]uint16, numCipherSuites) for i := 0; i < numCipherSuites; i++ { m.cipherSuites[i] = uint16(data[2+2*i])<<8 | uint16(data[3+2*i]) } - data = data[2+cipherSuiteLen:]; + data = data[2+cipherSuiteLen:] if len(data) < 2 { return false } - compressionMethodsLen := int(data[0]); + compressionMethodsLen := int(data[0]) if len(data) < 1+compressionMethodsLen { return false } - m.compressionMethods = data[1 : 1+compressionMethodsLen]; + m.compressionMethods = data[1 : 1+compressionMethodsLen] // A ClientHello may be following by trailing data: RFC 4346 section 7.4.1.2 - return true; + return true } type serverHelloMsg struct { - raw []byte; - major, minor uint8; - random []byte; - sessionId []byte; - cipherSuite uint16; - compressionMethod uint8; + raw []byte + major, minor uint8 + random []byte + sessionId []byte + cipherSuite uint16 + compressionMethod uint8 } func (m *serverHelloMsg) marshal() []byte { @@ -100,53 +100,53 @@ func (m *serverHelloMsg) marshal() []byte { return m.raw } - length := 38 + len(m.sessionId); - x := make([]byte, 4+length); - x[0] = typeServerHello; - x[1] = uint8(length >> 16); - x[2] = uint8(length >> 8); - x[3] = uint8(length); - x[4] = m.major; - x[5] = m.minor; - copy(x[6:38], m.random); - x[38] = uint8(len(m.sessionId)); - copy(x[39:39+len(m.sessionId)], m.sessionId); - z := x[39+len(m.sessionId):]; - z[0] = uint8(m.cipherSuite >> 8); - z[1] = uint8(m.cipherSuite); - z[2] = uint8(m.compressionMethod); - m.raw = x; - - return x; + length := 38 + len(m.sessionId) + x := make([]byte, 4+length) + x[0] = typeServerHello + x[1] = uint8(length >> 16) + x[2] = uint8(length >> 8) + x[3] = uint8(length) + x[4] = m.major + x[5] = m.minor + copy(x[6:38], m.random) + x[38] = uint8(len(m.sessionId)) + copy(x[39:39+len(m.sessionId)], m.sessionId) + z := x[39+len(m.sessionId):] + z[0] = uint8(m.cipherSuite >> 8) + z[1] = uint8(m.cipherSuite) + z[2] = uint8(m.compressionMethod) + m.raw = x + + return x } func (m *serverHelloMsg) unmarshal(data []byte) bool { if len(data) < 42 { return false } - m.raw = data; - m.major = data[4]; - m.minor = data[5]; - m.random = data[6:38]; - sessionIdLen := int(data[38]); + m.raw = data + m.major = data[4] + m.minor = data[5] + m.random = data[6:38] + sessionIdLen := int(data[38]) if sessionIdLen > 32 || len(data) < 39+sessionIdLen { return false } - m.sessionId = data[39 : 39+sessionIdLen]; - data = data[39+sessionIdLen:]; + m.sessionId = data[39 : 39+sessionIdLen] + data = data[39+sessionIdLen:] if len(data) < 3 { return false } - m.cipherSuite = uint16(data[0])<<8 | uint16(data[1]); - m.compressionMethod = data[2]; + m.cipherSuite = uint16(data[0])<<8 | uint16(data[1]) + m.compressionMethod = data[2] // Trailing data is allowed because extensions may be present. - return true; + return true } type certificateMsg struct { - raw []byte; - certificates [][]byte; + raw []byte + certificates [][]byte } func (m *certificateMsg) marshal() (x []byte) { @@ -154,34 +154,34 @@ func (m *certificateMsg) marshal() (x []byte) { return m.raw } - var i int; + var i int for _, slice := range m.certificates { i += len(slice) } - length := 3 + 3*len(m.certificates) + i; - x = make([]byte, 4+length); - x[0] = typeCertificate; - x[1] = uint8(length >> 16); - x[2] = uint8(length >> 8); - x[3] = uint8(length); + length := 3 + 3*len(m.certificates) + i + x = make([]byte, 4+length) + x[0] = typeCertificate + x[1] = uint8(length >> 16) + x[2] = uint8(length >> 8) + x[3] = uint8(length) - certificateOctets := length - 3; - x[4] = uint8(certificateOctets >> 16); - x[5] = uint8(certificateOctets >> 8); - x[6] = uint8(certificateOctets); + certificateOctets := length - 3 + x[4] = uint8(certificateOctets >> 16) + x[5] = uint8(certificateOctets >> 8) + x[6] = uint8(certificateOctets) - y := x[7:]; + y := x[7:] for _, slice := range m.certificates { - y[0] = uint8(len(slice) >> 16); - y[1] = uint8(len(slice) >> 8); - y[2] = uint8(len(slice)); - copy(y[3:], slice); - y = y[3+len(slice):]; + y[0] = uint8(len(slice) >> 16) + y[1] = uint8(len(slice) >> 8) + y[2] = uint8(len(slice)) + copy(y[3:], slice) + y = y[3+len(slice):] } - m.raw = x; - return; + m.raw = x + return } func (m *certificateMsg) unmarshal(data []byte) bool { @@ -189,44 +189,44 @@ func (m *certificateMsg) unmarshal(data []byte) bool { return false } - m.raw = data; - certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6]); + m.raw = data + certsLen := uint32(data[4])<<16 | uint32(data[5])<<8 | uint32(data[6]) if uint32(len(data)) != certsLen+7 { return false } - numCerts := 0; - d := data[7:]; + numCerts := 0 + d := data[7:] for certsLen > 0 { if len(d) < 4 { return false } - certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]); + certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]) if uint32(len(d)) < 3+certLen { return false } - d = d[3+certLen:]; - certsLen -= 3 + certLen; - numCerts++; + d = d[3+certLen:] + certsLen -= 3 + certLen + numCerts++ } - m.certificates = make([][]byte, numCerts); - d = data[7:]; + m.certificates = make([][]byte, numCerts) + d = data[7:] for i := 0; i < numCerts; i++ { - certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]); - m.certificates[i] = d[3 : 3+certLen]; - d = d[3+certLen:]; + certLen := uint32(d[0])<<24 | uint32(d[1])<<8 | uint32(d[2]) + m.certificates[i] = d[3 : 3+certLen] + d = d[3+certLen:] } - return true; + return true } type serverHelloDoneMsg struct{} func (m *serverHelloDoneMsg) marshal() []byte { - x := make([]byte, 4); - x[0] = typeServerHelloDone; - return x; + x := make([]byte, 4) + x[0] = typeServerHelloDone + return x } func (m *serverHelloDoneMsg) unmarshal(data []byte) bool { @@ -234,44 +234,44 @@ func (m *serverHelloDoneMsg) unmarshal(data []byte) bool { } type clientKeyExchangeMsg struct { - raw []byte; - ciphertext []byte; + raw []byte + ciphertext []byte } func (m *clientKeyExchangeMsg) marshal() []byte { if m.raw != nil { return m.raw } - length := len(m.ciphertext) + 2; - x := make([]byte, length+4); - x[0] = typeClientKeyExchange; - x[1] = uint8(length >> 16); - x[2] = uint8(length >> 8); - x[3] = uint8(length); - x[4] = uint8(len(m.ciphertext) >> 8); - x[5] = uint8(len(m.ciphertext)); - copy(x[6:], m.ciphertext); - - m.raw = x; - return x; + length := len(m.ciphertext) + 2 + x := make([]byte, length+4) + x[0] = typeClientKeyExchange + x[1] = uint8(length >> 16) + x[2] = uint8(length >> 8) + x[3] = uint8(length) + x[4] = uint8(len(m.ciphertext) >> 8) + x[5] = uint8(len(m.ciphertext)) + copy(x[6:], m.ciphertext) + + m.raw = x + return x } func (m *clientKeyExchangeMsg) unmarshal(data []byte) bool { - m.raw = data; + m.raw = data if len(data) < 7 { return false } - cipherTextLen := int(data[4])<<8 | int(data[5]); + cipherTextLen := int(data[4])<<8 | int(data[5]) if len(data) != 6+cipherTextLen { return false } - m.ciphertext = data[6:]; - return true; + m.ciphertext = data[6:] + return true } type finishedMsg struct { - raw []byte; - verifyData []byte; + raw []byte + verifyData []byte } func (m *finishedMsg) marshal() (x []byte) { @@ -279,19 +279,19 @@ func (m *finishedMsg) marshal() (x []byte) { return m.raw } - x = make([]byte, 16); - x[0] = typeFinished; - x[3] = 12; - copy(x[4:], m.verifyData); - m.raw = x; - return; + x = make([]byte, 16) + x[0] = typeFinished + x[3] = 12 + copy(x[4:], m.verifyData) + m.raw = x + return } func (m *finishedMsg) unmarshal(data []byte) bool { - m.raw = data; + m.raw = data if len(data) != 4+12 { return false } - m.verifyData = data[4:]; - return true; + m.verifyData = data[4:] + return true } diff --git a/src/pkg/crypto/tls/handshake_messages_test.go b/src/pkg/crypto/tls/handshake_messages_test.go index c580f65c6..4bfdd6c5f 100644 --- a/src/pkg/crypto/tls/handshake_messages_test.go +++ b/src/pkg/crypto/tls/handshake_messages_test.go @@ -5,10 +5,10 @@ package tls import ( - "rand"; - "reflect"; - "testing"; - "testing/quick"; + "rand" + "reflect" + "testing" + "testing/quick" ) var tests = []interface{}{ @@ -20,41 +20,41 @@ var tests = []interface{}{ } type testMessage interface { - marshal() []byte; - unmarshal([]byte) bool; + marshal() []byte + unmarshal([]byte) bool } func TestMarshalUnmarshal(t *testing.T) { - rand := rand.New(rand.NewSource(0)); + rand := rand.New(rand.NewSource(0)) for i, iface := range tests { - ty := reflect.NewValue(iface).Type(); + ty := reflect.NewValue(iface).Type() for j := 0; j < 100; j++ { - v, ok := quick.Value(ty, rand); + v, ok := quick.Value(ty, rand) if !ok { - t.Errorf("#%d: failed to create value", i); - break; + t.Errorf("#%d: failed to create value", i) + break } - m1 := v.Interface().(testMessage); - marshaled := m1.marshal(); - m2 := iface.(testMessage); + m1 := v.Interface().(testMessage) + marshaled := m1.marshal() + m2 := iface.(testMessage) if !m2.unmarshal(marshaled) { - t.Errorf("#%d failed to unmarshal %#v", i, m1); - break; + t.Errorf("#%d failed to unmarshal %#v", i, m1) + break } - m2.marshal(); // to fill any marshal cache in the message + m2.marshal() // to fill any marshal cache in the message if !reflect.DeepEqual(m1, m2) { - t.Errorf("#%d got:%#v want:%#v", i, m1, m2); - break; + t.Errorf("#%d got:%#v want:%#v", i, m1, m2) + break } // Now check that all prefixes are invalid. for j := 0; j < len(marshaled); j++ { if m2.unmarshal(marshaled[0:j]) { - t.Errorf("#%d unmarshaled a prefix of length %d of %#v", i, j, m1); - break; + t.Errorf("#%d unmarshaled a prefix of length %d of %#v", i, j, m1) + break } } } @@ -62,71 +62,71 @@ func TestMarshalUnmarshal(t *testing.T) { } func TestFuzz(t *testing.T) { - rand := rand.New(rand.NewSource(0)); + rand := rand.New(rand.NewSource(0)) for _, iface := range tests { - m := iface.(testMessage); + m := iface.(testMessage) for j := 0; j < 1000; j++ { - len := rand.Intn(100); - bytes := randomBytes(len, rand); + len := rand.Intn(100) + bytes := randomBytes(len, rand) // This just looks for crashes due to bounds errors etc. - m.unmarshal(bytes); + m.unmarshal(bytes) } } } func randomBytes(n int, rand *rand.Rand) []byte { - r := make([]byte, n); + r := make([]byte, n) for i := 0; i < n; i++ { r[i] = byte(rand.Int31()) } - return r; + return r } func (*clientHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value { - m := &clientHelloMsg{}; - m.major = uint8(rand.Intn(256)); - m.minor = uint8(rand.Intn(256)); - m.random = randomBytes(32, rand); - m.sessionId = randomBytes(rand.Intn(32), rand); - m.cipherSuites = make([]uint16, rand.Intn(63)+1); + m := &clientHelloMsg{} + m.major = uint8(rand.Intn(256)) + m.minor = uint8(rand.Intn(256)) + m.random = randomBytes(32, rand) + m.sessionId = randomBytes(rand.Intn(32), rand) + m.cipherSuites = make([]uint16, rand.Intn(63)+1) for i := 0; i < len(m.cipherSuites); i++ { m.cipherSuites[i] = uint16(rand.Int31()) } - m.compressionMethods = randomBytes(rand.Intn(63)+1, rand); + m.compressionMethods = randomBytes(rand.Intn(63)+1, rand) - return reflect.NewValue(m); + return reflect.NewValue(m) } func (*serverHelloMsg) Generate(rand *rand.Rand, size int) reflect.Value { - m := &serverHelloMsg{}; - m.major = uint8(rand.Intn(256)); - m.minor = uint8(rand.Intn(256)); - m.random = randomBytes(32, rand); - m.sessionId = randomBytes(rand.Intn(32), rand); - m.cipherSuite = uint16(rand.Int31()); - m.compressionMethod = uint8(rand.Intn(256)); - return reflect.NewValue(m); + m := &serverHelloMsg{} + m.major = uint8(rand.Intn(256)) + m.minor = uint8(rand.Intn(256)) + m.random = randomBytes(32, rand) + m.sessionId = randomBytes(rand.Intn(32), rand) + m.cipherSuite = uint16(rand.Int31()) + m.compressionMethod = uint8(rand.Intn(256)) + return reflect.NewValue(m) } func (*certificateMsg) Generate(rand *rand.Rand, size int) reflect.Value { - m := &certificateMsg{}; - numCerts := rand.Intn(20); - m.certificates = make([][]byte, numCerts); + m := &certificateMsg{} + numCerts := rand.Intn(20) + m.certificates = make([][]byte, numCerts) for i := 0; i < numCerts; i++ { m.certificates[i] = randomBytes(rand.Intn(10)+1, rand) } - return reflect.NewValue(m); + return reflect.NewValue(m) } func (*clientKeyExchangeMsg) Generate(rand *rand.Rand, size int) reflect.Value { - m := &clientKeyExchangeMsg{}; - m.ciphertext = randomBytes(rand.Intn(1000)+1, rand); - return reflect.NewValue(m); + m := &clientKeyExchangeMsg{} + m.ciphertext = randomBytes(rand.Intn(1000)+1, rand) + return reflect.NewValue(m) } func (*finishedMsg) Generate(rand *rand.Rand, size int) reflect.Value { - m := &finishedMsg{}; - m.verifyData = randomBytes(12, rand); - return reflect.NewValue(m); + m := &finishedMsg{} + m.verifyData = randomBytes(12, rand) + return reflect.NewValue(m) } diff --git a/src/pkg/crypto/tls/handshake_server.go b/src/pkg/crypto/tls/handshake_server.go index 2e7760365..5314e5cd1 100644 --- a/src/pkg/crypto/tls/handshake_server.go +++ b/src/pkg/crypto/tls/handshake_server.go @@ -13,17 +13,17 @@ package tls // channel in the message (ChangeCipherSpec). import ( - "crypto/hmac"; - "crypto/rc4"; - "crypto/rsa"; - "crypto/sha1"; - "crypto/subtle"; - "io"; + "crypto/hmac" + "crypto/rc4" + "crypto/rsa" + "crypto/sha1" + "crypto/subtle" + "io" ) type cipherSuite struct { - id uint16; // The number of this suite on the wire. - hashLength, cipherKeyLength int; + id uint16 // The number of this suite on the wire. + hashLength, cipherKeyLength int // TODO(agl): need a method to create the cipher and hash interfaces. } @@ -33,118 +33,118 @@ var cipherSuites = []cipherSuite{ // A serverHandshake performs the server side of the TLS 1.1 handshake protocol. type serverHandshake struct { - writeChan chan<- interface{}; - controlChan chan<- interface{}; - msgChan <-chan interface{}; - config *Config; + writeChan chan<- interface{} + controlChan chan<- interface{} + msgChan <-chan interface{} + config *Config } func (h *serverHandshake) loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config) { - h.writeChan = writeChan; - h.controlChan = controlChan; - h.msgChan = msgChan; - h.config = config; + h.writeChan = writeChan + h.controlChan = controlChan + h.msgChan = msgChan + h.config = config - defer close(writeChan); - defer close(controlChan); + defer close(writeChan) + defer close(controlChan) - clientHello, ok := h.readHandshakeMsg().(*clientHelloMsg); + clientHello, ok := h.readHandshakeMsg().(*clientHelloMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - major, minor, ok := mutualVersion(clientHello.major, clientHello.minor); + major, minor, ok := mutualVersion(clientHello.major, clientHello.minor) if !ok { - h.error(alertProtocolVersion); - return; + h.error(alertProtocolVersion) + return } - finishedHash := newFinishedHash(); - finishedHash.Write(clientHello.marshal()); + finishedHash := newFinishedHash() + finishedHash.Write(clientHello.marshal()) - hello := new(serverHelloMsg); + hello := new(serverHelloMsg) // We only support a single ciphersuite so we look for it in the list // of client supported suites. // // TODO(agl): Add additional cipher suites. - var suite *cipherSuite; + var suite *cipherSuite for _, id := range clientHello.cipherSuites { for _, supported := range cipherSuites { if supported.id == id { - suite = &supported; - break; + suite = &supported + break } } } - foundCompression := false; + foundCompression := false // We only support null compression, so check that the client offered it. for _, compression := range clientHello.compressionMethods { if compression == compressionNone { - foundCompression = true; - break; + foundCompression = true + break } } if suite == nil || !foundCompression { - h.error(alertHandshakeFailure); - return; - } - - hello.major = major; - hello.minor = minor; - hello.cipherSuite = suite.id; - currentTime := uint32(config.Time()); - hello.random = make([]byte, 32); - hello.random[0] = byte(currentTime >> 24); - hello.random[1] = byte(currentTime >> 16); - hello.random[2] = byte(currentTime >> 8); - hello.random[3] = byte(currentTime); - _, err := io.ReadFull(config.Rand, hello.random[4:]); + h.error(alertHandshakeFailure) + return + } + + hello.major = major + hello.minor = minor + hello.cipherSuite = suite.id + currentTime := uint32(config.Time()) + hello.random = make([]byte, 32) + hello.random[0] = byte(currentTime >> 24) + hello.random[1] = byte(currentTime >> 16) + hello.random[2] = byte(currentTime >> 8) + hello.random[3] = byte(currentTime) + _, err := io.ReadFull(config.Rand, hello.random[4:]) if err != nil { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - hello.compressionMethod = compressionNone; + hello.compressionMethod = compressionNone - finishedHash.Write(hello.marshal()); - writeChan <- writerSetVersion{major, minor}; - writeChan <- hello; + finishedHash.Write(hello.marshal()) + writeChan <- writerSetVersion{major, minor} + writeChan <- hello if len(config.Certificates) == 0 { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - certMsg := new(certificateMsg); - certMsg.certificates = config.Certificates[0].Certificate; - finishedHash.Write(certMsg.marshal()); - writeChan <- certMsg; + certMsg := new(certificateMsg) + certMsg.certificates = config.Certificates[0].Certificate + finishedHash.Write(certMsg.marshal()) + writeChan <- certMsg - helloDone := new(serverHelloDoneMsg); - finishedHash.Write(helloDone.marshal()); - writeChan <- helloDone; + helloDone := new(serverHelloDoneMsg) + finishedHash.Write(helloDone.marshal()) + writeChan <- helloDone - ckx, ok := h.readHandshakeMsg().(*clientKeyExchangeMsg); + ckx, ok := h.readHandshakeMsg().(*clientKeyExchangeMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - finishedHash.Write(ckx.marshal()); + finishedHash.Write(ckx.marshal()) - preMasterSecret := make([]byte, 48); - _, err = io.ReadFull(config.Rand, preMasterSecret[2:]); + preMasterSecret := make([]byte, 48) + _, err = io.ReadFull(config.Rand, preMasterSecret[2:]) if err != nil { - h.error(alertInternalError); - return; + h.error(alertInternalError) + return } - err = rsa.DecryptPKCS1v15SessionKey(config.Rand, config.Certificates[0].PrivateKey, ckx.ciphertext, preMasterSecret); + err = rsa.DecryptPKCS1v15SessionKey(config.Rand, config.Certificates[0].PrivateKey, ckx.ciphertext, preMasterSecret) if err != nil { - h.error(alertHandshakeFailure); - return; + h.error(alertHandshakeFailure) + return } // We don't check the version number in the premaster secret. For one, // by checking it, we would leak information about the validity of the @@ -154,70 +154,70 @@ func (h *serverHandshake) loop(writeChan chan<- interface{}, controlChan chan<- // 7.4.7.1 of RFC 4346. masterSecret, clientMAC, serverMAC, clientKey, serverKey := - keysFromPreMasterSecret11(preMasterSecret, clientHello.random, hello.random, suite.hashLength, suite.cipherKeyLength); + keysFromPreMasterSecret11(preMasterSecret, clientHello.random, hello.random, suite.hashLength, suite.cipherKeyLength) - _, ok = h.readHandshakeMsg().(changeCipherSpec); + _, ok = h.readHandshakeMsg().(changeCipherSpec) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - cipher, _ := rc4.NewCipher(clientKey); - controlChan <- &newCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)}; + cipher, _ := rc4.NewCipher(clientKey) + controlChan <- &newCipherSpec{cipher, hmac.New(sha1.New(), clientMAC)} - clientFinished, ok := h.readHandshakeMsg().(*finishedMsg); + clientFinished, ok := h.readHandshakeMsg().(*finishedMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } - verify := finishedHash.clientSum(masterSecret); + verify := finishedHash.clientSum(masterSecret) if len(verify) != len(clientFinished.verifyData) || subtle.ConstantTimeCompare(verify, clientFinished.verifyData) != 1 { - h.error(alertHandshakeFailure); - return; + h.error(alertHandshakeFailure) + return } - controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}; + controlChan <- ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0} - finishedHash.Write(clientFinished.marshal()); + finishedHash.Write(clientFinished.marshal()) - cipher2, _ := rc4.NewCipher(serverKey); - writeChan <- writerChangeCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)}; + cipher2, _ := rc4.NewCipher(serverKey) + writeChan <- writerChangeCipherSpec{cipher2, hmac.New(sha1.New(), serverMAC)} - finished := new(finishedMsg); - finished.verifyData = finishedHash.serverSum(masterSecret); - writeChan <- finished; + finished := new(finishedMsg) + finished.verifyData = finishedHash.serverSum(masterSecret) + writeChan <- finished - writeChan <- writerEnableApplicationData{}; + writeChan <- writerEnableApplicationData{} for { - _, ok := h.readHandshakeMsg().(*clientHelloMsg); + _, ok := h.readHandshakeMsg().(*clientHelloMsg) if !ok { - h.error(alertUnexpectedMessage); - return; + h.error(alertUnexpectedMessage) + return } // We reject all renegotication requests. - writeChan <- alert{alertLevelWarning, alertNoRenegotiation}; + writeChan <- alert{alertLevelWarning, alertNoRenegotiation} } } func (h *serverHandshake) readHandshakeMsg() interface{} { - v := <-h.msgChan; + v := <-h.msgChan if closed(h.msgChan) { // If the channel closed then the processor received an error // from the peer and we don't want to echo it back to them. - h.msgChan = nil; - return 0; + h.msgChan = nil + return 0 } if _, ok := v.(alert); ok { // We got an alert from the processor. We forward to the writer // and shutdown. - h.writeChan <- v; - h.msgChan = nil; - return 0; + h.writeChan <- v + h.msgChan = nil + return 0 } - return v; + return v } func (h *serverHandshake) error(e alertType) { @@ -227,9 +227,9 @@ func (h *serverHandshake) error(e alertType) { go func() { for _ = range h.msgChan { } - }(); - h.controlChan <- ConnectionState{false, "", e}; - close(h.controlChan); - h.writeChan <- alert{alertLevelError, e}; + }() + h.controlChan <- ConnectionState{false, "", e} + close(h.controlChan) + h.writeChan <- alert{alertLevelError, e} } } diff --git a/src/pkg/crypto/tls/handshake_server_test.go b/src/pkg/crypto/tls/handshake_server_test.go index 91583d2da..716098530 100644 --- a/src/pkg/crypto/tls/handshake_server_test.go +++ b/src/pkg/crypto/tls/handshake_server_test.go @@ -5,12 +5,12 @@ package tls import ( - "bytes"; - "big"; - "crypto/rsa"; - "os"; - "testing"; - "testing/script"; + "bytes" + "big" + "crypto/rsa" + "os" + "testing" + "testing/script" ) type zeroSource struct{} @@ -20,41 +20,41 @@ func (zeroSource) Read(b []byte) (n int, err os.Error) { b[i] = 0 } - return len(b), nil; + return len(b), nil } var testConfig *Config func init() { - testConfig = new(Config); - testConfig.Time = func() int64 { return 0 }; - testConfig.Rand = zeroSource{}; - testConfig.Certificates = make([]Certificate, 1); - testConfig.Certificates[0].Certificate = [][]byte{testCertificate}; - testConfig.Certificates[0].PrivateKey = testPrivateKey; + testConfig = new(Config) + testConfig.Time = func() int64 { return 0 } + testConfig.Rand = zeroSource{} + testConfig.Certificates = make([]Certificate, 1) + testConfig.Certificates[0].Certificate = [][]byte{testCertificate} + testConfig.Certificates[0].PrivateKey = testPrivateKey } func setupServerHandshake() (writeChan chan interface{}, controlChan chan interface{}, msgChan chan interface{}) { - sh := new(serverHandshake); - writeChan = make(chan interface{}); - controlChan = make(chan interface{}); - msgChan = make(chan interface{}); + sh := new(serverHandshake) + writeChan = make(chan interface{}) + controlChan = make(chan interface{}) + msgChan = make(chan interface{}) - go sh.loop(writeChan, controlChan, msgChan, testConfig); - return; + go sh.loop(writeChan, controlChan, msgChan, testConfig) + return } func testClientHelloFailure(t *testing.T, clientHello interface{}, expectedAlert alertType) { - writeChan, controlChan, msgChan := setupServerHandshake(); - defer close(msgChan); + writeChan, controlChan, msgChan := setupServerHandshake() + defer close(msgChan) - send := script.NewEvent("send", nil, script.Send{msgChan, clientHello}); - recvAlert := script.NewEvent("recv alert", []*script.Event{send}, script.Recv{writeChan, alert{alertLevelError, expectedAlert}}); - close1 := script.NewEvent("msgChan close", []*script.Event{recvAlert}, script.Closed{writeChan}); - recvState := script.NewEvent("recv state", []*script.Event{send}, script.Recv{controlChan, ConnectionState{false, "", expectedAlert}}); - close2 := script.NewEvent("controlChan close", []*script.Event{recvState}, script.Closed{controlChan}); + send := script.NewEvent("send", nil, script.Send{msgChan, clientHello}) + recvAlert := script.NewEvent("recv alert", []*script.Event{send}, script.Recv{writeChan, alert{alertLevelError, expectedAlert}}) + close1 := script.NewEvent("msgChan close", []*script.Event{recvAlert}, script.Closed{writeChan}) + recvState := script.NewEvent("recv state", []*script.Event{send}, script.Recv{controlChan, ConnectionState{false, "", expectedAlert}}) + close2 := script.NewEvent("controlChan close", []*script.Event{recvState}, script.Closed{controlChan}) - err := script.Perform(0, []*script.Event{send, recvAlert, close1, recvState, close2}); + err := script.Perform(0, []*script.Event{send, recvAlert, close1, recvState, close2}) if err != nil { t.Errorf("Got error: %s", err) } @@ -67,125 +67,125 @@ func TestSimpleError(t *testing.T) { var badProtocolVersions = []uint8{0, 0, 0, 5, 1, 0, 1, 5, 2, 0, 2, 5, 3, 0} func TestRejectBadProtocolVersion(t *testing.T) { - clientHello := new(clientHelloMsg); + clientHello := new(clientHelloMsg) for i := 0; i < len(badProtocolVersions); i += 2 { - clientHello.major = badProtocolVersions[i]; - clientHello.minor = badProtocolVersions[i+1]; + clientHello.major = badProtocolVersions[i] + clientHello.minor = badProtocolVersions[i+1] - testClientHelloFailure(t, clientHello, alertProtocolVersion); + testClientHelloFailure(t, clientHello, alertProtocolVersion) } } func TestNoSuiteOverlap(t *testing.T) { - clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{0xff00}, []uint8{0}}; - testClientHelloFailure(t, clientHello, alertHandshakeFailure); + clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{0xff00}, []uint8{0}} + testClientHelloFailure(t, clientHello, alertHandshakeFailure) } func TestNoCompressionOverlap(t *testing.T) { - clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{TLS_RSA_WITH_RC4_128_SHA}, []uint8{0xff}}; - testClientHelloFailure(t, clientHello, alertHandshakeFailure); + clientHello := &clientHelloMsg{nil, 3, 1, nil, nil, []uint16{TLS_RSA_WITH_RC4_128_SHA}, []uint8{0xff}} + testClientHelloFailure(t, clientHello, alertHandshakeFailure) } func matchServerHello(v interface{}) bool { - serverHello, ok := v.(*serverHelloMsg); + serverHello, ok := v.(*serverHelloMsg) if !ok { return false } return serverHello.major == 3 && serverHello.minor == 2 && serverHello.cipherSuite == TLS_RSA_WITH_RC4_128_SHA && - serverHello.compressionMethod == compressionNone; + serverHello.compressionMethod == compressionNone } func TestAlertForwarding(t *testing.T) { - writeChan, controlChan, msgChan := setupServerHandshake(); - defer close(msgChan); + writeChan, controlChan, msgChan := setupServerHandshake() + defer close(msgChan) - a := alert{alertLevelError, alertNoRenegotiation}; - sendAlert := script.NewEvent("send alert", nil, script.Send{msgChan, a}); - recvAlert := script.NewEvent("recv alert", []*script.Event{sendAlert}, script.Recv{writeChan, a}); - closeWriter := script.NewEvent("close writer", []*script.Event{recvAlert}, script.Closed{writeChan}); - closeControl := script.NewEvent("close control", []*script.Event{recvAlert}, script.Closed{controlChan}); + a := alert{alertLevelError, alertNoRenegotiation} + sendAlert := script.NewEvent("send alert", nil, script.Send{msgChan, a}) + recvAlert := script.NewEvent("recv alert", []*script.Event{sendAlert}, script.Recv{writeChan, a}) + closeWriter := script.NewEvent("close writer", []*script.Event{recvAlert}, script.Closed{writeChan}) + closeControl := script.NewEvent("close control", []*script.Event{recvAlert}, script.Closed{controlChan}) - err := script.Perform(0, []*script.Event{sendAlert, recvAlert, closeWriter, closeControl}); + err := script.Perform(0, []*script.Event{sendAlert, recvAlert, closeWriter, closeControl}) if err != nil { t.Errorf("Got error: %s", err) } } func TestClose(t *testing.T) { - writeChan, controlChan, msgChan := setupServerHandshake(); + writeChan, controlChan, msgChan := setupServerHandshake() - close := script.NewEvent("close", nil, script.Close{msgChan}); - closed1 := script.NewEvent("closed1", []*script.Event{close}, script.Closed{writeChan}); - closed2 := script.NewEvent("closed2", []*script.Event{close}, script.Closed{controlChan}); + close := script.NewEvent("close", nil, script.Close{msgChan}) + closed1 := script.NewEvent("closed1", []*script.Event{close}, script.Closed{writeChan}) + closed2 := script.NewEvent("closed2", []*script.Event{close}, script.Closed{controlChan}) - err := script.Perform(0, []*script.Event{close, closed1, closed2}); + err := script.Perform(0, []*script.Event{close, closed1, closed2}) if err != nil { t.Errorf("Got error: %s", err) } } func matchCertificate(v interface{}) bool { - cert, ok := v.(*certificateMsg); + cert, ok := v.(*certificateMsg) if !ok { return false } return len(cert.certificates) == 1 && - bytes.Compare(cert.certificates[0], testCertificate) == 0; + bytes.Compare(cert.certificates[0], testCertificate) == 0 } func matchSetCipher(v interface{}) bool { - _, ok := v.(writerChangeCipherSpec); - return ok; + _, ok := v.(writerChangeCipherSpec) + return ok } func matchDone(v interface{}) bool { - _, ok := v.(*serverHelloDoneMsg); - return ok; + _, ok := v.(*serverHelloDoneMsg) + return ok } func matchFinished(v interface{}) bool { - finished, ok := v.(*finishedMsg); + finished, ok := v.(*finishedMsg) if !ok { return false } - return bytes.Compare(finished.verifyData, fromHex("29122ae11453e631487b02ed")) == 0; + return bytes.Compare(finished.verifyData, fromHex("29122ae11453e631487b02ed")) == 0 } func matchNewCipherSpec(v interface{}) bool { - _, ok := v.(*newCipherSpec); - return ok; + _, ok := v.(*newCipherSpec) + return ok } func TestFullHandshake(t *testing.T) { - writeChan, controlChan, msgChan := setupServerHandshake(); - defer close(msgChan); + writeChan, controlChan, msgChan := setupServerHandshake() + defer close(msgChan) // The values for this test were obtained from running `gnutls-cli --insecure --debug 9` - clientHello := &clientHelloMsg{fromHex("0100007603024aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b310000340033004500390088001600320044003800870013006600900091008f008e002f004100350084000a00050004008c008d008b008a01000019000900030200010000000e000c0000093132372e302e302e31"), 3, 2, fromHex("4aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b31"), nil, []uint16{0x33, 0x45, 0x39, 0x88, 0x16, 0x32, 0x44, 0x38, 0x87, 0x13, 0x66, 0x90, 0x91, 0x8f, 0x8e, 0x2f, 0x41, 0x35, 0x84, 0xa, 0x5, 0x4, 0x8c, 0x8d, 0x8b, 0x8a}, []uint8{0x0}}; + clientHello := &clientHelloMsg{fromHex("0100007603024aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b310000340033004500390088001600320044003800870013006600900091008f008e002f004100350084000a00050004008c008d008b008a01000019000900030200010000000e000c0000093132372e302e302e31"), 3, 2, fromHex("4aef7d77e4686d5dfd9d953dfe280788759ffd440867d687670216da45516b31"), nil, []uint16{0x33, 0x45, 0x39, 0x88, 0x16, 0x32, 0x44, 0x38, 0x87, 0x13, 0x66, 0x90, 0x91, 0x8f, 0x8e, 0x2f, 0x41, 0x35, 0x84, 0xa, 0x5, 0x4, 0x8c, 0x8d, 0x8b, 0x8a}, []uint8{0x0}} - sendHello := script.NewEvent("send hello", nil, script.Send{msgChan, clientHello}); - setVersion := script.NewEvent("set version", []*script.Event{sendHello}, script.Recv{writeChan, writerSetVersion{3, 2}}); - recvHello := script.NewEvent("recv hello", []*script.Event{setVersion}, script.RecvMatch{writeChan, matchServerHello}); - recvCert := script.NewEvent("recv cert", []*script.Event{recvHello}, script.RecvMatch{writeChan, matchCertificate}); - recvDone := script.NewEvent("recv done", []*script.Event{recvCert}, script.RecvMatch{writeChan, matchDone}); + sendHello := script.NewEvent("send hello", nil, script.Send{msgChan, clientHello}) + setVersion := script.NewEvent("set version", []*script.Event{sendHello}, script.Recv{writeChan, writerSetVersion{3, 2}}) + recvHello := script.NewEvent("recv hello", []*script.Event{setVersion}, script.RecvMatch{writeChan, matchServerHello}) + recvCert := script.NewEvent("recv cert", []*script.Event{recvHello}, script.RecvMatch{writeChan, matchCertificate}) + recvDone := script.NewEvent("recv done", []*script.Event{recvCert}, script.RecvMatch{writeChan, matchDone}) - ckx := &clientKeyExchangeMsg{nil, fromHex("872e1fee5f37dd86f3215938ac8de20b302b90074e9fb93097e6b7d1286d0f45abf2daf179deb618bb3c70ed0afee6ee24476ee4649e5a23358143c0f1d9c251")}; - sendCKX := script.NewEvent("send ckx", []*script.Event{recvDone}, script.Send{msgChan, ckx}); + ckx := &clientKeyExchangeMsg{nil, fromHex("872e1fee5f37dd86f3215938ac8de20b302b90074e9fb93097e6b7d1286d0f45abf2daf179deb618bb3c70ed0afee6ee24476ee4649e5a23358143c0f1d9c251")} + sendCKX := script.NewEvent("send ckx", []*script.Event{recvDone}, script.Send{msgChan, ckx}) - sendCCS := script.NewEvent("send ccs", []*script.Event{sendCKX}, script.Send{msgChan, changeCipherSpec{}}); - recvNCS := script.NewEvent("recv done", []*script.Event{sendCCS}, script.RecvMatch{controlChan, matchNewCipherSpec}); + sendCCS := script.NewEvent("send ccs", []*script.Event{sendCKX}, script.Send{msgChan, changeCipherSpec{}}) + recvNCS := script.NewEvent("recv done", []*script.Event{sendCCS}, script.RecvMatch{controlChan, matchNewCipherSpec}) - finished := &finishedMsg{nil, fromHex("c8faca5d242f4423325c5b1a")}; - sendFinished := script.NewEvent("send finished", []*script.Event{recvNCS}, script.Send{msgChan, finished}); - recvFinished := script.NewEvent("recv finished", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchFinished}); - setCipher := script.NewEvent("set cipher", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchSetCipher}); - recvConnectionState := script.NewEvent("recv state", []*script.Event{sendFinished}, script.Recv{controlChan, ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}}); + finished := &finishedMsg{nil, fromHex("c8faca5d242f4423325c5b1a")} + sendFinished := script.NewEvent("send finished", []*script.Event{recvNCS}, script.Send{msgChan, finished}) + recvFinished := script.NewEvent("recv finished", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchFinished}) + setCipher := script.NewEvent("set cipher", []*script.Event{sendFinished}, script.RecvMatch{writeChan, matchSetCipher}) + recvConnectionState := script.NewEvent("recv state", []*script.Event{sendFinished}, script.Recv{controlChan, ConnectionState{true, "TLS_RSA_WITH_RC4_128_SHA", 0}}) - err := script.Perform(0, []*script.Event{sendHello, setVersion, recvHello, recvCert, recvDone, sendCKX, sendCCS, recvNCS, sendFinished, setCipher, recvConnectionState, recvFinished}); + err := script.Perform(0, []*script.Event{sendHello, setVersion, recvHello, recvCert, recvDone, sendCKX, sendCCS, recvNCS, sendFinished, setCipher, recvConnectionState, recvFinished}) if err != nil { t.Errorf("Got error: %s", err) } @@ -194,9 +194,9 @@ func TestFullHandshake(t *testing.T) { var testCertificate = fromHex("3082025930820203a003020102020900c2ec326b95228959300d06092a864886f70d01010505003054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374301e170d3039313032303232323434355a170d3130313032303232323434355a3054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374305c300d06092a864886f70d0101010500034b003048024100b2990f49c47dfa8cd400ae6a4d1b8a3b6a13642b23f28b003bfb97790ade9a4cc82b8b2a81747ddec08b6296e53a08c331687ef25c4bf4936ba1c0e6041e9d150203010001a381b73081b4301d0603551d0e0416041478a06086837c9293a8c9b70c0bdabdb9d77eeedf3081840603551d23047d307b801478a06086837c9293a8c9b70c0bdabdb9d77eeedfa158a4563054310b3009060355040613024155311330110603550408130a536f6d652d53746174653121301f060355040a1318496e7465726e6574205769646769747320507479204c7464310d300b0603550403130474657374820900c2ec326b95228959300c0603551d13040530030101ff300d06092a864886f70d0101050500034100ac23761ae1349d85a439caad4d0b932b09ea96de1917c3e0507c446f4838cb3076fb4d431db8c1987e96f1d7a8a2054dea3a64ec99a3f0eda4d47a163bf1f6ac") func bigFromString(s string) *big.Int { - ret := new(big.Int); - ret.SetString(s, 10); - return ret; + ret := new(big.Int) + ret.SetString(s, 10) + return ret } var testPrivateKey = &rsa.PrivateKey{ diff --git a/src/pkg/crypto/tls/prf.go b/src/pkg/crypto/tls/prf.go index b89b59c29..6b9c44c07 100644 --- a/src/pkg/crypto/tls/prf.go +++ b/src/pkg/crypto/tls/prf.go @@ -5,59 +5,59 @@ package tls import ( - "crypto/hmac"; - "crypto/md5"; - "crypto/sha1"; - "hash"; - "os"; - "strings"; + "crypto/hmac" + "crypto/md5" + "crypto/sha1" + "hash" + "os" + "strings" ) // Split a premaster secret in two as specified in RFC 4346, section 5. func splitPreMasterSecret(secret []byte) (s1, s2 []byte) { - s1 = secret[0 : (len(secret)+1)/2]; - s2 = secret[len(secret)/2:]; - return; + s1 = secret[0 : (len(secret)+1)/2] + s2 = secret[len(secret)/2:] + return } // pHash implements the P_hash function, as defined in RFC 4346, section 5. func pHash(result, secret, seed []byte, hash hash.Hash) { - h := hmac.New(hash, secret); - h.Write(seed); - a := h.Sum(); + h := hmac.New(hash, secret) + h.Write(seed) + a := h.Sum() - j := 0; + j := 0 for j < len(result) { - h.Reset(); - h.Write(a); - h.Write(seed); - b := h.Sum(); - todo := len(b); + h.Reset() + h.Write(a) + h.Write(seed) + b := h.Sum() + todo := len(b) if j+todo > len(result) { todo = len(result) - j } - copy(result[j:j+todo], b); - j += todo; + copy(result[j:j+todo], b) + j += todo - h.Reset(); - h.Write(a); - a = h.Sum(); + h.Reset() + h.Write(a) + a = h.Sum() } } // pRF11 implements the TLS 1.1 pseudo-random function, as defined in RFC 4346, section 5. func pRF11(result, secret, label, seed []byte) { - hashSHA1 := sha1.New(); - hashMD5 := md5.New(); + hashSHA1 := sha1.New() + hashMD5 := md5.New() - labelAndSeed := make([]byte, len(label)+len(seed)); - copy(labelAndSeed, label); - copy(labelAndSeed[len(label):], seed); + labelAndSeed := make([]byte, len(label)+len(seed)) + copy(labelAndSeed, label) + copy(labelAndSeed[len(label):], seed) - s1, s2 := splitPreMasterSecret(secret); - pHash(result, s1, labelAndSeed, hashMD5); - result2 := make([]byte, len(result)); - pHash(result2, s2, labelAndSeed, hashSHA1); + s1, s2 := splitPreMasterSecret(secret) + pHash(result, s1, labelAndSeed, hashMD5) + result2 := make([]byte, len(result)) + pHash(result2, s2, labelAndSeed, hashSHA1) for i, b := range result2 { result[i] ^= b @@ -65,9 +65,9 @@ func pRF11(result, secret, label, seed []byte) { } const ( - tlsRandomLength = 32; // Length of a random nonce in TLS 1.1. - masterSecretLength = 48; // Length of a master secret in TLS 1.1. - finishedVerifyLength = 12; // Length of verify_data in a Finished message. + tlsRandomLength = 32 // Length of a random nonce in TLS 1.1. + masterSecretLength = 48 // Length of a master secret in TLS 1.1. + finishedVerifyLength = 12 // Length of verify_data in a Finished message. ) var masterSecretLabel = strings.Bytes("master secret") @@ -79,32 +79,32 @@ var serverFinishedLabel = strings.Bytes("server finished") // secret, given the lengths of the MAC and cipher keys, as defined in RFC // 4346, section 6.3. func keysFromPreMasterSecret11(preMasterSecret, clientRandom, serverRandom []byte, macLen, keyLen int) (masterSecret, clientMAC, serverMAC, clientKey, serverKey []byte) { - var seed [tlsRandomLength * 2]byte; - copy(seed[0:len(clientRandom)], clientRandom); - copy(seed[len(clientRandom):], serverRandom); - masterSecret = make([]byte, masterSecretLength); - pRF11(masterSecret, preMasterSecret, masterSecretLabel, seed[0:]); - - copy(seed[0:len(clientRandom)], serverRandom); - copy(seed[len(serverRandom):], clientRandom); - - n := 2*macLen + 2*keyLen; - keyMaterial := make([]byte, n); - pRF11(keyMaterial, masterSecret, keyExpansionLabel, seed[0:]); - clientMAC = keyMaterial[0:macLen]; - serverMAC = keyMaterial[macLen : macLen*2]; - clientKey = keyMaterial[macLen*2 : macLen*2+keyLen]; - serverKey = keyMaterial[macLen*2+keyLen:]; - return; + var seed [tlsRandomLength * 2]byte + copy(seed[0:len(clientRandom)], clientRandom) + copy(seed[len(clientRandom):], serverRandom) + masterSecret = make([]byte, masterSecretLength) + pRF11(masterSecret, preMasterSecret, masterSecretLabel, seed[0:]) + + copy(seed[0:len(clientRandom)], serverRandom) + copy(seed[len(serverRandom):], clientRandom) + + n := 2*macLen + 2*keyLen + keyMaterial := make([]byte, n) + pRF11(keyMaterial, masterSecret, keyExpansionLabel, seed[0:]) + clientMAC = keyMaterial[0:macLen] + serverMAC = keyMaterial[macLen : macLen*2] + clientKey = keyMaterial[macLen*2 : macLen*2+keyLen] + serverKey = keyMaterial[macLen*2+keyLen:] + return } // A finishedHash calculates the hash of a set of handshake messages suitable // for including in a Finished message. type finishedHash struct { - clientMD5 hash.Hash; - clientSHA1 hash.Hash; - serverMD5 hash.Hash; - serverSHA1 hash.Hash; + clientMD5 hash.Hash + clientSHA1 hash.Hash + serverMD5 hash.Hash + serverSHA1 hash.Hash } func newFinishedHash() finishedHash { @@ -112,36 +112,36 @@ func newFinishedHash() finishedHash { } func (h finishedHash) Write(msg []byte) (n int, err os.Error) { - h.clientMD5.Write(msg); - h.clientSHA1.Write(msg); - h.serverMD5.Write(msg); - h.serverSHA1.Write(msg); - return len(msg), nil; + h.clientMD5.Write(msg) + h.clientSHA1.Write(msg) + h.serverMD5.Write(msg) + h.serverSHA1.Write(msg) + return len(msg), nil } // finishedSum calculates the contents of the verify_data member of a Finished // message given the MD5 and SHA1 hashes of a set of handshake messages. func finishedSum(md5, sha1, label, masterSecret []byte) []byte { - seed := make([]byte, len(md5)+len(sha1)); - copy(seed, md5); - copy(seed[len(md5):], sha1); - out := make([]byte, finishedVerifyLength); - pRF11(out, masterSecret, label, seed); - return out; + seed := make([]byte, len(md5)+len(sha1)) + copy(seed, md5) + copy(seed[len(md5):], sha1) + out := make([]byte, finishedVerifyLength) + pRF11(out, masterSecret, label, seed) + return out } // clientSum returns the contents of the verify_data member of a client's // Finished message. func (h finishedHash) clientSum(masterSecret []byte) []byte { - md5 := h.clientMD5.Sum(); - sha1 := h.clientSHA1.Sum(); - return finishedSum(md5, sha1, clientFinishedLabel, masterSecret); + md5 := h.clientMD5.Sum() + sha1 := h.clientSHA1.Sum() + return finishedSum(md5, sha1, clientFinishedLabel, masterSecret) } // serverSum returns the contents of the verify_data member of a server's // Finished message. func (h finishedHash) serverSum(masterSecret []byte) []byte { - md5 := h.serverMD5.Sum(); - sha1 := h.serverSHA1.Sum(); - return finishedSum(md5, sha1, serverFinishedLabel, masterSecret); + md5 := h.serverMD5.Sum() + sha1 := h.serverSHA1.Sum() + return finishedSum(md5, sha1, serverFinishedLabel, masterSecret) } diff --git a/src/pkg/crypto/tls/prf_test.go b/src/pkg/crypto/tls/prf_test.go index 0d4a4db35..5c23f368d 100644 --- a/src/pkg/crypto/tls/prf_test.go +++ b/src/pkg/crypto/tls/prf_test.go @@ -5,12 +5,12 @@ package tls import ( - "encoding/hex"; - "testing"; + "encoding/hex" + "testing" ) type testSplitPreMasterSecretTest struct { - in, out1, out2 string; + in, out1, out2 string } var testSplitPreMasterSecretTests = []testSplitPreMasterSecretTest{ @@ -23,10 +23,10 @@ var testSplitPreMasterSecretTests = []testSplitPreMasterSecretTest{ func TestSplitPreMasterSecret(t *testing.T) { for i, test := range testSplitPreMasterSecretTests { - in, _ := hex.DecodeString(test.in); - out1, out2 := splitPreMasterSecret(in); - s1 := hex.EncodeToString(out1); - s2 := hex.EncodeToString(out2); + in, _ := hex.DecodeString(test.in) + out1, out2 := splitPreMasterSecret(in) + s1 := hex.EncodeToString(out1) + s2 := hex.EncodeToString(out2) if s1 != test.out1 || s2 != test.out2 { t.Errorf("#%d: got: (%s, %s) want: (%s, %s)", i, s1, s2, test.out1, test.out2) } @@ -34,25 +34,25 @@ func TestSplitPreMasterSecret(t *testing.T) { } type testKeysFromTest struct { - preMasterSecret string; - clientRandom, serverRandom string; - masterSecret string; - clientMAC, serverMAC string; - clientKey, serverKey string; - macLen, keyLen int; + preMasterSecret string + clientRandom, serverRandom string + masterSecret string + clientMAC, serverMAC string + clientKey, serverKey string + macLen, keyLen int } func TestKeysFromPreMasterSecret(t *testing.T) { for i, test := range testKeysFromTests { - in, _ := hex.DecodeString(test.preMasterSecret); - clientRandom, _ := hex.DecodeString(test.clientRandom); - serverRandom, _ := hex.DecodeString(test.serverRandom); - master, clientMAC, serverMAC, clientKey, serverKey := keysFromPreMasterSecret11(in, clientRandom, serverRandom, test.macLen, test.keyLen); - masterString := hex.EncodeToString(master); - clientMACString := hex.EncodeToString(clientMAC); - serverMACString := hex.EncodeToString(serverMAC); - clientKeyString := hex.EncodeToString(clientKey); - serverKeyString := hex.EncodeToString(serverKey); + in, _ := hex.DecodeString(test.preMasterSecret) + clientRandom, _ := hex.DecodeString(test.clientRandom) + serverRandom, _ := hex.DecodeString(test.serverRandom) + master, clientMAC, serverMAC, clientKey, serverKey := keysFromPreMasterSecret11(in, clientRandom, serverRandom, test.macLen, test.keyLen) + masterString := hex.EncodeToString(master) + clientMACString := hex.EncodeToString(clientMAC) + serverMACString := hex.EncodeToString(serverMAC) + clientKeyString := hex.EncodeToString(clientKey) + serverKeyString := hex.EncodeToString(serverKey) if masterString != test.masterSecret || clientMACString != test.clientMAC || serverMACString != test.serverMAC || diff --git a/src/pkg/crypto/tls/record_process.go b/src/pkg/crypto/tls/record_process.go index e356d67ca..ddeca0e2b 100644 --- a/src/pkg/crypto/tls/record_process.go +++ b/src/pkg/crypto/tls/record_process.go @@ -10,27 +10,27 @@ package tls // state, or for a notification when the state changes. import ( - "container/list"; - "crypto/subtle"; - "hash"; + "container/list" + "crypto/subtle" + "hash" ) // getConnectionState is a request from the application to get the current // ConnectionState. type getConnectionState struct { - reply chan<- ConnectionState; + reply chan<- ConnectionState } // waitConnectionState is a request from the application to be notified when // the connection state changes. type waitConnectionState struct { - reply chan<- ConnectionState; + reply chan<- ConnectionState } // connectionStateChange is a message from the handshake processor that the // connection state has changed. type connectionStateChange struct { - connState ConnectionState; + connState ConnectionState } // changeCipherSpec is a message send to the handshake processor to signal that @@ -40,32 +40,32 @@ type changeCipherSpec struct{} // newCipherSpec is a message from the handshake processor that future // records should be processed with a new cipher and MAC function. type newCipherSpec struct { - encrypt encryptor; - mac hash.Hash; + encrypt encryptor + mac hash.Hash } type recordProcessor struct { - decrypt encryptor; - mac hash.Hash; - seqNum uint64; - handshakeBuf []byte; - appDataChan chan<- []byte; - requestChan <-chan interface{}; - controlChan <-chan interface{}; - recordChan <-chan *record; - handshakeChan chan<- interface{}; + decrypt encryptor + mac hash.Hash + seqNum uint64 + handshakeBuf []byte + appDataChan chan<- []byte + requestChan <-chan interface{} + controlChan <-chan interface{} + recordChan <-chan *record + handshakeChan chan<- interface{} // recordRead is nil when we don't wish to read any more. - recordRead <-chan *record; + recordRead <-chan *record // appDataSend is nil when len(appData) == 0. - appDataSend chan<- []byte; + appDataSend chan<- []byte // appData contains any application data queued for upstream. - appData []byte; + appData []byte // A list of channels waiting for connState to change. - waitQueue *list.List; - connState ConnectionState; - shutdown bool; - header [13]byte; + waitQueue *list.List + connState ConnectionState + shutdown bool + header [13]byte } // drainRequestChannel processes messages from the request channel until it's closed. @@ -84,24 +84,24 @@ func drainRequestChannel(requestChan <-chan interface{}, c ConnectionState) { } func (p *recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan interface{}, controlChan <-chan interface{}, recordChan <-chan *record, handshakeChan chan<- interface{}) { - noop := nop{}; - p.decrypt = noop; - p.mac = noop; - p.waitQueue = list.New(); - - p.appDataChan = appDataChan; - p.requestChan = requestChan; - p.controlChan = controlChan; - p.recordChan = recordChan; - p.handshakeChan = handshakeChan; - p.recordRead = recordChan; + noop := nop{} + p.decrypt = noop + p.mac = noop + p.waitQueue = list.New() + + p.appDataChan = appDataChan + p.requestChan = requestChan + p.controlChan = controlChan + p.recordChan = recordChan + p.handshakeChan = handshakeChan + p.recordRead = recordChan for !p.shutdown { select { case p.appDataSend <- p.appData: - p.appData = nil; - p.appDataSend = nil; - p.recordRead = p.recordChan; + p.appData = nil + p.appDataSend = nil + p.recordRead = p.recordChan case c := <-controlChan: p.processControlMsg(c) case r := <-requestChan: @@ -111,24 +111,24 @@ func (p *recordProcessor) loop(appDataChan chan<- []byte, requestChan <-chan int } } - p.wakeWaiters(); - go drainRequestChannel(p.requestChan, p.connState); + p.wakeWaiters() + go drainRequestChannel(p.requestChan, p.connState) go func() { for _ = range controlChan { } - }(); + }() - close(handshakeChan); + close(handshakeChan) if len(p.appData) > 0 { appDataChan <- p.appData } - close(appDataChan); + close(appDataChan) } func (p *recordProcessor) processRequestMsg(requestMsg interface{}) { if closed(p.requestChan) { - p.shutdown = true; - return; + p.shutdown = true + return } switch r := requestMsg.(type) { @@ -138,51 +138,51 @@ func (p *recordProcessor) processRequestMsg(requestMsg interface{}) { if p.connState.HandshakeComplete { r.reply <- p.connState } - p.waitQueue.PushBack(r.reply); + p.waitQueue.PushBack(r.reply) } } func (p *recordProcessor) processControlMsg(msg interface{}) { - connState, ok := msg.(ConnectionState); + connState, ok := msg.(ConnectionState) if !ok || closed(p.controlChan) { - p.shutdown = true; - return; + p.shutdown = true + return } - p.connState = connState; - p.wakeWaiters(); + p.connState = connState + p.wakeWaiters() } func (p *recordProcessor) wakeWaiters() { for i := p.waitQueue.Front(); i != nil; i = i.Next() { i.Value.(chan<- ConnectionState) <- p.connState } - p.waitQueue.Init(); + p.waitQueue.Init() } func (p *recordProcessor) processRecord(r *record) { if closed(p.recordChan) { - p.shutdown = true; - return; + p.shutdown = true + return } - p.decrypt.XORKeyStream(r.payload); + p.decrypt.XORKeyStream(r.payload) if len(r.payload) < p.mac.Size() { - p.error(alertBadRecordMAC); - return; + p.error(alertBadRecordMAC) + return } - fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r); - p.seqNum++; + fillMACHeader(&p.header, p.seqNum, len(r.payload)-p.mac.Size(), r) + p.seqNum++ - p.mac.Reset(); - p.mac.Write(p.header[0:13]); - p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()]); - macBytes := p.mac.Sum(); + p.mac.Reset() + p.mac.Write(p.header[0:13]) + p.mac.Write(r.payload[0 : len(r.payload)-p.mac.Size()]) + macBytes := p.mac.Sum() if subtle.ConstantTimeCompare(macBytes, r.payload[len(r.payload)-p.mac.Size():]) != 1 { - p.error(alertBadRecordMAC); - return; + p.error(alertBadRecordMAC) + return } switch r.contentType { @@ -190,31 +190,31 @@ func (p *recordProcessor) processRecord(r *record) { p.processHandshakeRecord(r.payload[0 : len(r.payload)-p.mac.Size()]) case recordTypeChangeCipherSpec: if len(r.payload) != 1 || r.payload[0] != 1 { - p.error(alertUnexpectedMessage); - return; + p.error(alertUnexpectedMessage) + return } - p.handshakeChan <- changeCipherSpec{}; - newSpec, ok := (<-p.controlChan).(*newCipherSpec); + p.handshakeChan <- changeCipherSpec{} + newSpec, ok := (<-p.controlChan).(*newCipherSpec) if !ok { - p.connState.Error = alertUnexpectedMessage; - p.shutdown = true; - return; + p.connState.Error = alertUnexpectedMessage + p.shutdown = true + return } - p.decrypt = newSpec.encrypt; - p.mac = newSpec.mac; - p.seqNum = 0; + p.decrypt = newSpec.encrypt + p.mac = newSpec.mac + p.seqNum = 0 case recordTypeApplicationData: if p.connState.HandshakeComplete == false { - p.error(alertUnexpectedMessage); - return; + p.error(alertUnexpectedMessage) + return } - p.recordRead = nil; - p.appData = r.payload[0 : len(r.payload)-p.mac.Size()]; - p.appDataSend = p.appDataChan; + p.recordRead = nil + p.appData = r.payload[0 : len(r.payload)-p.mac.Size()] + p.appDataSend = p.appDataChan default: - p.error(alertUnexpectedMessage); - return; + p.error(alertUnexpectedMessage) + return } } @@ -223,61 +223,61 @@ func (p *recordProcessor) processHandshakeRecord(data []byte) { p.handshakeBuf = data } else { if len(p.handshakeBuf) > maxHandshakeMsg { - p.error(alertInternalError); - return; + p.error(alertInternalError) + return } - newBuf := make([]byte, len(p.handshakeBuf)+len(data)); - copy(newBuf, p.handshakeBuf); - copy(newBuf[len(p.handshakeBuf):], data); - p.handshakeBuf = newBuf; + newBuf := make([]byte, len(p.handshakeBuf)+len(data)) + copy(newBuf, p.handshakeBuf) + copy(newBuf[len(p.handshakeBuf):], data) + p.handshakeBuf = newBuf } for len(p.handshakeBuf) >= 4 { handshakeLen := int(p.handshakeBuf[1])<<16 | int(p.handshakeBuf[2])<<8 | - int(p.handshakeBuf[3]); + int(p.handshakeBuf[3]) if handshakeLen+4 > len(p.handshakeBuf) { break } - bytes := p.handshakeBuf[0 : handshakeLen+4]; - p.handshakeBuf = p.handshakeBuf[handshakeLen+4:]; + bytes := p.handshakeBuf[0 : handshakeLen+4] + p.handshakeBuf = p.handshakeBuf[handshakeLen+4:] if bytes[0] == typeFinished { // Special case because Finished is synchronous: the // handshake handler has to tell us if it's ok to start // forwarding application data. - m := new(finishedMsg); + m := new(finishedMsg) if !m.unmarshal(bytes) { p.error(alertUnexpectedMessage) } - p.handshakeChan <- m; - var ok bool; - p.connState, ok = (<-p.controlChan).(ConnectionState); + p.handshakeChan <- m + var ok bool + p.connState, ok = (<-p.controlChan).(ConnectionState) if !ok || p.connState.Error != 0 { - p.shutdown = true; - return; + p.shutdown = true + return } } else { - msg, ok := parseHandshakeMsg(bytes); + msg, ok := parseHandshakeMsg(bytes) if !ok { - p.error(alertUnexpectedMessage); - return; + p.error(alertUnexpectedMessage) + return } - p.handshakeChan <- msg; + p.handshakeChan <- msg } } } func (p *recordProcessor) error(err alertType) { - close(p.handshakeChan); - p.connState.Error = err; - p.wakeWaiters(); - p.shutdown = true; + close(p.handshakeChan) + p.connState.Error = err + p.wakeWaiters() + p.shutdown = true } func parseHandshakeMsg(data []byte) (interface{}, bool) { var m interface { - unmarshal([]byte) bool; + unmarshal([]byte) bool } switch data[0] { @@ -295,6 +295,6 @@ func parseHandshakeMsg(data []byte) (interface{}, bool) { return nil, false } - ok := m.unmarshal(data); - return m, ok; + ok := m.unmarshal(data) + return m, ok } diff --git a/src/pkg/crypto/tls/record_process_test.go b/src/pkg/crypto/tls/record_process_test.go index 1d019e30d..65ce3eba9 100644 --- a/src/pkg/crypto/tls/record_process_test.go +++ b/src/pkg/crypto/tls/record_process_test.go @@ -5,132 +5,132 @@ package tls import ( - "encoding/hex"; - "testing"; - "testing/script"; + "encoding/hex" + "testing" + "testing/script" ) func setup() (appDataChan chan []byte, requestChan chan interface{}, controlChan chan interface{}, recordChan chan *record, handshakeChan chan interface{}) { - rp := new(recordProcessor); - appDataChan = make(chan []byte); - requestChan = make(chan interface{}); - controlChan = make(chan interface{}); - recordChan = make(chan *record); - handshakeChan = make(chan interface{}); - - go rp.loop(appDataChan, requestChan, controlChan, recordChan, handshakeChan); - return; + rp := new(recordProcessor) + appDataChan = make(chan []byte) + requestChan = make(chan interface{}) + controlChan = make(chan interface{}) + recordChan = make(chan *record) + handshakeChan = make(chan interface{}) + + go rp.loop(appDataChan, requestChan, controlChan, recordChan, handshakeChan) + return } func fromHex(s string) []byte { - b, _ := hex.DecodeString(s); - return b; + b, _ := hex.DecodeString(s) + return b } func TestNullConnectionState(t *testing.T) { - _, requestChan, controlChan, recordChan, _ := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); + _, requestChan, controlChan, recordChan, _ := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) // Test a simple request for the connection state. - replyChan := make(chan ConnectionState); - sendReq := script.NewEvent("send request", nil, script.Send{requestChan, getConnectionState{replyChan}}); - getReply := script.NewEvent("get reply", []*script.Event{sendReq}, script.Recv{replyChan, ConnectionState{false, "", 0}}); + replyChan := make(chan ConnectionState) + sendReq := script.NewEvent("send request", nil, script.Send{requestChan, getConnectionState{replyChan}}) + getReply := script.NewEvent("get reply", []*script.Event{sendReq}, script.Recv{replyChan, ConnectionState{false, "", 0}}) - err := script.Perform(0, []*script.Event{sendReq, getReply}); + err := script.Perform(0, []*script.Event{sendReq, getReply}) if err != nil { t.Errorf("Got error: %s", err) } } func TestWaitConnectionState(t *testing.T) { - _, requestChan, controlChan, recordChan, _ := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); + _, requestChan, controlChan, recordChan, _ := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) // Test that waitConnectionState doesn't get a reply until the connection state changes. - replyChan := make(chan ConnectionState); - sendReq := script.NewEvent("send request", nil, script.Send{requestChan, waitConnectionState{replyChan}}); - replyChan2 := make(chan ConnectionState); - sendReq2 := script.NewEvent("send request 2", []*script.Event{sendReq}, script.Send{requestChan, getConnectionState{replyChan2}}); - getReply2 := script.NewEvent("get reply 2", []*script.Event{sendReq2}, script.Recv{replyChan2, ConnectionState{false, "", 0}}); - sendState := script.NewEvent("send state", []*script.Event{getReply2}, script.Send{controlChan, ConnectionState{true, "test", 1}}); - getReply := script.NewEvent("get reply", []*script.Event{sendState}, script.Recv{replyChan, ConnectionState{true, "test", 1}}); - - err := script.Perform(0, []*script.Event{sendReq, sendReq2, getReply2, sendState, getReply}); + replyChan := make(chan ConnectionState) + sendReq := script.NewEvent("send request", nil, script.Send{requestChan, waitConnectionState{replyChan}}) + replyChan2 := make(chan ConnectionState) + sendReq2 := script.NewEvent("send request 2", []*script.Event{sendReq}, script.Send{requestChan, getConnectionState{replyChan2}}) + getReply2 := script.NewEvent("get reply 2", []*script.Event{sendReq2}, script.Recv{replyChan2, ConnectionState{false, "", 0}}) + sendState := script.NewEvent("send state", []*script.Event{getReply2}, script.Send{controlChan, ConnectionState{true, "test", 1}}) + getReply := script.NewEvent("get reply", []*script.Event{sendState}, script.Recv{replyChan, ConnectionState{true, "test", 1}}) + + err := script.Perform(0, []*script.Event{sendReq, sendReq2, getReply2, sendState, getReply}) if err != nil { t.Errorf("Got error: %s", err) } } func TestHandshakeAssembly(t *testing.T) { - _, requestChan, controlChan, recordChan, handshakeChan := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); + _, requestChan, controlChan, recordChan, handshakeChan := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) // Test the reassembly of a fragmented handshake message. - send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("10000003")}}); - send2 := script.NewEvent("send 2", []*script.Event{send1}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("0001")}}); - send3 := script.NewEvent("send 3", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("42")}}); - recvMsg := script.NewEvent("recv", []*script.Event{send3}, script.Recv{handshakeChan, &clientKeyExchangeMsg{fromHex("10000003000142"), fromHex("42")}}); + send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("10000003")}}) + send2 := script.NewEvent("send 2", []*script.Event{send1}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("0001")}}) + send3 := script.NewEvent("send 3", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("42")}}) + recvMsg := script.NewEvent("recv", []*script.Event{send3}, script.Recv{handshakeChan, &clientKeyExchangeMsg{fromHex("10000003000142"), fromHex("42")}}) - err := script.Perform(0, []*script.Event{send1, send2, send3, recvMsg}); + err := script.Perform(0, []*script.Event{send1, send2, send3, recvMsg}) if err != nil { t.Errorf("Got error: %s", err) } } func TestEarlyApplicationData(t *testing.T) { - _, requestChan, controlChan, recordChan, handshakeChan := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); + _, requestChan, controlChan, recordChan, handshakeChan := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) // Test that applicaton data received before the handshake has completed results in an error. - send := script.NewEvent("send", nil, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("")}}); - recv := script.NewEvent("recv", []*script.Event{send}, script.Closed{handshakeChan}); + send := script.NewEvent("send", nil, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("")}}) + recv := script.NewEvent("recv", []*script.Event{send}, script.Closed{handshakeChan}) - err := script.Perform(0, []*script.Event{send, recv}); + err := script.Perform(0, []*script.Event{send, recv}) if err != nil { t.Errorf("Got error: %s", err) } } func TestApplicationData(t *testing.T) { - appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); + appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) // Test that the application data is forwarded after a successful Finished message. - send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("1400000c000000000000000000000000")}}); - recv1 := script.NewEvent("recv finished", []*script.Event{send1}, script.Recv{handshakeChan, &finishedMsg{fromHex("1400000c000000000000000000000000"), fromHex("000000000000000000000000")}}); - send2 := script.NewEvent("send connState", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{true, "", 0}}); - send3 := script.NewEvent("send 2", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("0102")}}); - recv2 := script.NewEvent("recv data", []*script.Event{send3}, script.Recv{appDataChan, []byte{0x01, 0x02}}); + send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeHandshake, 0, 0, fromHex("1400000c000000000000000000000000")}}) + recv1 := script.NewEvent("recv finished", []*script.Event{send1}, script.Recv{handshakeChan, &finishedMsg{fromHex("1400000c000000000000000000000000"), fromHex("000000000000000000000000")}}) + send2 := script.NewEvent("send connState", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{true, "", 0}}) + send3 := script.NewEvent("send 2", []*script.Event{send2}, script.Send{recordChan, &record{recordTypeApplicationData, 0, 0, fromHex("0102")}}) + recv2 := script.NewEvent("recv data", []*script.Event{send3}, script.Recv{appDataChan, []byte{0x01, 0x02}}) - err := script.Perform(0, []*script.Event{send1, recv1, send2, send3, recv2}); + err := script.Perform(0, []*script.Event{send1, recv1, send2, send3, recv2}) if err != nil { t.Errorf("Got error: %s", err) } } func TestInvalidChangeCipherSpec(t *testing.T) { - appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup(); - defer close(requestChan); - defer close(controlChan); - defer close(recordChan); - - send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeChangeCipherSpec, 0, 0, []byte{1}}}); - recv1 := script.NewEvent("recv 1", []*script.Event{send1}, script.Recv{handshakeChan, changeCipherSpec{}}); - send2 := script.NewEvent("send 2", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{false, "", 42}}); - close := script.NewEvent("close 1", []*script.Event{send2}, script.Closed{appDataChan}); - close2 := script.NewEvent("close 2", []*script.Event{send2}, script.Closed{handshakeChan}); - - err := script.Perform(0, []*script.Event{send1, recv1, send2, close, close2}); + appDataChan, requestChan, controlChan, recordChan, handshakeChan := setup() + defer close(requestChan) + defer close(controlChan) + defer close(recordChan) + + send1 := script.NewEvent("send 1", nil, script.Send{recordChan, &record{recordTypeChangeCipherSpec, 0, 0, []byte{1}}}) + recv1 := script.NewEvent("recv 1", []*script.Event{send1}, script.Recv{handshakeChan, changeCipherSpec{}}) + send2 := script.NewEvent("send 2", []*script.Event{recv1}, script.Send{controlChan, ConnectionState{false, "", 42}}) + close := script.NewEvent("close 1", []*script.Event{send2}, script.Closed{appDataChan}) + close2 := script.NewEvent("close 2", []*script.Event{send2}, script.Closed{handshakeChan}) + + err := script.Perform(0, []*script.Event{send1, recv1, send2, close, close2}) if err != nil { t.Errorf("Got error: %s", err) } diff --git a/src/pkg/crypto/tls/record_read.go b/src/pkg/crypto/tls/record_read.go index 518a1361b..0ddd884a4 100644 --- a/src/pkg/crypto/tls/record_read.go +++ b/src/pkg/crypto/tls/record_read.go @@ -9,34 +9,34 @@ package tls // it's outbound channel. On error, it closes its outbound channel. import ( - "io"; - "bufio"; + "io" + "bufio" ) // recordReader loops, reading TLS records from source and writing them to the // given channel. The channel is closed on EOF or on error. func recordReader(c chan<- *record, source io.Reader) { - defer close(c); - buf := bufio.NewReader(source); + defer close(c) + buf := bufio.NewReader(source) for { - var header [5]byte; - n, _ := buf.Read(header[0:]); + var header [5]byte + n, _ := buf.Read(header[0:]) if n != 5 { return } - recordLength := int(header[3])<<8 | int(header[4]); + recordLength := int(header[3])<<8 | int(header[4]) if recordLength > maxTLSCiphertext { return } - payload := make([]byte, recordLength); - n, _ = buf.Read(payload); + payload := make([]byte, recordLength) + n, _ = buf.Read(payload) if n != recordLength { return } - c <- &record{recordType(header[0]), header[1], header[2], payload}; + c <- &record{recordType(header[0]), header[1], header[2], payload} } } diff --git a/src/pkg/crypto/tls/record_read_test.go b/src/pkg/crypto/tls/record_read_test.go index ce1a8e6b4..f897599ad 100644 --- a/src/pkg/crypto/tls/record_read_test.go +++ b/src/pkg/crypto/tls/record_read_test.go @@ -5,9 +5,9 @@ package tls import ( - "bytes"; - "testing"; - "testing/iotest"; + "bytes" + "testing" + "testing/iotest" ) func matchRecord(r1, r2 *record) bool { @@ -20,12 +20,12 @@ func matchRecord(r1, r2 *record) bool { return r1.contentType == r2.contentType && r1.major == r2.major && r1.minor == r2.minor && - bytes.Compare(r1.payload, r2.payload) == 0; + bytes.Compare(r1.payload, r2.payload) == 0 } type recordReaderTest struct { - in []byte; - out []*record; + in []byte + out []*record } var recordReaderTests = []recordReaderTest{ @@ -42,31 +42,31 @@ var recordReaderTests = []recordReaderTest{ func TestRecordReader(t *testing.T) { for i, test := range recordReaderTests { - buf := bytes.NewBuffer(test.in); - c := make(chan *record); - go recordReader(c, buf); - matchRecordReaderOutput(t, i, test, c); + buf := bytes.NewBuffer(test.in) + c := make(chan *record) + go recordReader(c, buf) + matchRecordReaderOutput(t, i, test, c) - buf = bytes.NewBuffer(test.in); - buf2 := iotest.OneByteReader(buf); - c = make(chan *record); - go recordReader(c, buf2); - matchRecordReaderOutput(t, i*2, test, c); + buf = bytes.NewBuffer(test.in) + buf2 := iotest.OneByteReader(buf) + c = make(chan *record) + go recordReader(c, buf2) + matchRecordReaderOutput(t, i*2, test, c) } } func matchRecordReaderOutput(t *testing.T, i int, test recordReaderTest, c <-chan *record) { for j, r1 := range test.out { - r2 := <-c; + r2 := <-c if r2 == nil { - t.Errorf("#%d truncated after %d values", i, j); - break; + t.Errorf("#%d truncated after %d values", i, j) + break } if !matchRecord(r1, r2) { t.Errorf("#%d (%d) got:%#v want:%#v", i, j, r2, r1) } } - <-c; + <-c if !closed(c) { t.Errorf("#%d: channel didn't close", i) } diff --git a/src/pkg/crypto/tls/record_write.go b/src/pkg/crypto/tls/record_write.go index f55a214c3..5f3fb5b16 100644 --- a/src/pkg/crypto/tls/record_write.go +++ b/src/pkg/crypto/tls/record_write.go @@ -5,9 +5,9 @@ package tls import ( - "fmt"; - "hash"; - "io"; + "fmt" + "hash" + "io" ) // writerEnableApplicationData is a message which instructs recordWriter to @@ -17,14 +17,14 @@ type writerEnableApplicationData struct{} // writerChangeCipherSpec updates the encryption and MAC functions and resets // the sequence count. type writerChangeCipherSpec struct { - encryptor encryptor; - mac hash.Hash; + encryptor encryptor + mac hash.Hash } // writerSetVersion sets the version number bytes that we included in the // record header for future records. type writerSetVersion struct { - major, minor uint8; + major, minor uint8 } // A recordWriter accepts messages from the handshake processor and @@ -32,37 +32,37 @@ type writerSetVersion struct { // writing. It doesn't read from the application data channel until the // handshake processor has signaled that the handshake is complete. type recordWriter struct { - writer io.Writer; - encryptor encryptor; - mac hash.Hash; - seqNum uint64; - major, minor uint8; - shutdown bool; - appChan <-chan []byte; - controlChan <-chan interface{}; - header [13]byte; + writer io.Writer + encryptor encryptor + mac hash.Hash + seqNum uint64 + major, minor uint8 + shutdown bool + appChan <-chan []byte + controlChan <-chan interface{} + header [13]byte } func (w *recordWriter) loop(writer io.Writer, appChan <-chan []byte, controlChan <-chan interface{}) { - w.writer = writer; - w.encryptor = nop{}; - w.mac = nop{}; - w.appChan = appChan; - w.controlChan = controlChan; + w.writer = writer + w.encryptor = nop{} + w.mac = nop{} + w.appChan = appChan + w.controlChan = controlChan for !w.shutdown { - msg := <-controlChan; + msg := <-controlChan if _, ok := msg.(writerEnableApplicationData); ok { break } - w.processControlMessage(msg); + w.processControlMessage(msg) } for !w.shutdown { // Always process control messages first. if controlMsg, ok := <-controlChan; ok { - w.processControlMessage(controlMsg); - continue; + w.processControlMessage(controlMsg) + continue } select { @@ -89,58 +89,58 @@ func (w *recordWriter) loop(writer io.Writer, appChan <-chan []byte, controlChan // fillMACHeader generates a MAC header. See RFC 4346, section 6.2.3.1. func fillMACHeader(header *[13]byte, seqNum uint64, length int, r *record) { - header[0] = uint8(seqNum >> 56); - header[1] = uint8(seqNum >> 48); - header[2] = uint8(seqNum >> 40); - header[3] = uint8(seqNum >> 32); - header[4] = uint8(seqNum >> 24); - header[5] = uint8(seqNum >> 16); - header[6] = uint8(seqNum >> 8); - header[7] = uint8(seqNum); - header[8] = uint8(r.contentType); - header[9] = r.major; - header[10] = r.minor; - header[11] = uint8(length >> 8); - header[12] = uint8(length); + header[0] = uint8(seqNum >> 56) + header[1] = uint8(seqNum >> 48) + header[2] = uint8(seqNum >> 40) + header[3] = uint8(seqNum >> 32) + header[4] = uint8(seqNum >> 24) + header[5] = uint8(seqNum >> 16) + header[6] = uint8(seqNum >> 8) + header[7] = uint8(seqNum) + header[8] = uint8(r.contentType) + header[9] = r.major + header[10] = r.minor + header[11] = uint8(length >> 8) + header[12] = uint8(length) } func (w *recordWriter) writeRecord(r *record) { - w.mac.Reset(); + w.mac.Reset() - fillMACHeader(&w.header, w.seqNum, len(r.payload), r); + fillMACHeader(&w.header, w.seqNum, len(r.payload), r) - w.mac.Write(w.header[0:13]); - w.mac.Write(r.payload); - macBytes := w.mac.Sum(); + w.mac.Write(w.header[0:13]) + w.mac.Write(r.payload) + macBytes := w.mac.Sum() - w.encryptor.XORKeyStream(r.payload); - w.encryptor.XORKeyStream(macBytes); + w.encryptor.XORKeyStream(r.payload) + w.encryptor.XORKeyStream(macBytes) - length := len(r.payload) + len(macBytes); - w.header[11] = uint8(length >> 8); - w.header[12] = uint8(length); - w.writer.Write(w.header[8:13]); - w.writer.Write(r.payload); - w.writer.Write(macBytes); + length := len(r.payload) + len(macBytes) + w.header[11] = uint8(length >> 8) + w.header[12] = uint8(length) + w.writer.Write(w.header[8:13]) + w.writer.Write(r.payload) + w.writer.Write(macBytes) - w.seqNum++; + w.seqNum++ } func (w *recordWriter) processControlMessage(controlMsg interface{}) { if controlMsg == nil { - w.shutdown = true; - return; + w.shutdown = true + return } switch msg := controlMsg.(type) { case writerChangeCipherSpec: - w.writeRecord(&record{recordTypeChangeCipherSpec, w.major, w.minor, []byte{0x01}}); - w.encryptor = msg.encryptor; - w.mac = msg.mac; - w.seqNum = 0; + w.writeRecord(&record{recordTypeChangeCipherSpec, w.major, w.minor, []byte{0x01}}) + w.encryptor = msg.encryptor + w.mac = msg.mac + w.seqNum = 0 case writerSetVersion: - w.major = msg.major; - w.minor = msg.minor; + w.major = msg.major + w.minor = msg.minor case alert: w.writeRecord(&record{recordTypeAlert, w.major, w.minor, []byte{byte(msg.level), byte(msg.error)}}) case handshakeMessage: @@ -153,18 +153,18 @@ func (w *recordWriter) processControlMessage(controlMsg interface{}) { func (w *recordWriter) processAppMessage(appMsg []byte) { if closed(w.appChan) { - w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, []byte{byte(alertCloseNotify)}}); - w.shutdown = true; - return; + w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, []byte{byte(alertCloseNotify)}}) + w.shutdown = true + return } - var done int; + var done int for done < len(appMsg) { - todo := len(appMsg); + todo := len(appMsg) if todo > maxTLSPlaintext { todo = maxTLSPlaintext } - w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, appMsg[done : done+todo]}); - done += todo; + w.writeRecord(&record{recordTypeApplicationData, w.major, w.minor, appMsg[done : done+todo]}) + done += todo } } diff --git a/src/pkg/crypto/tls/tls.go b/src/pkg/crypto/tls/tls.go index c5a0f69d5..29d918e4b 100644 --- a/src/pkg/crypto/tls/tls.go +++ b/src/pkg/crypto/tls/tls.go @@ -6,26 +6,26 @@ package tls import ( - "io"; - "os"; - "net"; - "time"; + "io" + "os" + "net" + "time" ) // A Conn represents a secure connection. type Conn struct { - net.Conn; - writeChan chan<- []byte; - readChan <-chan []byte; - requestChan chan<- interface{}; - readBuf []byte; - eof bool; - readTimeout, writeTimeout int64; + net.Conn + writeChan chan<- []byte + readChan <-chan []byte + requestChan chan<- interface{} + readBuf []byte + eof bool + readTimeout, writeTimeout int64 } func timeout(c chan<- bool, nsecs int64) { - time.Sleep(nsecs); - c <- true; + time.Sleep(nsecs) + c <- true } func (tls *Conn) Read(p []byte) (int, os.Error) { @@ -34,10 +34,10 @@ func (tls *Conn) Read(p []byte) (int, os.Error) { return 0, os.EOF } - var timeoutChan chan bool; + var timeoutChan chan bool if tls.readTimeout > 0 { - timeoutChan = make(chan bool); - go timeout(timeoutChan, tls.readTimeout); + timeoutChan = make(chan bool) + go timeout(timeoutChan, tls.readTimeout) } select { @@ -53,14 +53,14 @@ func (tls *Conn) Read(p []byte) (int, os.Error) { return 0, io.ErrUnexpectedEOF } if len(tls.readBuf) == 0 { - tls.eof = true; - return 0, os.EOF; + tls.eof = true + return 0, os.EOF } } - n := copy(p, tls.readBuf); - tls.readBuf = tls.readBuf[n:]; - return n, nil; + n := copy(p, tls.readBuf) + tls.readBuf = tls.readBuf[n:] + return n, nil } func (tls *Conn) Write(p []byte) (int, os.Error) { @@ -68,10 +68,10 @@ func (tls *Conn) Write(p []byte) (int, os.Error) { return 0, os.EOF } - var timeoutChan chan bool; + var timeoutChan chan bool if tls.writeTimeout > 0 { - timeoutChan = make(chan bool); - go timeout(timeoutChan, tls.writeTimeout); + timeoutChan = make(chan bool) + go timeout(timeoutChan, tls.writeTimeout) } select { @@ -80,73 +80,73 @@ func (tls *Conn) Write(p []byte) (int, os.Error) { return 0, os.EAGAIN } - return len(p), nil; + return len(p), nil } func (tls *Conn) Close() os.Error { - close(tls.writeChan); - close(tls.requestChan); - tls.eof = true; - return nil; + close(tls.writeChan) + close(tls.requestChan) + tls.eof = true + return nil } func (tls *Conn) SetTimeout(nsec int64) os.Error { - tls.readTimeout = nsec; - tls.writeTimeout = nsec; - return nil; + tls.readTimeout = nsec + tls.writeTimeout = nsec + return nil } func (tls *Conn) SetReadTimeout(nsec int64) os.Error { - tls.readTimeout = nsec; - return nil; + tls.readTimeout = nsec + return nil } func (tls *Conn) SetWriteTimeout(nsec int64) os.Error { - tls.writeTimeout = nsec; - return nil; + tls.writeTimeout = nsec + return nil } func (tls *Conn) GetConnectionState() ConnectionState { - replyChan := make(chan ConnectionState); - tls.requestChan <- getConnectionState{replyChan}; - return <-replyChan; + replyChan := make(chan ConnectionState) + tls.requestChan <- getConnectionState{replyChan} + return <-replyChan } func (tls *Conn) WaitConnectionState() ConnectionState { - replyChan := make(chan ConnectionState); - tls.requestChan <- waitConnectionState{replyChan}; - return <-replyChan; + replyChan := make(chan ConnectionState) + tls.requestChan <- waitConnectionState{replyChan} + return <-replyChan } type handshaker interface { - loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config); + loop(writeChan chan<- interface{}, controlChan chan<- interface{}, msgChan <-chan interface{}, config *Config) } // Server establishes a secure connection over the given connection and acts // as a TLS server. func startTLSGoroutines(conn net.Conn, h handshaker, config *Config) *Conn { - tls := new(Conn); - tls.Conn = conn; + tls := new(Conn) + tls.Conn = conn - writeChan := make(chan []byte); - readChan := make(chan []byte); - requestChan := make(chan interface{}); + writeChan := make(chan []byte) + readChan := make(chan []byte) + requestChan := make(chan interface{}) - tls.writeChan = writeChan; - tls.readChan = readChan; - tls.requestChan = requestChan; + tls.writeChan = writeChan + tls.readChan = readChan + tls.requestChan = requestChan - handshakeWriterChan := make(chan interface{}); - processorHandshakeChan := make(chan interface{}); - handshakeProcessorChan := make(chan interface{}); - readerProcessorChan := make(chan *record); + handshakeWriterChan := make(chan interface{}) + processorHandshakeChan := make(chan interface{}) + handshakeProcessorChan := make(chan interface{}) + readerProcessorChan := make(chan *record) - go new(recordWriter).loop(conn, writeChan, handshakeWriterChan); - go recordReader(readerProcessorChan, conn); - go new(recordProcessor).loop(readChan, requestChan, handshakeProcessorChan, readerProcessorChan, processorHandshakeChan); - go h.loop(handshakeWriterChan, handshakeProcessorChan, processorHandshakeChan, config); + go new(recordWriter).loop(conn, writeChan, handshakeWriterChan) + go recordReader(readerProcessorChan, conn) + go new(recordProcessor).loop(readChan, requestChan, handshakeProcessorChan, readerProcessorChan, processorHandshakeChan) + go h.loop(handshakeWriterChan, handshakeProcessorChan, processorHandshakeChan, config) - return tls; + return tls } func Server(conn net.Conn, config *Config) *Conn { @@ -158,28 +158,28 @@ func Client(conn net.Conn, config *Config) *Conn { } type Listener struct { - listener net.Listener; - config *Config; + listener net.Listener + config *Config } func (l Listener) Accept() (c net.Conn, err os.Error) { - c, err = l.listener.Accept(); + c, err = l.listener.Accept() if err != nil { return } - c = Server(c, l.config); - return; + c = Server(c, l.config) + return } -func (l Listener) Close() os.Error { return l.listener.Close() } +func (l Listener) Close() os.Error { return l.listener.Close() } -func (l Listener) Addr() net.Addr { return l.listener.Addr() } +func (l Listener) Addr() net.Addr { return l.listener.Addr() } // NewListener creates a Listener which accepts connections from an inner // Listener and wraps each connection with Server. func NewListener(listener net.Listener, config *Config) (l Listener) { - l.listener = listener; - l.config = config; - return; + l.listener = listener + l.config = config + return } diff --git a/src/pkg/crypto/x509/x509.go b/src/pkg/crypto/x509/x509.go index 6a6239b1b..dcd12f05f 100644 --- a/src/pkg/crypto/x509/x509.go +++ b/src/pkg/crypto/x509/x509.go @@ -6,25 +6,25 @@ package x509 import ( - "asn1"; - "big"; - "container/vector"; - "crypto/rsa"; - "crypto/sha1"; - "hash"; - "os"; - "strings"; - "time"; + "asn1" + "big" + "container/vector" + "crypto/rsa" + "crypto/sha1" + "hash" + "os" + "strings" + "time" ) // pkcs1PrivateKey is a structure which mirrors the PKCS#1 ASN.1 for an RSA private key. type pkcs1PrivateKey struct { - Version int; - N asn1.RawValue; - E int; - D asn1.RawValue; - P asn1.RawValue; - Q asn1.RawValue; + Version int + N asn1.RawValue + E int + D asn1.RawValue + P asn1.RawValue + Q asn1.RawValue } // rawValueIsInteger returns true iff the given ASN.1 RawValue is an INTEGER type. @@ -34,11 +34,11 @@ func rawValueIsInteger(raw *asn1.RawValue) bool { // ParsePKCS1PrivateKey returns an RSA private key from its ASN.1 PKCS#1 DER encoded form. func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) { - var priv pkcs1PrivateKey; - rest, err := asn1.Unmarshal(&priv, der); + var priv pkcs1PrivateKey + rest, err := asn1.Unmarshal(&priv, der) if len(rest) > 0 { - err = asn1.SyntaxError{"trailing data"}; - return; + err = asn1.SyntaxError{"trailing data"} + return } if err != nil { return @@ -48,8 +48,8 @@ func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) { !rawValueIsInteger(&priv.D) || !rawValueIsInteger(&priv.P) || !rawValueIsInteger(&priv.Q) { - err = asn1.StructuralError{"tags don't match"}; - return; + err = asn1.StructuralError{"tags don't match"} + return } key = &rsa.PrivateKey{ @@ -60,39 +60,39 @@ func ParsePKCS1PrivateKey(der []byte) (key *rsa.PrivateKey, err os.Error) { D: new(big.Int).SetBytes(priv.D.Bytes), P: new(big.Int).SetBytes(priv.P.Bytes), Q: new(big.Int).SetBytes(priv.Q.Bytes), - }; + } - err = key.Validate(); + err = key.Validate() if err != nil { return nil, err } - return; + return } // These structures reflect the ASN.1 structure of X.509 certificates.: type certificate struct { - TBSCertificate tbsCertificate; - SignatureAlgorithm algorithmIdentifier; - SignatureValue asn1.BitString; + TBSCertificate tbsCertificate + SignatureAlgorithm algorithmIdentifier + SignatureValue asn1.BitString } type tbsCertificate struct { - Raw asn1.RawContent; - Version int "optional,explicit,default:1,tag:0"; - SerialNumber asn1.RawValue; - SignatureAlgorithm algorithmIdentifier; - Issuer rdnSequence; - Validity validity; - Subject rdnSequence; - PublicKey publicKeyInfo; - UniqueId asn1.BitString "optional,explicit,tag:1"; - SubjectUniqueId asn1.BitString "optional,explicit,tag:2"; - Extensions []extension "optional,explicit,tag:3"; + Raw asn1.RawContent + Version int "optional,explicit,default:1,tag:0" + SerialNumber asn1.RawValue + SignatureAlgorithm algorithmIdentifier + Issuer rdnSequence + Validity validity + Subject rdnSequence + PublicKey publicKeyInfo + UniqueId asn1.BitString "optional,explicit,tag:1" + SubjectUniqueId asn1.BitString "optional,explicit,tag:2" + Extensions []extension "optional,explicit,tag:3" } type algorithmIdentifier struct { - Algorithm asn1.ObjectIdentifier; + Algorithm asn1.ObjectIdentifier } type rdnSequence []relativeDistinguishedName @@ -100,55 +100,55 @@ type rdnSequence []relativeDistinguishedName type relativeDistinguishedName []attributeTypeAndValue type attributeTypeAndValue struct { - Type asn1.ObjectIdentifier; - Value interface{}; + Type asn1.ObjectIdentifier + Value interface{} } type validity struct { - NotBefore, NotAfter *time.Time; + NotBefore, NotAfter *time.Time } type publicKeyInfo struct { - Algorithm algorithmIdentifier; - PublicKey asn1.BitString; + Algorithm algorithmIdentifier + PublicKey asn1.BitString } type extension struct { - Id asn1.ObjectIdentifier; - Critical bool "optional"; - Value []byte; + Id asn1.ObjectIdentifier + Critical bool "optional" + Value []byte } // RFC 5280, 4.2.1.1 type authKeyId struct { - Id []byte "optional,tag:0"; + Id []byte "optional,tag:0" } type SignatureAlgorithm int const ( - UnknownSignatureAlgorithm SignatureAlgorithm = iota; - MD2WithRSA; - MD5WithRSA; - SHA1WithRSA; - SHA256WithRSA; - SHA384WithRSA; - SHA512WithRSA; + UnknownSignatureAlgorithm SignatureAlgorithm = iota + MD2WithRSA + MD5WithRSA + SHA1WithRSA + SHA256WithRSA + SHA384WithRSA + SHA512WithRSA ) type PublicKeyAlgorithm int const ( - UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota; - RSA; + UnknownPublicKeyAlgorithm PublicKeyAlgorithm = iota + RSA ) // Name represents an X.509 distinguished name. This only includes the common // elements of a DN. Additional elements in the name are ignored. type Name struct { - Country, Organization, OrganizationalUnit string; - CommonName, SerialNumber, Locality string; - Province, StreetAddress, PostalCode string; + Country, Organization, OrganizationalUnit string + CommonName, SerialNumber, Locality string + Province, StreetAddress, PostalCode string } func (n *Name) fillFromRDNSequence(rdns *rdnSequence) { @@ -156,13 +156,13 @@ func (n *Name) fillFromRDNSequence(rdns *rdnSequence) { if len(rdn) == 0 { continue } - atv := rdn[0]; - value, ok := atv.Value.(string); + atv := rdn[0] + value, ok := atv.Value.(string) if !ok { continue } - t := atv.Type; + t := atv.Type if len(t) == 4 && t[0] == 2 && t[1] == 5 && t[2] == 4 { switch t[3] { case 3: @@ -207,7 +207,7 @@ func getSignatureAlgorithmFromOID(oid []int) SignatureAlgorithm { } } - return UnknownSignatureAlgorithm; + return UnknownSignatureAlgorithm } func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm { @@ -219,7 +219,7 @@ func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm { } } - return UnknownPublicKeyAlgorithm; + return UnknownPublicKeyAlgorithm } // KeyUsage represents the set of actions that are valid for a given key. It's @@ -227,43 +227,43 @@ func getPublicKeyAlgorithmFromOID(oid []int) PublicKeyAlgorithm { type KeyUsage int const ( - KeyUsageDigitalSignature KeyUsage = 1 << iota; - KeyUsageContentCommitment; - KeyUsageKeyEncipherment; - KeyUsageDataEncipherment; - KeyUsageKeyAgreement; - KeyUsageCertSign; - KeyUsageCRLSign; - KeyUsageEncipherOnly; - KeyUsageDecipherOnly; + KeyUsageDigitalSignature KeyUsage = 1 << iota + KeyUsageContentCommitment + KeyUsageKeyEncipherment + KeyUsageDataEncipherment + KeyUsageKeyAgreement + KeyUsageCertSign + KeyUsageCRLSign + KeyUsageEncipherOnly + KeyUsageDecipherOnly ) // A Certificate represents an X.509 certificate. type Certificate struct { - Raw []byte; // Raw ASN.1 DER contents. - Signature []byte; - SignatureAlgorithm SignatureAlgorithm; + Raw []byte // Raw ASN.1 DER contents. + Signature []byte + SignatureAlgorithm SignatureAlgorithm - PublicKeyAlgorithm PublicKeyAlgorithm; - PublicKey interface{}; + PublicKeyAlgorithm PublicKeyAlgorithm + PublicKey interface{} - Version int; - SerialNumber []byte; - Issuer Name; - Subject Name; - NotBefore, NotAfter *time.Time; // Validity bounds. - KeyUsage KeyUsage; + Version int + SerialNumber []byte + Issuer Name + Subject Name + NotBefore, NotAfter *time.Time // Validity bounds. + KeyUsage KeyUsage - BasicConstraintsValid bool; // if true then the next two fields are valid. - IsCA bool; - MaxPathLen int; + BasicConstraintsValid bool // if true then the next two fields are valid. + IsCA bool + MaxPathLen int - SubjectKeyId []byte; - AuthorityKeyId []byte; + SubjectKeyId []byte + AuthorityKeyId []byte // Subject Alternate Name values - DNSNames []string; - EmailAddresses []string; + DNSNames []string + EmailAddresses []string } // UnsupportedAlgorithmError results from attempting to perform an operation @@ -306,26 +306,26 @@ func (c *Certificate) CheckSignatureFrom(parent *Certificate) (err os.Error) { // TODO(agl): don't ignore the path length constraint. - var h hash.Hash; - var hashType rsa.PKCS1v15Hash; + var h hash.Hash + var hashType rsa.PKCS1v15Hash switch c.SignatureAlgorithm { case SHA1WithRSA: - h = sha1.New(); - hashType = rsa.HashSHA1; + h = sha1.New() + hashType = rsa.HashSHA1 default: return UnsupportedAlgorithmError{} } - pub, ok := parent.PublicKey.(*rsa.PublicKey); + pub, ok := parent.PublicKey.(*rsa.PublicKey) if !ok { return UnsupportedAlgorithmError{} } - h.Write(c.Raw); - digest := h.Sum(); + h.Write(c.Raw) + digest := h.Sum() - return rsa.VerifyPKCS1v15(pub, hashType, digest, c.Signature); + return rsa.VerifyPKCS1v15(pub, hashType, digest, c.Signature) } func matchHostnames(pattern, host string) bool { @@ -333,8 +333,8 @@ func matchHostnames(pattern, host string) bool { return false } - patternParts := strings.Split(pattern, ".", 0); - hostParts := strings.Split(host, ".", 0); + patternParts := strings.Split(pattern, ".", 0) + hostParts := strings.Split(host, ".", 0) if len(patternParts) != len(hostParts) { return false @@ -349,7 +349,7 @@ func matchHostnames(pattern, host string) bool { } } - return true; + return true } // IsValidForHost returns true iff c is a valid certificate for the given host. @@ -361,10 +361,10 @@ func (c *Certificate) IsValidForHost(h string) bool { } } // If Subject Alt Name is given, we ignore the common name. - return false; + return false } - return matchHostnames(c.Subject.CommonName, h); + return matchHostnames(c.Subject.CommonName, h) } type UnhandledCriticalExtension struct{} @@ -374,20 +374,20 @@ func (h UnhandledCriticalExtension) String() string { } type basicConstraints struct { - IsCA bool "optional"; - MaxPathLen int "optional"; + IsCA bool "optional" + MaxPathLen int "optional" } type rsaPublicKey struct { - N asn1.RawValue; - E int; + N asn1.RawValue + E int } func parsePublicKey(algo PublicKeyAlgorithm, asn1Data []byte) (interface{}, os.Error) { switch algo { case RSA: - p := new(rsaPublicKey); - _, err := asn1.Unmarshal(p, asn1Data); + p := new(rsaPublicKey) + _, err := asn1.Unmarshal(p, asn1Data) if err != nil { return nil, err } @@ -399,79 +399,79 @@ func parsePublicKey(algo PublicKeyAlgorithm, asn1Data []byte) (interface{}, os.E pub := &rsa.PublicKey{ E: p.E, N: new(big.Int).SetBytes(p.N.Bytes), - }; - return pub, nil; + } + return pub, nil default: return nil, nil } - panic("unreachable"); + panic("unreachable") } func appendString(in []string, v string) (out []string) { if cap(in)-len(in) < 1 { - out = make([]string, len(in)+1, len(in)*2+1); + out = make([]string, len(in)+1, len(in)*2+1) for i, v := range in { out[i] = v } } else { out = in[0 : len(in)+1] } - out[len(in)] = v; - return out; + out[len(in)] = v + return out } func parseCertificate(in *certificate) (*Certificate, os.Error) { - out := new(Certificate); - out.Raw = in.TBSCertificate.Raw; + out := new(Certificate) + out.Raw = in.TBSCertificate.Raw - out.Signature = in.SignatureValue.RightAlign(); + out.Signature = in.SignatureValue.RightAlign() out.SignatureAlgorithm = - getSignatureAlgorithmFromOID(in.TBSCertificate.SignatureAlgorithm.Algorithm); + getSignatureAlgorithmFromOID(in.TBSCertificate.SignatureAlgorithm.Algorithm) out.PublicKeyAlgorithm = - getPublicKeyAlgorithmFromOID(in.TBSCertificate.PublicKey.Algorithm.Algorithm); - var err os.Error; - out.PublicKey, err = parsePublicKey(out.PublicKeyAlgorithm, in.TBSCertificate.PublicKey.PublicKey.RightAlign()); + getPublicKeyAlgorithmFromOID(in.TBSCertificate.PublicKey.Algorithm.Algorithm) + var err os.Error + out.PublicKey, err = parsePublicKey(out.PublicKeyAlgorithm, in.TBSCertificate.PublicKey.PublicKey.RightAlign()) if err != nil { return nil, err } - out.Version = in.TBSCertificate.Version; - out.SerialNumber = in.TBSCertificate.SerialNumber.Bytes; - out.Issuer.fillFromRDNSequence(&in.TBSCertificate.Issuer); - out.Subject.fillFromRDNSequence(&in.TBSCertificate.Subject); - out.NotBefore = in.TBSCertificate.Validity.NotBefore; - out.NotAfter = in.TBSCertificate.Validity.NotAfter; + out.Version = in.TBSCertificate.Version + out.SerialNumber = in.TBSCertificate.SerialNumber.Bytes + out.Issuer.fillFromRDNSequence(&in.TBSCertificate.Issuer) + out.Subject.fillFromRDNSequence(&in.TBSCertificate.Subject) + out.NotBefore = in.TBSCertificate.Validity.NotBefore + out.NotAfter = in.TBSCertificate.Validity.NotAfter for _, e := range in.TBSCertificate.Extensions { if len(e.Id) == 4 && e.Id[0] == 2 && e.Id[1] == 5 && e.Id[2] == 29 { switch e.Id[3] { case 15: // RFC 5280, 4.2.1.3 - var usageBits asn1.BitString; - _, err := asn1.Unmarshal(&usageBits, e.Value); + var usageBits asn1.BitString + _, err := asn1.Unmarshal(&usageBits, e.Value) if err == nil { - var usage int; + var usage int for i := 0; i < 9; i++ { if usageBits.At(i) != 0 { usage |= 1 << uint(i) } } - out.KeyUsage = KeyUsage(usage); - continue; + out.KeyUsage = KeyUsage(usage) + continue } case 19: // RFC 5280, 4.2.1.9 - var constriants basicConstraints; - _, err := asn1.Unmarshal(&constriants, e.Value); + var constriants basicConstraints + _, err := asn1.Unmarshal(&constriants, e.Value) if err == nil { - out.BasicConstraintsValid = true; - out.IsCA = constriants.IsCA; - out.MaxPathLen = constriants.MaxPathLen; - continue; + out.BasicConstraintsValid = true + out.IsCA = constriants.IsCA + out.MaxPathLen = constriants.MaxPathLen + continue } case 17: // RFC 5280, 4.2.1.6 @@ -490,8 +490,8 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) { // uniformResourceIdentifier [6] IA5String, // iPAddress [7] OCTET STRING, // registeredID [8] OBJECT IDENTIFIER } - var seq asn1.RawValue; - _, err := asn1.Unmarshal(&seq, e.Value); + var seq asn1.RawValue + _, err := asn1.Unmarshal(&seq, e.Value) if err != nil { return nil, err } @@ -499,22 +499,22 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) { return nil, asn1.StructuralError{"bad SAN sequence"} } - parsedName := false; + parsedName := false - rest := seq.Bytes; + rest := seq.Bytes for len(rest) > 0 { - var v asn1.RawValue; - rest, err = asn1.Unmarshal(&v, rest); + var v asn1.RawValue + rest, err = asn1.Unmarshal(&v, rest) if err != nil { return nil, err } switch v.Tag { case 1: - out.EmailAddresses = appendString(out.EmailAddresses, string(v.Bytes)); - parsedName = true; + out.EmailAddresses = appendString(out.EmailAddresses, string(v.Bytes)) + parsedName = true case 2: - out.DNSNames = appendString(out.DNSNames, string(v.Bytes)); - parsedName = true; + out.DNSNames = appendString(out.DNSNames, string(v.Bytes)) + parsedName = true } } @@ -526,18 +526,18 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) { case 35: // RFC 5280, 4.2.1.1 - var a authKeyId; - _, err = asn1.Unmarshal(&a, e.Value); + var a authKeyId + _, err = asn1.Unmarshal(&a, e.Value) if err != nil { return nil, err } - out.AuthorityKeyId = a.Id; - continue; + out.AuthorityKeyId = a.Id + continue case 14: // RFC 5280, 4.2.1.2 - out.SubjectKeyId = e.Value; - continue; + out.SubjectKeyId = e.Value + continue } } @@ -546,13 +546,13 @@ func parseCertificate(in *certificate) (*Certificate, os.Error) { } } - return out, nil; + return out, nil } // ParseCertificate parses a single certificate from the given ASN.1 DER data. func ParseCertificate(asn1Data []byte) (*Certificate, os.Error) { - var cert certificate; - rest, err := asn1.Unmarshal(&cert, asn1Data); + var cert certificate + rest, err := asn1.Unmarshal(&cert, asn1Data) if err != nil { return nil, err } @@ -560,32 +560,32 @@ func ParseCertificate(asn1Data []byte) (*Certificate, os.Error) { return nil, asn1.SyntaxError{"trailing data"} } - return parseCertificate(&cert); + return parseCertificate(&cert) } // ParseCertificates parses one or more certificates from the given ASN.1 DER // data. The certificates must be concatenated with no intermediate padding. func ParseCertificates(asn1Data []byte) ([]*Certificate, os.Error) { - v := new(vector.Vector); + v := new(vector.Vector) for len(asn1Data) > 0 { - cert := new(certificate); - var err os.Error; - asn1Data, err = asn1.Unmarshal(cert, asn1Data); + cert := new(certificate) + var err os.Error + asn1Data, err = asn1.Unmarshal(cert, asn1Data) if err != nil { return nil, err } - v.Push(cert); + v.Push(cert) } - ret := make([]*Certificate, v.Len()); + ret := make([]*Certificate, v.Len()) for i := 0; i < v.Len(); i++ { - cert, err := parseCertificate(v.At(i).(*certificate)); + cert, err := parseCertificate(v.At(i).(*certificate)) if err != nil { return nil, err } - ret[i] = cert; + ret[i] = cert } - return ret, nil; + return ret, nil } diff --git a/src/pkg/crypto/x509/x509_test.go b/src/pkg/crypto/x509/x509_test.go index c6a63253f..796807b4b 100644 --- a/src/pkg/crypto/x509/x509_test.go +++ b/src/pkg/crypto/x509/x509_test.go @@ -5,18 +5,18 @@ package x509 import ( - "big"; - "crypto/rsa"; - "encoding/hex"; - "encoding/pem"; - "reflect"; - "strings"; - "testing"; + "big" + "crypto/rsa" + "encoding/hex" + "encoding/pem" + "reflect" + "strings" + "testing" ) func TestParsePKCS1PrivateKey(t *testing.T) { - block, _ := pem.Decode(strings.Bytes(pemPrivateKey)); - priv, err := ParsePKCS1PrivateKey(block.Bytes); + block, _ := pem.Decode(strings.Bytes(pemPrivateKey)) + priv, err := ParsePKCS1PrivateKey(block.Bytes) if err != nil { t.Errorf("Failed to parse private key: %s", err) } @@ -37,9 +37,9 @@ tAboUGBxTDq3ZroNism3DaMIbKPyYrAqhKov1h5V ` func bigFromString(s string) *big.Int { - ret := new(big.Int); - ret.SetString(s, 10); - return ret; + ret := new(big.Int) + ret.SetString(s, 10) + return ret } var rsaPrivateKey = &rsa.PrivateKey{ @@ -53,8 +53,8 @@ var rsaPrivateKey = &rsa.PrivateKey{ } type matchHostnamesTest struct { - pattern, host string; - ok bool; + pattern, host string + ok bool } var matchHostnamesTests = []matchHostnamesTest{ @@ -72,7 +72,7 @@ var matchHostnamesTests = []matchHostnamesTest{ func TestMatchHostnames(t *testing.T) { for i, test := range matchHostnamesTests { - r := matchHostnames(test.pattern, test.host); + r := matchHostnames(test.pattern, test.host) if r != test.ok { t.Errorf("#%d mismatch got: %t want: %t", i, r, test.ok) } @@ -80,17 +80,17 @@ func TestMatchHostnames(t *testing.T) { } func TestCertificateParse(t *testing.T) { - s, _ := hex.DecodeString(certBytes); - certs, err := ParseCertificates(s); + s, _ := hex.DecodeString(certBytes) + certs, err := ParseCertificates(s) if err != nil { t.Error(err) } if len(certs) != 2 { - t.Errorf("Wrong number of certs: got %d want 2", len(certs)); - return; + t.Errorf("Wrong number of certs: got %d want 2", len(certs)) + return } - err = certs[0].CheckSignatureFrom(certs[1]); + err = certs[0].CheckSignatureFrom(certs[1]) if err != nil { t.Error(err) } diff --git a/src/pkg/crypto/xtea/block.go b/src/pkg/crypto/xtea/block.go index 7cf768153..dfb82e1e2 100644 --- a/src/pkg/crypto/xtea/block.go +++ b/src/pkg/crypto/xtea/block.go @@ -17,50 +17,50 @@ const numRounds = 64 // blockToUint32 reads an 8 byte slice into two uint32s. // The block is treated as big endian. func blockToUint32(src []byte) (uint32, uint32) { - r0 := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]); - r1 := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]); - return r0, r1; + r0 := uint32(src[0])<<24 | uint32(src[1])<<16 | uint32(src[2])<<8 | uint32(src[3]) + r1 := uint32(src[4])<<24 | uint32(src[5])<<16 | uint32(src[6])<<8 | uint32(src[7]) + return r0, r1 } // uint32ToBlock writes two unint32s into an 8 byte data block. // Values are written as big endian. func uint32ToBlock(v0, v1 uint32, dst []byte) { - dst[0] = byte(v0 >> 24); - dst[1] = byte(v0 >> 16); - dst[2] = byte(v0 >> 8); - dst[3] = byte(v0); - dst[4] = byte(v1 >> 24); - dst[5] = byte(v1 >> 16); - dst[6] = byte(v1 >> 8); - dst[7] = byte(v1 >> 0); + dst[0] = byte(v0 >> 24) + dst[1] = byte(v0 >> 16) + dst[2] = byte(v0 >> 8) + dst[3] = byte(v0) + dst[4] = byte(v1 >> 24) + dst[5] = byte(v1 >> 16) + dst[6] = byte(v1 >> 8) + dst[7] = byte(v1 >> 0) } // encryptBlock encrypts a single 8 byte block using XTEA. func encryptBlock(c *Cipher, src, dst []byte) { - v0, v1 := blockToUint32(src); + v0, v1 := blockToUint32(src) // Two rounds of XTEA applied per loop for i := 0; i < numRounds; { - v0 += ((v1<<4 ^ v1>>5) + v1) ^ c.table[i]; - i++; - v1 += ((v0<<4 ^ v0>>5) + v0) ^ c.table[i]; - i++; + v0 += ((v1<<4 ^ v1>>5) + v1) ^ c.table[i] + i++ + v1 += ((v0<<4 ^ v0>>5) + v0) ^ c.table[i] + i++ } - uint32ToBlock(v0, v1, dst); + uint32ToBlock(v0, v1, dst) } // decryptBlock decrypt a single 8 byte block using XTEA. func decryptBlock(c *Cipher, src, dst []byte) { - v0, v1 := blockToUint32(src); + v0, v1 := blockToUint32(src) // Two rounds of XTEA applied per loop for i := numRounds; i > 0; { - i--; - v1 -= ((v0<<4 ^ v0>>5) + v0) ^ c.table[i]; - i--; - v0 -= ((v1<<4 ^ v1>>5) + v1) ^ c.table[i]; + i-- + v1 -= ((v0<<4 ^ v0>>5) + v0) ^ c.table[i] + i-- + v0 -= ((v1<<4 ^ v1>>5) + v1) ^ c.table[i] } - uint32ToBlock(v0, v1, dst); + uint32ToBlock(v0, v1, dst) } diff --git a/src/pkg/crypto/xtea/cipher.go b/src/pkg/crypto/xtea/cipher.go index 71545b5ac..4fb3acbef 100644 --- a/src/pkg/crypto/xtea/cipher.go +++ b/src/pkg/crypto/xtea/cipher.go @@ -9,8 +9,8 @@ package xtea // For details, see http://www.cix.co.uk/~klockstone/xtea.pdf import ( - "os"; - "strconv"; + "os" + "strconv" ) // The XTEA block size in bytes. @@ -19,7 +19,7 @@ const BlockSize = 8 // A Cipher is an instance of an XTEA cipher using a particular key. // table contains a series of precalculated values that are used each round. type Cipher struct { - table [64]uint32; + table [64]uint32 } type KeySizeError int @@ -32,7 +32,7 @@ func (k KeySizeError) String() string { // The key argument should be the XTEA key. // XTEA only supports 128 bit (16 byte) keys. func NewCipher(key []byte) (*Cipher, os.Error) { - k := len(key); + k := len(key) switch k { default: return nil, KeySizeError(k) @@ -40,25 +40,25 @@ func NewCipher(key []byte) (*Cipher, os.Error) { break } - c := new(Cipher); - initCipher(c, key); + c := new(Cipher) + initCipher(c, key) - return c, nil; + return c, nil } // BlockSize returns the XTEA block size, 8 bytes. // It is necessary to satisfy the Key interface in the // package "crypto/modes". -func (c *Cipher) BlockSize() int { return BlockSize } +func (c *Cipher) BlockSize() int { return BlockSize } // Encrypt encrypts the 8 byte buffer src using the key and stores the result in dst. // Note that for amounts of data larger than a block, // it is not safe to just call Encrypt on successive blocks; // instead, use an encryption mode like XTEACBC (see modes.go). -func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c, src, dst) } +func (c *Cipher) Encrypt(src, dst []byte) { encryptBlock(c, src, dst) } // Decrypt decrypts the 8 byte buffer src using the key k and stores the result in dst. -func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c, src, dst) } +func (c *Cipher) Decrypt(src, dst []byte) { decryptBlock(c, src, dst) } // Reset zeros the table, so that it will no longer appear in the process's memory. func (c *Cipher) Reset() { @@ -71,22 +71,22 @@ func (c *Cipher) Reset() { // of precalculated values that are based on the key. func initCipher(c *Cipher, key []byte) { // Load the key into four uint32s - var k [4]uint32; + var k [4]uint32 for i := 0; i < len(k); i++ { - j := i << 2; // Multiply by 4 - k[i] = uint32(key[j+0])<<24 | uint32(key[j+1])<<16 | uint32(key[j+2])<<8 | uint32(key[j+3]); + j := i << 2 // Multiply by 4 + k[i] = uint32(key[j+0])<<24 | uint32(key[j+1])<<16 | uint32(key[j+2])<<8 | uint32(key[j+3]) } // Precalculate the table - const delta = 0x9E3779B9; - var sum uint32 = 0; + const delta = 0x9E3779B9 + var sum uint32 = 0 // Two rounds of XTEA applied per loop for i := 0; i < numRounds; { - c.table[i] = sum + k[sum&3]; - i++; - sum += delta; - c.table[i] = sum + k[(sum>>11)&3]; - i++; + c.table[i] = sum + k[sum&3] + i++ + sum += delta + c.table[i] = sum + k[(sum>>11)&3] + i++ } } diff --git a/src/pkg/crypto/xtea/xtea_test.go b/src/pkg/crypto/xtea/xtea_test.go index 26221c4b4..94756f79f 100644 --- a/src/pkg/crypto/xtea/xtea_test.go +++ b/src/pkg/crypto/xtea/xtea_test.go @@ -5,7 +5,7 @@ package xtea import ( - "testing"; + "testing" ) // A sample test key for when we just want to initialise a cipher @@ -14,20 +14,20 @@ var testKey = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, // Test that the block size for XTEA is correct func TestBlocksize(t *testing.T) { if BlockSize != 8 { - t.Errorf("BlockSize constant - expected 8, got %d", BlockSize); - return; + t.Errorf("BlockSize constant - expected 8, got %d", BlockSize) + return } - c, err := NewCipher(testKey); + c, err := NewCipher(testKey) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err); - return; + t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err) + return } - result := c.BlockSize(); + result := c.BlockSize() if result != 8 { - t.Errorf("BlockSize function - expected 8, gotr %d", result); - return; + t.Errorf("BlockSize function - expected 8, gotr %d", result) + return } } @@ -45,16 +45,16 @@ var testTable = []uint32{ // Test that the cipher context is initialised correctly func TestCipherInit(t *testing.T) { - c, err := NewCipher(testKey); + c, err := NewCipher(testKey) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err); - return; + t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err) + return } for i := 0; i < len(c.table); i++ { if c.table[i] != testTable[i] { - t.Errorf("NewCipher() failed to initialise Cipher.table[%d] correctly. Expected %08X, got %08X", i, testTable[i], c.table[i]); - break; + t.Errorf("NewCipher() failed to initialise Cipher.table[%d] correctly. Expected %08X, got %08X", i, testTable[i], c.table[i]) + break } } } @@ -65,17 +65,17 @@ func TestInvalidKeySize(t *testing.T) { key := []byte{ 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, - }; + } - _, err := NewCipher(key); + _, err := NewCipher(key) if err == nil { t.Errorf("Invalid key size %d didn't result in an error.", len(key)) } // Test a short key - key = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77}; + key = []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77} - _, err = NewCipher(key); + _, err = NewCipher(key) if err == nil { t.Errorf("Invalid key size %d didn't result in an error.", len(key)) } @@ -83,51 +83,51 @@ func TestInvalidKeySize(t *testing.T) { // Test that we can correctly decode some bytes we have encoded func TestEncodeDecode(t *testing.T) { - original := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}; - input := original; - output := make([]byte, BlockSize); + original := []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF} + input := original + output := make([]byte, BlockSize) - c, err := NewCipher(testKey); + c, err := NewCipher(testKey) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err); - return; + t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err) + return } // Encrypt the input block - c.Encrypt(input, output); + c.Encrypt(input, output) // Check that the output does not match the input - differs := false; + differs := false for i := 0; i < len(input); i++ { if output[i] != input[i] { - differs = true; - break; + differs = true + break } } if differs == false { - t.Error("Cipher.Encrypt: Failed to encrypt the input block."); - return; + t.Error("Cipher.Encrypt: Failed to encrypt the input block.") + return } // Decrypt the block we just encrypted - input = output; - output = make([]byte, BlockSize); - c.Decrypt(input, output); + input = output + output = make([]byte, BlockSize) + c.Decrypt(input, output) // Check that the output from decrypt matches our initial input for i := 0; i < len(input); i++ { if output[i] != original[i] { - t.Errorf("Decrypted byte %d differed. Expected %02X, got %02X\n", i, original[i], output[i]); - return; + t.Errorf("Decrypted byte %d differed. Expected %02X, got %02X\n", i, original[i], output[i]) + return } } } // Test Vectors type CryptTest struct { - key []byte; - plainText []byte; - cipherText []byte; + key []byte + plainText []byte + cipherText []byte } var CryptTests = []CryptTest{ @@ -189,19 +189,19 @@ var CryptTests = []CryptTest{ // Test encryption func TestCipherEncrypt(t *testing.T) { for i, tt := range CryptTests { - c, err := NewCipher(tt.key); + c, err := NewCipher(tt.key) if err != nil { - t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err); - continue; + t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err) + continue } - out := make([]byte, len(tt.plainText)); - c.Encrypt(tt.plainText, out); + out := make([]byte, len(tt.plainText)) + c.Encrypt(tt.plainText, out) for j := 0; j < len(out); j++ { if out[j] != tt.cipherText[j] { - t.Errorf("Cipher.Encrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.cipherText[j]); - break; + t.Errorf("Cipher.Encrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.cipherText[j]) + break } } } @@ -210,19 +210,19 @@ func TestCipherEncrypt(t *testing.T) { // Test decryption func TestCipherDecrypt(t *testing.T) { for i, tt := range CryptTests { - c, err := NewCipher(tt.key); + c, err := NewCipher(tt.key) if err != nil { - t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err); - continue; + t.Errorf("NewCipher(%d bytes), vector %d = %s", len(tt.key), i, err) + continue } - out := make([]byte, len(tt.cipherText)); - c.Decrypt(tt.cipherText, out); + out := make([]byte, len(tt.cipherText)) + c.Decrypt(tt.cipherText, out) for j := 0; j < len(out); j++ { if out[j] != tt.plainText[j] { - t.Errorf("Cipher.Decrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.plainText[j]); - break; + t.Errorf("Cipher.Decrypt %d: out[%d] = %02X, expected %02X", i, j, out[j], tt.plainText[j]) + break } } } @@ -230,17 +230,17 @@ func TestCipherDecrypt(t *testing.T) { // Test resetting the cipher context func TestReset(t *testing.T) { - c, err := NewCipher(testKey); + c, err := NewCipher(testKey) if err != nil { - t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err); - return; + t.Errorf("NewCipher(%d bytes) = %s", len(testKey), err) + return } - c.Reset(); + c.Reset() for i := 0; i < len(c.table); i++ { if c.table[i] != 0 { - t.Errorf("Cipher.Reset: Failed to clear Cipher.table[%d]. expected 0, got %08X", i, c.table[i]); - return; + t.Errorf("Cipher.Reset: Failed to clear Cipher.table[%d]. expected 0, got %08X", i, c.table[i]) + return } } } |