From be2edb57614dd5a92294b7d29a34de754998fde5 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 3 Mar 2009 08:39:12 -0800 Subject: [PATCH] Automated g4 rollback of changelist 25024, plus significant hand editing. Back to T{x} for composite literals. R=r OCL=25612 CL=25632 --- doc/progs/cat_rot13.go | 2 +- doc/progs/fd.go | 2 +- doc/progs/helloworld3.go | 2 +- doc/progs/print.go | 4 +- doc/progs/print_string.go | 2 +- doc/progs/sortmain.go | 22 +- doc/progs/sum.go | 2 +- src/cmd/gotest/gotest | 6 +- src/lib/bignum.go | 14 +- src/lib/bignum_test.go | 40 +- src/lib/bufio.go | 2 +- src/lib/bufio_test.go | 40 +- src/lib/exec_test.go | 4 +- src/lib/flag.go | 16 +- src/lib/fmt/fmt_test.go | 244 ++++---- src/lib/hash/adler32.go | 2 +- src/lib/hash/adler32_test.go | 66 +- src/lib/hash/crc32.go | 2 +- src/lib/hash/crc32_test.go | 66 +- src/lib/hash/md5_test.go | 66 +- src/lib/hash/md5block.go | 12 +- src/lib/hash/sha1_test.go | 66 +- src/lib/http/server.go | 4 +- src/lib/http/status.go | 4 +- src/lib/io/io.go | 2 +- src/lib/io/pipe.go | 4 +- src/lib/io/pipe_test.go | 2 +- src/lib/json/generic.go | 12 +- src/lib/json/generic_test.go | 4 +- src/lib/json/struct.go | 6 +- src/lib/log.go | 2 +- src/lib/log_test.go | 26 +- src/lib/math/all_test.go | 48 +- src/lib/net/dialgoogle_test.go | 4 +- src/lib/net/dnsclient.go | 6 +- src/lib/net/dnsmsg.go | 4 +- src/lib/net/ip_test.go | 23 +- src/lib/net/net_darwin.go | 8 +- src/lib/net/net_linux.go | 8 +- src/lib/net/parse.go | 2 +- src/lib/net/port_test.go | 58 +- src/lib/os/dir_amd64_darwin.go | 2 +- src/lib/os/dir_amd64_linux.go | 4 +- src/lib/os/error.go | 2 +- src/lib/os/file.go | 2 +- src/lib/os/os_test.go | 8 +- src/lib/reflect/all_test.go | 14 +- src/lib/reflect/type.go | 18 +- src/lib/reflect/value.go | 140 ++--- src/lib/regexp/all_test.go | 86 +-- src/lib/sort_test.go | 14 +- src/lib/strconv/atof.go | 12 +- src/lib/strconv/atof_test.go | 110 ++-- src/lib/strconv/atoi_test.go | 158 ++--- src/lib/strconv/decimal.go | 60 +- src/lib/strconv/decimal_test.go | 76 +-- src/lib/strconv/ftoa.go | 4 +- src/lib/strconv/ftoa_test.go | 148 ++--- src/lib/strconv/itoa_test.go | 97 ++- src/lib/strconv/quote_test.go | 96 +-- src/lib/strings_test.go | 28 +- src/lib/tabwriter/tabwriter.go | 2 +- src/lib/time/time.go | 20 +- src/lib/time/time_test.go | 26 +- src/lib/time/zoneinfo.go | 8 +- src/lib/unicode/letter.go | 1010 +++++++++++++++---------------- src/lib/unicode/letter_test.go | 16 +- src/lib/utf8_test.go | 66 +- src/run.bash | 10 +- test/235.go | 6 +- test/bigalg.go | 4 +- test/bugs/bug117.go | 2 +- test/chan/powser1.go | 2 +- test/chan/powser2.go | 2 +- test/chan/sieve.go | 2 +- test/closure.go | 6 +- test/cmp1.go | 2 +- test/complit.go | 26 +- test/convlit1.go | 3 +- test/fixedbugs/bug047.go | 4 +- test/fixedbugs/bug048.go | 2 +- test/fixedbugs/bug096.go | 4 +- test/fixedbugs/bug097.go | 2 +- test/fixedbugs/bug098.go | 4 +- test/fixedbugs/bug101.go | 2 +- test/fixedbugs/bug102.go | 2 +- test/fixedbugs/bug112.go | 2 +- test/fixedbugs/bug119.go | 4 +- test/fixedbugs/bug120.go | 18 +- test/fixedbugs/bug130.go | 2 +- test/indirect.go | 4 +- test/initcomma.go | 8 +- test/interface4.go | 8 +- test/interface6.go | 24 +- test/mallocrand.go | 2 +- test/map.go | 14 +- test/method3.go | 2 +- test/parentype.go | 6 +- usr/gri/pretty/parser.go | 138 ++--- usr/gri/pretty/selftest2.go | 8 +- 100 files changed, 1731 insertions(+), 1730 deletions(-) diff --git a/doc/progs/cat_rot13.go b/doc/progs/cat_rot13.go index cfb193609f..d2b017bd2c 100644 --- a/doc/progs/cat_rot13.go +++ b/doc/progs/cat_rot13.go @@ -32,7 +32,7 @@ type rotate13 struct { } func newRotate13(source reader) *rotate13 { - return &rotate13(source) + return &rotate13{source} } func (r13 *rotate13) Read(b []byte) (ret int, err *os.Error) { diff --git a/doc/progs/fd.go b/doc/progs/fd.go index b686d0b784..c99c87777a 100644 --- a/doc/progs/fd.go +++ b/doc/progs/fd.go @@ -18,7 +18,7 @@ func newFD(fd int64, name string) *FD { if fd < 0 { return nil } - return &FD(fd, name) + return &FD{fd, name} } var ( diff --git a/doc/progs/helloworld3.go b/doc/progs/helloworld3.go index 36624ab53d..59aebc7213 100644 --- a/doc/progs/helloworld3.go +++ b/doc/progs/helloworld3.go @@ -7,7 +7,7 @@ package main import fd "fd" func main() { - hello := []byte('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '\n'); + hello := []byte{'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '\n'}; fd.Stdout.Write(hello); file, err := fd.Open("/does/not/exist", 0, 0); if file == nil { diff --git a/doc/progs/print.go b/doc/progs/print.go index 5f651d6d83..cc146fed8c 100644 --- a/doc/progs/print.go +++ b/doc/progs/print.go @@ -12,8 +12,8 @@ func main() { // harder stuff type T struct { a int; b string }; - t := T(77, "Sunset Strip"); - a := []int(1, 2, 3, 4); + t := T{77, "Sunset Strip"}; + a := []int{1, 2, 3, 4}; fmt.Printf("%v %v %v\n", u64, t, a); fmt.Print(u64, " ", t, " ", a, "\n"); fmt.Println(u64, t, a); diff --git a/doc/progs/print_string.go b/doc/progs/print_string.go index 8150be8948..13a8d82418 100644 --- a/doc/progs/print_string.go +++ b/doc/progs/print_string.go @@ -13,6 +13,6 @@ func (t *testType) String() string { } func main() { - t := &testType(77, "Sunset Strip"); + t := &testType{77, "Sunset Strip"}; fmt.Println(t) } diff --git a/doc/progs/sortmain.go b/doc/progs/sortmain.go index a945295790..74d1d18408 100644 --- a/doc/progs/sortmain.go +++ b/doc/progs/sortmain.go @@ -7,7 +7,7 @@ package main import "sort" func ints() { - data := []int(74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586); + data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}; a := sort.IntArray(data); sort.Sort(a); if !sort.IsSorted(a) { @@ -16,7 +16,7 @@ func ints() { } func strings() { - data := []string("monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"); + data := []string{"monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"}; a := sort.StringArray(data); sort.Sort(a); if !sort.IsSorted(a) { @@ -39,15 +39,15 @@ func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num; func (p *dayArray) Swap(i, j int) { p.data[i], p.data[j] = p.data[j], p.data[i]; } func days() { - Sunday := day( 0, "SUN", "Sunday" ); - Monday := day( 1, "MON", "Monday" ); - Tuesday := day( 2, "TUE", "Tuesday" ); - Wednesday := day( 3, "WED", "Wednesday" ); - Thursday := day( 4, "THU", "Thursday" ); - Friday := day( 5, "FRI", "Friday" ); - Saturday := day( 6, "SAT", "Saturday" ); - data := []*day(&Tuesday, &Thursday, &Sunday, &Monday, &Friday); - a := dayArray(data); + Sunday := day{ 0, "SUN", "Sunday" }; + Monday := day{ 1, "MON", "Monday" }; + Tuesday := day{ 2, "TUE", "Tuesday" }; + Wednesday := day{ 3, "WED", "Wednesday" }; + Thursday := day{ 4, "THU", "Thursday" }; + Friday := day{ 5, "FRI", "Friday" }; + Saturday := day{ 6, "SAT", "Saturday" }; + data := []*day{&Tuesday, &Thursday, &Sunday, &Monday, &Friday}; + a := dayArray{data}; sort.Sort(&a); if !sort.IsSorted(&a) { panic() diff --git a/doc/progs/sum.go b/doc/progs/sum.go index 0ca7c042ac..3ca1a58770 100644 --- a/doc/progs/sum.go +++ b/doc/progs/sum.go @@ -14,6 +14,6 @@ func sum(a []int) int { // returns an int func main() { - s := sum([3]int(1,2,3)); // a slice of the array is passed to sum + s := sum([3]int{1,2,3}); // a slice of the array is passed to sum print(s, "\n"); } diff --git a/src/cmd/gotest/gotest b/src/cmd/gotest/gotest index cddbeb0316..0ec17322d1 100755 --- a/src/cmd/gotest/gotest +++ b/src/cmd/gotest/gotest @@ -71,7 +71,7 @@ trap "rm -f _testmain.go _testmain.6" 0 1 2 3 14 15 echo 'import "testing"' # test array echo - echo 'var tests = []testing.Test(' + echo 'var tests = []testing.Test {' for ofile in $ofiles do # test functions are named TestFoo @@ -84,11 +84,11 @@ trap "rm -f _testmain.go _testmain.6" 0 1 2 3 14 15 else for i in $tests do - echo ' testing.Test( "'$i'", '$i' ),' + echo ' testing.Test{ "'$i'", '$i' },' done fi done - echo ')' + echo '}' # body echo echo 'func main() {' diff --git a/src/lib/bignum.go b/src/lib/bignum.go index 2ae3a73baf..078374ad7e 100755 --- a/src/lib/bignum.go +++ b/src/lib/bignum.go @@ -114,10 +114,10 @@ func Dump(x []Digit) { type Natural []Digit; var ( - natZero Natural = Natural(); - natOne Natural = Natural(1); - natTwo Natural = Natural(2); - natTen Natural = Natural(10); + natZero Natural = Natural{}; + natOne Natural = Natural{1}; + natTwo Natural = Natural{2}; + natTen Natural = Natural{10}; ) @@ -131,7 +131,7 @@ func Nat(x uint) Natural { case 10: return natTen; } assert(Digit(x) < _B); - return Natural(Digit(x)); + return Natural{Digit(x)}; } @@ -818,7 +818,7 @@ func MakeInt(sign bool, mant Natural) *Integer { if mant.IsZero() { sign = false; // normalize } - return &Integer(sign, mant); + return &Integer{sign, mant}; } @@ -1140,7 +1140,7 @@ func MakeRat(a *Integer, b Natural) *Rational { a = MakeInt(a.sign, a.mant.Div(f)); b = b.Div(f); } - return &Rational(a, b); + return &Rational{a, b}; } diff --git a/src/lib/bignum_test.go b/src/lib/bignum_test.go index 91304c1e0f..d8d214dd78 100644 --- a/src/lib/bignum_test.go +++ b/src/lib/bignum_test.go @@ -264,16 +264,16 @@ func TestIntQuoRem(t *testing.T) { tester = t; test_msg = "IntQuoRem"; type T struct { x, y, q, r int }; - a := []T( - T(+8, +3, +2, +2), - T(+8, -3, -2, +2), - T(-8, +3, -2, -2), - T(-8, -3, +2, -2), - T(+1, +2, 0, +1), - T(+1, -2, 0, +1), - T(-1, +2, 0, -1), - T(-1, -2, 0, -1), - ); + a := []T{ + T{+8, +3, +2, +2}, + T{+8, -3, -2, +2}, + T{-8, +3, -2, -2}, + T{-8, -3, +2, -2}, + T{+1, +2, 0, +1}, + 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 := bignum.Int(e.x).Mul(ip), bignum.Int(e.y).Mul(ip); @@ -291,16 +291,16 @@ func TestIntDivMod(t *testing.T) { tester = t; test_msg = "IntDivMod"; type T struct { x, y, q, r int }; - a := []T( - T(+8, +3, +2, +2), - T(+8, -3, -2, +2), - T(-8, +3, -3, +1), - T(-8, -3, +3, +1), - T(+1, +2, 0, +1), - T(+1, -2, 0, +1), - T(-1, +2, -1, +1), - T(-1, -2, +1, +1), - ); + a := []T{ + T{+8, +3, +2, +2}, + T{+8, -3, -2, +2}, + T{-8, +3, -3, +1}, + T{-8, -3, +3, +1}, + T{+1, +2, 0, +1}, + 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 := bignum.Int(e.x).Mul(ip), bignum.Int(e.y).Mul(ip); diff --git a/src/lib/bufio.go b/src/lib/bufio.go index fd3267fd44..9f36885885 100644 --- a/src/lib/bufio.go +++ b/src/lib/bufio.go @@ -477,6 +477,6 @@ type BufReadWrite struct { } func NewBufReadWrite(r *BufRead, w *BufWrite) *BufReadWrite { - return &BufReadWrite(r, w) + return &BufReadWrite{r, w} } diff --git a/src/lib/bufio_test.go b/src/lib/bufio_test.go index fe8698b00d..9ffd6cbfd4 100644 --- a/src/lib/bufio_test.go +++ b/src/lib/bufio_test.go @@ -98,10 +98,10 @@ type readMaker struct { name string; fn func([]byte) io.Read; } -var readMakers = []readMaker ( - readMaker( "full", func(p []byte) io.Read { return newByteReader(p) } ), - readMaker( "half", func(p []byte) io.Read { return newHalfByteReader(p) } ), -) +var readMakers = []readMaker { + readMaker{ "full", func(p []byte) io.Read { return newByteReader(p) } }, + readMaker{ "half", func(p []byte) io.Read { return newHalfByteReader(p) } }, +} // Call ReadLineString (which ends up calling everything else) // to accumulate the text of a file. @@ -157,21 +157,21 @@ type bufReader struct { name string; fn func(*BufRead) string; } -var bufreaders = []bufReader ( - bufReader( "1", func(b *BufRead) string { return reads(b, 1) } ), - bufReader( "2", func(b *BufRead) string { return reads(b, 2) } ), - bufReader( "3", func(b *BufRead) string { return reads(b, 3) } ), - bufReader( "4", func(b *BufRead) string { return reads(b, 4) } ), - bufReader( "5", func(b *BufRead) string { return reads(b, 5) } ), - bufReader( "7", func(b *BufRead) string { return reads(b, 7) } ), - bufReader( "bytes", readBytes ), - bufReader( "lines", readLines ), -) +var bufreaders = []bufReader { + bufReader{ "1", func(b *BufRead) string { return reads(b, 1) } }, + bufReader{ "2", func(b *BufRead) string { return reads(b, 2) } }, + bufReader{ "3", func(b *BufRead) string { return reads(b, 3) } }, + bufReader{ "4", func(b *BufRead) string { return reads(b, 4) } }, + bufReader{ "5", func(b *BufRead) string { return reads(b, 5) } }, + bufReader{ "7", func(b *BufRead) string { return reads(b, 7) } }, + bufReader{ "bytes", readBytes }, + bufReader{ "lines", readLines }, +} -var bufsizes = []int ( +var bufsizes = []int { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 23, 32, 46, 64, 93, 128, 1024, 4096 -) +} func TestBufReadSimple(t *testing.T) { b := NewBufRead(newByteReader(io.StringBytes("hello world"))); @@ -281,10 +281,10 @@ type writeMaker struct { func TestBufWrite(t *testing.T) { var data [8192]byte; - var writers = []writeMaker ( - writeMaker( "full", newByteWriter ), - writeMaker( "half", newHalfByteWriter ), - ); + var writers = []writeMaker { + writeMaker{ "full", newByteWriter }, + writeMaker{ "half", newHalfByteWriter }, + }; for i := 0; i < len(data); i++ { data[i] = byte(' '+ i%('~'-' ')); diff --git a/src/lib/exec_test.go b/src/lib/exec_test.go index 740dfa7654..54d483799d 100644 --- a/src/lib/exec_test.go +++ b/src/lib/exec_test.go @@ -11,7 +11,7 @@ import ( ) func TestOpenCmdCat(t *testing.T) { - cmd, err := exec.OpenCmd("/bin/cat", []string("cat"), nil, + cmd, err := exec.OpenCmd("/bin/cat", []string{"cat"}, nil, exec.Pipe, exec.Pipe, exec.DevNull); if err != nil { t.Fatalf("opencmd /bin/cat: %v", err); @@ -32,7 +32,7 @@ func TestOpenCmdCat(t *testing.T) { } func TestOpenCmdEcho(t *testing.T) { - cmd, err := OpenCmd("/bin/echo", []string("echo", "hello", "world"), nil, + cmd, err := OpenCmd("/bin/echo", []string{"echo", "hello", "world"}, nil, exec.DevNull, exec.Pipe, exec.DevNull); if err != nil { t.Fatalf("opencmd /bin/echo: %v", err); diff --git a/src/lib/flag.go b/src/lib/flag.go index 188cb90595..164b9c5ba3 100644 --- a/src/lib/flag.go +++ b/src/lib/flag.go @@ -74,7 +74,7 @@ type boolValue struct { func newBoolValue(val bool, p *bool) *boolValue { *p = val; - return &boolValue(p) + return &boolValue{p} } func (b *boolValue) set(s string) bool { @@ -94,7 +94,7 @@ type intValue struct { func newIntValue(val int, p *int) *intValue { *p = val; - return &intValue(p) + return &intValue{p} } func (i *intValue) set(s string) bool { @@ -114,7 +114,7 @@ type int64Value struct { func newInt64Value(val int64, p *int64) *int64Value { *p = val; - return &int64Value(p) + return &int64Value{p} } func (i *int64Value) set(s string) bool { @@ -134,7 +134,7 @@ type uintValue struct { func newUintValue(val uint, p *uint) *uintValue { *p = val; - return &uintValue(p) + return &uintValue{p} } func (i *uintValue) set(s string) bool { @@ -154,7 +154,7 @@ type uint64Value struct { func newUint64Value(val uint64, p *uint64) *uint64Value { *p = val; - return &uint64Value(p) + return &uint64Value{p} } func (i *uint64Value) set(s string) bool { @@ -174,7 +174,7 @@ type stringValue struct { func newStringValue(val string, p *string) *stringValue { *p = val; - return &stringValue(p) + return &stringValue{p} } func (s *stringValue) set(val string) bool { @@ -206,7 +206,7 @@ type allFlags struct { first_arg int; // 0 is the program name, 1 is first arg } -var flags *allFlags = &allFlags(make(map[string] *Flag), make(map[string] *Flag), 1) +var flags *allFlags = &allFlags{make(map[string] *Flag), make(map[string] *Flag), 1} // Visit all flags, including those defined but not set. func VisitAll(fn func(*Flag)) { @@ -282,7 +282,7 @@ func NArg() int { func add(name string, value FlagValue, usage string) { // Remember the default value as a string; it won't change. - f := &Flag(name, usage, value, value.String()); + f := &Flag{name, usage, value, value.String()}; dummy, alreadythere := flags.formal[name]; if alreadythere { print("flag redefined: ", name, "\n"); diff --git a/src/lib/fmt/fmt_test.go b/src/lib/fmt/fmt_test.go index 6541ee0dd4..8cafcd159a 100644 --- a/src/lib/fmt/fmt_test.go +++ b/src/lib/fmt/fmt_test.go @@ -29,127 +29,127 @@ type fmtTest struct { const b32 uint32 = 1<<32 - 1 const b64 uint64 = 1<<64 - 1 -var array = []int(1, 2, 3, 4, 5) +var array = []int{1, 2, 3, 4, 5} -var fmttests = []fmtTest( +var fmttests = []fmtTest{ // basic string - fmtTest( "%s", "abc", "abc" ), - fmtTest( "%x", "abc", "616263" ), - fmtTest( "%x", "xyz", "78797a" ), - fmtTest( "%X", "xyz", "78797A" ), - fmtTest( "%q", "abc", `"abc"` ), + fmtTest{ "%s", "abc", "abc" }, + fmtTest{ "%x", "abc", "616263" }, + fmtTest{ "%x", "xyz", "78797a" }, + fmtTest{ "%X", "xyz", "78797A" }, + fmtTest{ "%q", "abc", `"abc"` }, // basic bytes - fmtTest( "%s", io.StringBytes("abc"), "abc" ), - fmtTest( "%x", io.StringBytes("abc"), "616263" ), - fmtTest( "% x", io.StringBytes("abc"), "61 62 63" ), - fmtTest( "%x", io.StringBytes("xyz"), "78797a" ), - fmtTest( "%X", io.StringBytes("xyz"), "78797A" ), - fmtTest( "%q", io.StringBytes("abc"), `"abc"` ), + fmtTest{ "%s", io.StringBytes("abc"), "abc" }, + fmtTest{ "%x", io.StringBytes("abc"), "616263" }, + fmtTest{ "% x", io.StringBytes("abc"), "61 62 63" }, + fmtTest{ "%x", io.StringBytes("xyz"), "78797a" }, + fmtTest{ "%X", io.StringBytes("xyz"), "78797A" }, + fmtTest{ "%q", io.StringBytes("abc"), `"abc"` }, // escaped strings - fmtTest( "%#q", `abc`, "`abc`" ), - fmtTest( "%#q", `"`, "`\"`" ), - fmtTest( "1 %#q", `\n`, "1 `\\n`" ), - fmtTest( "2 %#q", "\n", `2 "\n"` ), - fmtTest( "%q", `"`, `"\""` ), - fmtTest( "%q", "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` ), - fmtTest( "%q", "abc\xffdef", `"abc\xffdef"` ), - fmtTest( "%q", "\u263a", `"\u263a"` ), - fmtTest( "%q", "\U0010ffff", `"\U0010ffff"` ), + fmtTest{ "%#q", `abc`, "`abc`" }, + fmtTest{ "%#q", `"`, "`\"`" }, + fmtTest{ "1 %#q", `\n`, "1 `\\n`" }, + fmtTest{ "2 %#q", "\n", `2 "\n"` }, + fmtTest{ "%q", `"`, `"\""` }, + fmtTest{ "%q", "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` }, + fmtTest{ "%q", "abc\xffdef", `"abc\xffdef"` }, + fmtTest{ "%q", "\u263a", `"\u263a"` }, + fmtTest{ "%q", "\U0010ffff", `"\U0010ffff"` }, // width - fmtTest( "%5s", "abc", " abc" ), - fmtTest( "%-5s", "abc", "abc " ), - fmtTest( "%05s", "abc", "00abc" ), + fmtTest{ "%5s", "abc", " abc" }, + fmtTest{ "%-5s", "abc", "abc " }, + fmtTest{ "%05s", "abc", "00abc" }, // integers - fmtTest( "%d", 12345, "12345" ), - fmtTest( "%d", -12345, "-12345" ), - fmtTest( "%10d", 12345, " 12345" ), - fmtTest( "%10d", -12345, " -12345" ), - fmtTest( "%+10d", 12345, " +12345" ), - fmtTest( "%010d", 12345, "0000012345" ), - fmtTest( "%010d", -12345, "-000012345" ), - fmtTest( "%-10d", 12345, "12345 " ), - fmtTest( "%010.3d", 1, " 001" ), - fmtTest( "%010.3d", -1, " -001" ), - fmtTest( "%+d", 12345, "+12345" ), - fmtTest( "%+d", -12345, "-12345" ), - fmtTest( "% d", 12345, " 12345" ), - fmtTest( "% d", -12345, "-12345" ), + fmtTest{ "%d", 12345, "12345" }, + fmtTest{ "%d", -12345, "-12345" }, + fmtTest{ "%10d", 12345, " 12345" }, + fmtTest{ "%10d", -12345, " -12345" }, + fmtTest{ "%+10d", 12345, " +12345" }, + fmtTest{ "%010d", 12345, "0000012345" }, + fmtTest{ "%010d", -12345, "-000012345" }, + fmtTest{ "%-10d", 12345, "12345 " }, + fmtTest{ "%010.3d", 1, " 001" }, + fmtTest{ "%010.3d", -1, " -001" }, + fmtTest{ "%+d", 12345, "+12345" }, + fmtTest{ "%+d", -12345, "-12345" }, + fmtTest{ "% d", 12345, " 12345" }, + fmtTest{ "% d", -12345, "-12345" }, // arrays // TODO: when arrays work in interfaces, enable this line // and delete the TestArrayPrinter routine below // fmtTest{ "%v", array, "[1 2 3 4 5]" }, - fmtTest( "%v", &array, "&[1 2 3 4 5]" ), + fmtTest{ "%v", &array, "&[1 2 3 4 5]" }, // old test/fmt_test.go - fmtTest( "%d", 1234, "1234" ), - fmtTest( "%d", -1234, "-1234" ), - fmtTest( "%d", uint(1234), "1234" ), - fmtTest( "%d", uint32(b32), "4294967295" ), - fmtTest( "%d", uint64(b64), "18446744073709551615" ), - fmtTest( "%o", 01234, "1234" ), - fmtTest( "%o", uint32(b32), "37777777777" ), - fmtTest( "%o", uint64(b64), "1777777777777777777777" ), - fmtTest( "%x", 0x1234abcd, "1234abcd" ), - fmtTest( "%x", b32-0x1234567, "fedcba98" ), - fmtTest( "%X", 0x1234abcd, "1234ABCD" ), - fmtTest( "%X", b32-0x1234567, "FEDCBA98" ), - fmtTest( "%x", b64, "ffffffffffffffff" ), - fmtTest( "%b", 7, "111" ), - fmtTest( "%b", b64, "1111111111111111111111111111111111111111111111111111111111111111" ), - fmtTest( "%e", float64(1), "1.000000e+00" ), - fmtTest( "%e", float64(1234.5678e3), "1.234568e+06" ), - fmtTest( "%e", float64(1234.5678e-8), "1.234568e-05" ), - fmtTest( "%e", float64(-7), "-7.000000e+00" ), - fmtTest( "%e", float64(-1e-9), "-1.000000e-09" ), - fmtTest( "%f", float64(1234.5678e3), "1234567.800000" ), - fmtTest( "%f", float64(1234.5678e-8), "0.000012" ), - fmtTest( "%f", float64(-7), "-7.000000" ), - fmtTest( "%f", float64(-1e-9), "-0.000000" ), - fmtTest( "%g", float64(1234.5678e3), "1.2345678e+06" ), - fmtTest( "%g", float32(1234.5678e3), "1.2345678e+06" ), - fmtTest( "%g", float64(1234.5678e-8), "1.2345678e-05" ), - fmtTest( "%g", float64(-7), "-7" ), - fmtTest( "%g", float64(-1e-9), "-1e-09", ), - fmtTest( "%g", float32(-1e-9), "-1e-09" ), - fmtTest( "%c", 'x', "x" ), - fmtTest( "%c", 0xe4, "ä" ), - fmtTest( "%c", 0x672c, "本" ), - fmtTest( "%c", '日', "日" ), - fmtTest( "%20.8d", 1234, " 00001234" ), - fmtTest( "%20.8d", -1234, " -00001234" ), - fmtTest( "%20d", 1234, " 1234" ), - fmtTest( "%-20.8d", 1234, "00001234 " ), - fmtTest( "%-20.8d", -1234, "-00001234 " ), - fmtTest( "%.20b", 7, "00000000000000000111" ), - fmtTest( "%20.5s", "qwertyuiop", " qwert" ), - fmtTest( "%.5s", "qwertyuiop", "qwert" ), - fmtTest( "%-20.5s", "qwertyuiop", "qwert " ), - fmtTest( "%20c", 'x', " x" ), - fmtTest( "%-20c", 'x', "x " ), - fmtTest( "%20.6e", 1.2345e3, " 1.234500e+03" ), - fmtTest( "%20.6e", 1.2345e-3, " 1.234500e-03" ), - fmtTest( "%20e", 1.2345e3, " 1.234500e+03" ), - fmtTest( "%20e", 1.2345e-3, " 1.234500e-03" ), - fmtTest( "%20.8e", 1.2345e3, " 1.23450000e+03" ), - fmtTest( "%20f", float64(1.23456789e3), " 1234.567890" ), - fmtTest( "%20f", float64(1.23456789e-3), " 0.001235" ), - fmtTest( "%20f", float64(12345678901.23456789), " 12345678901.234568" ), - fmtTest( "%-20f", float64(1.23456789e3), "1234.567890 " ), - fmtTest( "%20.8f", float64(1.23456789e3), " 1234.56789000" ), - fmtTest( "%20.8f", float64(1.23456789e-3), " 0.00123457" ), - fmtTest( "%g", float64(1.23456789e3), "1234.56789" ), - fmtTest( "%g", float64(1.23456789e-3), "0.00123456789" ), - fmtTest( "%g", float64(1.23456789e20), "1.23456789e+20" ), - fmtTest( "%20e", math.Inf(1), " +Inf" ), - fmtTest( "%-20f", math.Inf(-1), "-Inf " ), - fmtTest( "%20g", math.NaN(), " NaN" ), -) + fmtTest{ "%d", 1234, "1234" }, + fmtTest{ "%d", -1234, "-1234" }, + fmtTest{ "%d", uint(1234), "1234" }, + fmtTest{ "%d", uint32(b32), "4294967295" }, + fmtTest{ "%d", uint64(b64), "18446744073709551615" }, + fmtTest{ "%o", 01234, "1234" }, + fmtTest{ "%o", uint32(b32), "37777777777" }, + fmtTest{ "%o", uint64(b64), "1777777777777777777777" }, + fmtTest{ "%x", 0x1234abcd, "1234abcd" }, + fmtTest{ "%x", b32-0x1234567, "fedcba98" }, + fmtTest{ "%X", 0x1234abcd, "1234ABCD" }, + fmtTest{ "%X", b32-0x1234567, "FEDCBA98" }, + fmtTest{ "%x", b64, "ffffffffffffffff" }, + fmtTest{ "%b", 7, "111" }, + fmtTest{ "%b", b64, "1111111111111111111111111111111111111111111111111111111111111111" }, + fmtTest{ "%e", float64(1), "1.000000e+00" }, + fmtTest{ "%e", float64(1234.5678e3), "1.234568e+06" }, + fmtTest{ "%e", float64(1234.5678e-8), "1.234568e-05" }, + fmtTest{ "%e", float64(-7), "-7.000000e+00" }, + fmtTest{ "%e", float64(-1e-9), "-1.000000e-09" }, + fmtTest{ "%f", float64(1234.5678e3), "1234567.800000" }, + fmtTest{ "%f", float64(1234.5678e-8), "0.000012" }, + fmtTest{ "%f", float64(-7), "-7.000000" }, + fmtTest{ "%f", float64(-1e-9), "-0.000000" }, + fmtTest{ "%g", float64(1234.5678e3), "1.2345678e+06" }, + fmtTest{ "%g", float32(1234.5678e3), "1.2345678e+06" }, + fmtTest{ "%g", float64(1234.5678e-8), "1.2345678e-05" }, + fmtTest{ "%g", float64(-7), "-7" }, + fmtTest{ "%g", float64(-1e-9), "-1e-09", }, + fmtTest{ "%g", float32(-1e-9), "-1e-09" }, + fmtTest{ "%c", 'x', "x" }, + fmtTest{ "%c", 0xe4, "ä" }, + fmtTest{ "%c", 0x672c, "本" }, + fmtTest{ "%c", '日', "日" }, + fmtTest{ "%20.8d", 1234, " 00001234" }, + fmtTest{ "%20.8d", -1234, " -00001234" }, + fmtTest{ "%20d", 1234, " 1234" }, + fmtTest{ "%-20.8d", 1234, "00001234 " }, + fmtTest{ "%-20.8d", -1234, "-00001234 " }, + fmtTest{ "%.20b", 7, "00000000000000000111" }, + fmtTest{ "%20.5s", "qwertyuiop", " qwert" }, + fmtTest{ "%.5s", "qwertyuiop", "qwert" }, + fmtTest{ "%-20.5s", "qwertyuiop", "qwert " }, + fmtTest{ "%20c", 'x', " x" }, + fmtTest{ "%-20c", 'x', "x " }, + fmtTest{ "%20.6e", 1.2345e3, " 1.234500e+03" }, + fmtTest{ "%20.6e", 1.2345e-3, " 1.234500e-03" }, + fmtTest{ "%20e", 1.2345e3, " 1.234500e+03" }, + fmtTest{ "%20e", 1.2345e-3, " 1.234500e-03" }, + fmtTest{ "%20.8e", 1.2345e3, " 1.23450000e+03" }, + fmtTest{ "%20f", float64(1.23456789e3), " 1234.567890" }, + fmtTest{ "%20f", float64(1.23456789e-3), " 0.001235" }, + fmtTest{ "%20f", float64(12345678901.23456789), " 12345678901.234568" }, + fmtTest{ "%-20f", float64(1.23456789e3), "1234.567890 " }, + fmtTest{ "%20.8f", float64(1.23456789e3), " 1234.56789000" }, + fmtTest{ "%20.8f", float64(1.23456789e-3), " 0.00123457" }, + fmtTest{ "%g", float64(1.23456789e3), "1234.56789" }, + fmtTest{ "%g", float64(1.23456789e-3), "0.00123456789" }, + fmtTest{ "%g", float64(1.23456789e20), "1.23456789e+20" }, + fmtTest{ "%20e", math.Inf(1), " +Inf" }, + fmtTest{ "%-20f", math.Inf(-1), "-Inf " }, + fmtTest{ "%20g", math.NaN(), " NaN" }, +} func TestSprintf(t *testing.T) { for i := 0; i < len(fmttests); i++ { @@ -190,20 +190,20 @@ type flagTest struct { out string; } -var flagtests = []flagTest ( - flagTest( "%a", "[%a]" ), - flagTest( "%-a", "[%-a]" ), - flagTest( "%+a", "[%+a]" ), - flagTest( "%#a", "[%#a]" ), - flagTest( "% a", "[% a]" ), - flagTest( "%0a", "[%0a]" ), - flagTest( "%1.2a", "[%1.2a]" ), - flagTest( "%-1.2a", "[%-1.2a]" ), - flagTest( "%+1.2a", "[%+1.2a]" ), - flagTest( "%-+1.2a", "[%+-1.2a]" ), - flagTest( "%-+1.2abc", "[%+-1.2a]bc" ), - flagTest( "%-1.2abc", "[%-1.2a]bc" ), -) +var flagtests = []flagTest { + flagTest{ "%a", "[%a]" }, + flagTest{ "%-a", "[%-a]" }, + flagTest{ "%+a", "[%+a]" }, + flagTest{ "%#a", "[%#a]" }, + flagTest{ "% a", "[% a]" }, + flagTest{ "%0a", "[%0a]" }, + flagTest{ "%1.2a", "[%1.2a]" }, + flagTest{ "%-1.2a", "[%-1.2a]" }, + flagTest{ "%+1.2a", "[%+1.2a]" }, + flagTest{ "%-+1.2a", "[%+-1.2a]" }, + flagTest{ "%-+1.2abc", "[%+-1.2a]bc" }, + flagTest{ "%-1.2abc", "[%-1.2a]bc" }, +} func TestFlagParser(t *testing.T) { var flagprinter flagPrinter; @@ -229,10 +229,10 @@ func TestStructPrinter(t *testing.T) { fmt string; out string; } - var tests = []Test ( - Test( "%v", "{abc def 123}" ), - Test( "%+v", "{a=abc b=def c=123}" ), - ); + var tests = []Test { + Test{ "%v", "{abc def 123}" }, + Test{ "%+v", "{a=abc b=def c=123}" }, + }; for i := 0; i < len(tests); i++ { tt := tests[i]; out := fmt.Sprintf(tt.fmt, s); @@ -243,7 +243,7 @@ func TestStructPrinter(t *testing.T) { } func TestArrayPrinter(t *testing.T) { - a := []int(1, 2, 3, 4, 5); + a := []int{1, 2, 3, 4, 5}; want := "[1 2 3 4 5]"; out := fmt.Sprintf("%v", a); if out != want { diff --git a/src/lib/hash/adler32.go b/src/lib/hash/adler32.go index 9bfca550b6..07818992ea 100644 --- a/src/lib/hash/adler32.go +++ b/src/lib/hash/adler32.go @@ -25,7 +25,7 @@ const ( ) func NewDigest() *Digest { - return &Digest(1, 0, 0); + return &Digest{1, 0, 0}; } func (d *Digest) Write(p []byte) (nn int, err *os.Error) { diff --git a/src/lib/hash/adler32_test.go b/src/lib/hash/adler32_test.go index aecf90c746..97b918f131 100644 --- a/src/lib/hash/adler32_test.go +++ b/src/lib/hash/adler32_test.go @@ -15,39 +15,39 @@ type _Adler32Test struct { in string; } -var golden = []_Adler32Test ( - _Adler32Test( 0x1, "" ), - _Adler32Test( 0x620062, "a" ), - _Adler32Test( 0x12600c4, "ab" ), - _Adler32Test( 0x24d0127, "abc" ), - _Adler32Test( 0x3d8018b, "abcd" ), - _Adler32Test( 0x5c801f0, "abcde" ), - _Adler32Test( 0x81e0256, "abcdef" ), - _Adler32Test( 0xadb02bd, "abcdefg" ), - _Adler32Test( 0xe000325, "abcdefgh" ), - _Adler32Test( 0x118e038e, "abcdefghi" ), - _Adler32Test( 0x158603f8, "abcdefghij" ), - _Adler32Test( 0x3f090f02, "Discard medicine more than two years old." ), - _Adler32Test( 0x46d81477, "He who has a shady past knows that nice guys finish last." ), - _Adler32Test( 0x40ee0ee1, "I wouldn't marry him with a ten foot pole." ), - _Adler32Test( 0x16661315, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" ), - _Adler32Test( 0x5b2e1480, "The days of the digital watch are numbered. -Tom Stoppard" ), - _Adler32Test( 0x8c3c09ea, "Nepal premier won't resign." ), - _Adler32Test( 0x45ac18fd, "For every action there is an equal and opposite government program." ), - _Adler32Test( 0x53c61462, "His money is twice tainted: 'taint yours and 'taint mine." ), - _Adler32Test( 0x7e511e63, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" ), - _Adler32Test( 0xe4801a6a, "It's a tiny change to the code and not completely disgusting. - Bob Manchek" ), - _Adler32Test( 0x61b507df, "size: a.out: bad magic" ), - _Adler32Test( 0xb8631171, "The major problem is with sendmail. -Mark Horton" ), - _Adler32Test( 0x8b5e1904, "Give me a rock, paper and scissors and I will move the world. CCFestoon" ), - _Adler32Test( 0x7cc6102b, "If the enemy is within range, then so are you." ), - _Adler32Test( 0x700318e7, "It's well we cannot hear the screams/That we create in others' dreams." ), - _Adler32Test( 0x1e601747, "You remind me of a TV show, but that's all right: I watch it anyway." ), - _Adler32Test( 0xb55b0b09, "C is as portable as Stonehedge!!" ), - _Adler32Test( 0x39111dd0, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" ), - _Adler32Test( 0x91dd304f, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" ), - _Adler32Test( 0x2e5d1316, "How can you write a big system without C++? -Paul Glick" ), -) +var golden = []_Adler32Test { + _Adler32Test{ 0x1, "" }, + _Adler32Test{ 0x620062, "a" }, + _Adler32Test{ 0x12600c4, "ab" }, + _Adler32Test{ 0x24d0127, "abc" }, + _Adler32Test{ 0x3d8018b, "abcd" }, + _Adler32Test{ 0x5c801f0, "abcde" }, + _Adler32Test{ 0x81e0256, "abcdef" }, + _Adler32Test{ 0xadb02bd, "abcdefg" }, + _Adler32Test{ 0xe000325, "abcdefgh" }, + _Adler32Test{ 0x118e038e, "abcdefghi" }, + _Adler32Test{ 0x158603f8, "abcdefghij" }, + _Adler32Test{ 0x3f090f02, "Discard medicine more than two years old." }, + _Adler32Test{ 0x46d81477, "He who has a shady past knows that nice guys finish last." }, + _Adler32Test{ 0x40ee0ee1, "I wouldn't marry him with a ten foot pole." }, + _Adler32Test{ 0x16661315, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" }, + _Adler32Test{ 0x5b2e1480, "The days of the digital watch are numbered. -Tom Stoppard" }, + _Adler32Test{ 0x8c3c09ea, "Nepal premier won't resign." }, + _Adler32Test{ 0x45ac18fd, "For every action there is an equal and opposite government program." }, + _Adler32Test{ 0x53c61462, "His money is twice tainted: 'taint yours and 'taint mine." }, + _Adler32Test{ 0x7e511e63, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" }, + _Adler32Test{ 0xe4801a6a, "It's a tiny change to the code and not completely disgusting. - Bob Manchek" }, + _Adler32Test{ 0x61b507df, "size: a.out: bad magic" }, + _Adler32Test{ 0xb8631171, "The major problem is with sendmail. -Mark Horton" }, + _Adler32Test{ 0x8b5e1904, "Give me a rock, paper and scissors and I will move the world. CCFestoon" }, + _Adler32Test{ 0x7cc6102b, "If the enemy is within range, then so are you." }, + _Adler32Test{ 0x700318e7, "It's well we cannot hear the screams/That we create in others' dreams." }, + _Adler32Test{ 0x1e601747, "You remind me of a TV show, but that's all right: I watch it anyway." }, + _Adler32Test{ 0xb55b0b09, "C is as portable as Stonehedge!!" }, + _Adler32Test{ 0x39111dd0, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" }, + _Adler32Test{ 0x91dd304f, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" }, + _Adler32Test{ 0x2e5d1316, "How can you write a big system without C++? -Paul Glick" }, +} func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { diff --git a/src/lib/hash/crc32.go b/src/lib/hash/crc32.go index 02b2d6cabe..7bfca39d3f 100644 --- a/src/lib/hash/crc32.go +++ b/src/lib/hash/crc32.go @@ -52,7 +52,7 @@ type Digest struct { } func NewDigest(tab Table) *Digest { - return &Digest(0, tab); + return &Digest{0, tab}; } func NewIEEEDigest() *Digest { diff --git a/src/lib/hash/crc32_test.go b/src/lib/hash/crc32_test.go index e827ccc6d5..a2a37cf4ac 100644 --- a/src/lib/hash/crc32_test.go +++ b/src/lib/hash/crc32_test.go @@ -15,39 +15,39 @@ type _Crc32Test struct { in string; } -var golden = []_Crc32Test ( - _Crc32Test( 0x0, "" ), - _Crc32Test( 0xe8b7be43, "a" ), - _Crc32Test( 0x9e83486d, "ab" ), - _Crc32Test( 0x352441c2, "abc" ), - _Crc32Test( 0xed82cd11, "abcd" ), - _Crc32Test( 0x8587d865, "abcde" ), - _Crc32Test( 0x4b8e39ef, "abcdef" ), - _Crc32Test( 0x312a6aa6, "abcdefg" ), - _Crc32Test( 0xaeef2a50, "abcdefgh" ), - _Crc32Test( 0x8da988af, "abcdefghi" ), - _Crc32Test( 0x3981703a, "abcdefghij" ), - _Crc32Test( 0x6b9cdfe7, "Discard medicine more than two years old." ), - _Crc32Test( 0xc90ef73f, "He who has a shady past knows that nice guys finish last." ), - _Crc32Test( 0xb902341f, "I wouldn't marry him with a ten foot pole." ), - _Crc32Test( 0x42080e8, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" ), - _Crc32Test( 0x154c6d11, "The days of the digital watch are numbered. -Tom Stoppard" ), - _Crc32Test( 0x4c418325, "Nepal premier won't resign." ), - _Crc32Test( 0x33955150, "For every action there is an equal and opposite government program." ), - _Crc32Test( 0x26216a4b, "His money is twice tainted: 'taint yours and 'taint mine." ), - _Crc32Test( 0x1abbe45e, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" ), - _Crc32Test( 0xc89a94f7, "It's a tiny change to the code and not completely disgusting. - Bob Manchek" ), - _Crc32Test( 0xab3abe14, "size: a.out: bad magic" ), - _Crc32Test( 0xbab102b6, "The major problem is with sendmail. -Mark Horton" ), - _Crc32Test( 0x999149d7, "Give me a rock, paper and scissors and I will move the world. CCFestoon" ), - _Crc32Test( 0x6d52a33c, "If the enemy is within range, then so are you." ), - _Crc32Test( 0x90631e8d, "It's well we cannot hear the screams/That we create in others' dreams." ), - _Crc32Test( 0x78309130, "You remind me of a TV show, but that's all right: I watch it anyway." ), - _Crc32Test( 0x7d0a377f, "C is as portable as Stonehedge!!" ), - _Crc32Test( 0x8c79fd79, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" ), - _Crc32Test( 0xa20b7167, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" ), - _Crc32Test( 0x8e0bb443, "How can you write a big system without C++? -Paul Glick" ), -) +var golden = []_Crc32Test { + _Crc32Test{ 0x0, "" }, + _Crc32Test{ 0xe8b7be43, "a" }, + _Crc32Test{ 0x9e83486d, "ab" }, + _Crc32Test{ 0x352441c2, "abc" }, + _Crc32Test{ 0xed82cd11, "abcd" }, + _Crc32Test{ 0x8587d865, "abcde" }, + _Crc32Test{ 0x4b8e39ef, "abcdef" }, + _Crc32Test{ 0x312a6aa6, "abcdefg" }, + _Crc32Test{ 0xaeef2a50, "abcdefgh" }, + _Crc32Test{ 0x8da988af, "abcdefghi" }, + _Crc32Test{ 0x3981703a, "abcdefghij" }, + _Crc32Test{ 0x6b9cdfe7, "Discard medicine more than two years old." }, + _Crc32Test{ 0xc90ef73f, "He who has a shady past knows that nice guys finish last." }, + _Crc32Test{ 0xb902341f, "I wouldn't marry him with a ten foot pole." }, + _Crc32Test{ 0x42080e8, "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" }, + _Crc32Test{ 0x154c6d11, "The days of the digital watch are numbered. -Tom Stoppard" }, + _Crc32Test{ 0x4c418325, "Nepal premier won't resign." }, + _Crc32Test{ 0x33955150, "For every action there is an equal and opposite government program." }, + _Crc32Test{ 0x26216a4b, "His money is twice tainted: 'taint yours and 'taint mine." }, + _Crc32Test{ 0x1abbe45e, "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" }, + _Crc32Test{ 0xc89a94f7, "It's a tiny change to the code and not completely disgusting. - Bob Manchek" }, + _Crc32Test{ 0xab3abe14, "size: a.out: bad magic" }, + _Crc32Test{ 0xbab102b6, "The major problem is with sendmail. -Mark Horton" }, + _Crc32Test{ 0x999149d7, "Give me a rock, paper and scissors and I will move the world. CCFestoon" }, + _Crc32Test{ 0x6d52a33c, "If the enemy is within range, then so are you." }, + _Crc32Test{ 0x90631e8d, "It's well we cannot hear the screams/That we create in others' dreams." }, + _Crc32Test{ 0x78309130, "You remind me of a TV show, but that's all right: I watch it anyway." }, + _Crc32Test{ 0x7d0a377f, "C is as portable as Stonehedge!!" }, + _Crc32Test{ 0x8c79fd79, "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" }, + _Crc32Test{ 0xa20b7167, "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" }, + _Crc32Test{ 0x8e0bb443, "How can you write a big system without C++? -Paul Glick" }, +} func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { diff --git a/src/lib/hash/md5_test.go b/src/lib/hash/md5_test.go index b6724fb591..6410346944 100644 --- a/src/lib/hash/md5_test.go +++ b/src/lib/hash/md5_test.go @@ -16,39 +16,39 @@ type md5Test struct { in string; } -var golden = []md5Test ( - md5Test( "d41d8cd98f00b204e9800998ecf8427e", "" ), - md5Test( "0cc175b9c0f1b6a831c399e269772661", "a" ), - md5Test( "187ef4436122d1cc2f40dc2b92f0eba0", "ab" ), - md5Test( "900150983cd24fb0d6963f7d28e17f72", "abc" ), - md5Test( "e2fc714c4727ee9395f324cd2e7f331f", "abcd" ), - md5Test( "ab56b4d92b40713acc5af89985d4b786", "abcde" ), - md5Test( "e80b5017098950fc58aad83c8c14978e", "abcdef" ), - md5Test( "7ac66c0f148de9519b8bd264312c4d64", "abcdefg" ), - md5Test( "e8dc4081b13434b45189a720b77b6818", "abcdefgh" ), - md5Test( "8aa99b1f439ff71293e95357bac6fd94", "abcdefghi" ), - md5Test( "a925576942e94b2ef57a066101b48876", "abcdefghij" ), - md5Test( "d747fc1719c7eacb84058196cfe56d57", "Discard medicine more than two years old." ), - md5Test( "bff2dcb37ef3a44ba43ab144768ca837", "He who has a shady past knows that nice guys finish last." ), - md5Test( "0441015ecb54a7342d017ed1bcfdbea5", "I wouldn't marry him with a ten foot pole." ), - md5Test( "9e3cac8e9e9757a60c3ea391130d3689", "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" ), - md5Test( "a0f04459b031f916a59a35cc482dc039", "The days of the digital watch are numbered. -Tom Stoppard" ), - md5Test( "e7a48e0fe884faf31475d2a04b1362cc", "Nepal premier won't resign." ), - md5Test( "637d2fe925c07c113800509964fb0e06", "For every action there is an equal and opposite government program." ), - md5Test( "834a8d18d5c6562119cf4c7f5086cb71", "His money is twice tainted: 'taint yours and 'taint mine." ), - md5Test( "de3a4d2fd6c73ec2db2abad23b444281", "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" ), - md5Test( "acf203f997e2cf74ea3aff86985aefaf", "It's a tiny change to the code and not completely disgusting. - Bob Manchek" ), - md5Test( "e1c1384cb4d2221dfdd7c795a4222c9a", "size: a.out: bad magic" ), - md5Test( "c90f3ddecc54f34228c063d7525bf644", "The major problem is with sendmail. -Mark Horton" ), - md5Test( "cdf7ab6c1fd49bd9933c43f3ea5af185", "Give me a rock, paper and scissors and I will move the world. CCFestoon" ), - md5Test( "83bc85234942fc883c063cbd7f0ad5d0", "If the enemy is within range, then so are you." ), - md5Test( "277cbe255686b48dd7e8f389394d9299", "It's well we cannot hear the screams/That we create in others' dreams." ), - md5Test( "fd3fb0a7ffb8af16603f3d3af98f8e1f", "You remind me of a TV show, but that's all right: I watch it anyway." ), - md5Test( "469b13a78ebf297ecda64d4723655154", "C is as portable as Stonehedge!!" ), - md5Test( "63eb3a2f466410104731c4b037600110", "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" ), - md5Test( "72c2ed7592debca1c90fc0100f931a2f", "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" ), - md5Test( "132f7619d33b523b1d9e5bd8e0928355", "How can you write a big system without C++? -Paul Glick" ), -) +var golden = []md5Test { + md5Test{ "d41d8cd98f00b204e9800998ecf8427e", "" }, + md5Test{ "0cc175b9c0f1b6a831c399e269772661", "a" }, + md5Test{ "187ef4436122d1cc2f40dc2b92f0eba0", "ab" }, + md5Test{ "900150983cd24fb0d6963f7d28e17f72", "abc" }, + md5Test{ "e2fc714c4727ee9395f324cd2e7f331f", "abcd" }, + md5Test{ "ab56b4d92b40713acc5af89985d4b786", "abcde" }, + md5Test{ "e80b5017098950fc58aad83c8c14978e", "abcdef" }, + md5Test{ "7ac66c0f148de9519b8bd264312c4d64", "abcdefg" }, + md5Test{ "e8dc4081b13434b45189a720b77b6818", "abcdefgh" }, + md5Test{ "8aa99b1f439ff71293e95357bac6fd94", "abcdefghi" }, + md5Test{ "a925576942e94b2ef57a066101b48876", "abcdefghij" }, + md5Test{ "d747fc1719c7eacb84058196cfe56d57", "Discard medicine more than two years old." }, + md5Test{ "bff2dcb37ef3a44ba43ab144768ca837", "He who has a shady past knows that nice guys finish last." }, + md5Test{ "0441015ecb54a7342d017ed1bcfdbea5", "I wouldn't marry him with a ten foot pole." }, + md5Test{ "9e3cac8e9e9757a60c3ea391130d3689", "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" }, + md5Test{ "a0f04459b031f916a59a35cc482dc039", "The days of the digital watch are numbered. -Tom Stoppard" }, + md5Test{ "e7a48e0fe884faf31475d2a04b1362cc", "Nepal premier won't resign." }, + md5Test{ "637d2fe925c07c113800509964fb0e06", "For every action there is an equal and opposite government program." }, + md5Test{ "834a8d18d5c6562119cf4c7f5086cb71", "His money is twice tainted: 'taint yours and 'taint mine." }, + md5Test{ "de3a4d2fd6c73ec2db2abad23b444281", "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" }, + md5Test{ "acf203f997e2cf74ea3aff86985aefaf", "It's a tiny change to the code and not completely disgusting. - Bob Manchek" }, + md5Test{ "e1c1384cb4d2221dfdd7c795a4222c9a", "size: a.out: bad magic" }, + md5Test{ "c90f3ddecc54f34228c063d7525bf644", "The major problem is with sendmail. -Mark Horton" }, + md5Test{ "cdf7ab6c1fd49bd9933c43f3ea5af185", "Give me a rock, paper and scissors and I will move the world. CCFestoon" }, + md5Test{ "83bc85234942fc883c063cbd7f0ad5d0", "If the enemy is within range, then so are you." }, + md5Test{ "277cbe255686b48dd7e8f389394d9299", "It's well we cannot hear the screams/That we create in others' dreams." }, + md5Test{ "fd3fb0a7ffb8af16603f3d3af98f8e1f", "You remind me of a TV show, but that's all right: I watch it anyway." }, + md5Test{ "469b13a78ebf297ecda64d4723655154", "C is as portable as Stonehedge!!" }, + md5Test{ "63eb3a2f466410104731c4b037600110", "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" }, + md5Test{ "72c2ed7592debca1c90fc0100f931a2f", "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" }, + md5Test{ "132f7619d33b523b1d9e5bd8e0928355", "How can you write a big system without C++? -Paul Glick" }, +} func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { diff --git a/src/lib/hash/md5block.go b/src/lib/hash/md5block.go index b5328cb831..7974dbf0b9 100644 --- a/src/lib/hash/md5block.go +++ b/src/lib/hash/md5block.go @@ -11,7 +11,7 @@ package md5 import "md5" // table[i] = int((1<<32) * abs(sin(i+1 radians))). -var table = []uint32 ( +var table = []uint32 { // round 1 0xd76aa478, 0xe8c7b756, @@ -83,12 +83,12 @@ var table = []uint32 ( 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, -) +} -var shift1 = []uint ( 7, 12, 17, 22 ); -var shift2 = []uint ( 5, 9, 14, 20 ); -var shift3 = []uint ( 4, 11, 16, 23 ); -var shift4 = []uint ( 6, 10, 15, 21 ); +var shift1 = []uint { 7, 12, 17, 22 }; +var shift2 = []uint { 5, 9, 14, 20 }; +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]; diff --git a/src/lib/hash/sha1_test.go b/src/lib/hash/sha1_test.go index 02be3a77ba..2dde3973d9 100644 --- a/src/lib/hash/sha1_test.go +++ b/src/lib/hash/sha1_test.go @@ -18,39 +18,39 @@ type sha1Test struct { in string; } -var golden = []sha1Test ( - sha1Test( "da39a3ee5e6b4b0d3255bfef95601890afd80709", "" ), - sha1Test( "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "a" ), - sha1Test( "da23614e02469a0d7c7bd1bdab5c9c474b1904dc", "ab" ), - sha1Test( "a9993e364706816aba3e25717850c26c9cd0d89d", "abc" ), - sha1Test( "81fe8bfe87576c3ecb22426f8e57847382917acf", "abcd" ), - sha1Test( "03de6c570bfe24bfc328ccd7ca46b76eadaf4334", "abcde" ), - sha1Test( "1f8ac10f23c5b5bc1167bda84b833e5c057a77d2", "abcdef" ), - sha1Test( "2fb5e13419fc89246865e7a324f476ec624e8740", "abcdefg" ), - sha1Test( "425af12a0743502b322e93a015bcf868e324d56a", "abcdefgh" ), - sha1Test( "c63b19f1e4c8b5f76b25c49b8b87f57d8e4872a1", "abcdefghi" ), - sha1Test( "d68c19a0a345b7eab78d5e11e991c026ec60db63", "abcdefghij" ), - sha1Test( "ebf81ddcbe5bf13aaabdc4d65354fdf2044f38a7", "Discard medicine more than two years old." ), - sha1Test( "e5dea09392dd886ca63531aaa00571dc07554bb6", "He who has a shady past knows that nice guys finish last." ), - sha1Test( "45988f7234467b94e3e9494434c96ee3609d8f8f", "I wouldn't marry him with a ten foot pole." ), - sha1Test( "55dee037eb7460d5a692d1ce11330b260e40c988", "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" ), - sha1Test( "b7bc5fb91080c7de6b582ea281f8a396d7c0aee8", "The days of the digital watch are numbered. -Tom Stoppard" ), - sha1Test( "c3aed9358f7c77f523afe86135f06b95b3999797", "Nepal premier won't resign." ), - sha1Test( "6e29d302bf6e3a5e4305ff318d983197d6906bb9", "For every action there is an equal and opposite government program." ), - sha1Test( "597f6a540010f94c15d71806a99a2c8710e747bd", "His money is twice tainted: 'taint yours and 'taint mine." ), - sha1Test( "6859733b2590a8a091cecf50086febc5ceef1e80", "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" ), - sha1Test( "514b2630ec089b8aee18795fc0cf1f4860cdacad", "It's a tiny change to the code and not completely disgusting. - Bob Manchek" ), - sha1Test( "c5ca0d4a7b6676fc7aa72caa41cc3d5df567ed69", "size: a.out: bad magic" ), - sha1Test( "74c51fa9a04eadc8c1bbeaa7fc442f834b90a00a", "The major problem is with sendmail. -Mark Horton" ), - sha1Test( "0b4c4ce5f52c3ad2821852a8dc00217fa18b8b66", "Give me a rock, paper and scissors and I will move the world. CCFestoon" ), - sha1Test( "3ae7937dd790315beb0f48330e8642237c61550a", "If the enemy is within range, then so are you." ), - sha1Test( "410a2b296df92b9a47412b13281df8f830a9f44b", "It's well we cannot hear the screams/That we create in others' dreams." ), - sha1Test( "841e7c85ca1adcddbdd0187f1289acb5c642f7f5", "You remind me of a TV show, but that's all right: I watch it anyway." ), - sha1Test( "163173b825d03b952601376b25212df66763e1db", "C is as portable as Stonehedge!!" ), - sha1Test( "32b0377f2687eb88e22106f133c586ab314d5279", "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" ), - sha1Test( "0885aaf99b569542fd165fa44e322718f4a984e0", "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" ), - sha1Test( "6627d6904d71420b0bf3886ab629623538689f45", "How can you write a big system without C++? -Paul Glick" ), -) +var golden = []sha1Test { + sha1Test{ "da39a3ee5e6b4b0d3255bfef95601890afd80709", "" }, + sha1Test{ "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "a" }, + sha1Test{ "da23614e02469a0d7c7bd1bdab5c9c474b1904dc", "ab" }, + sha1Test{ "a9993e364706816aba3e25717850c26c9cd0d89d", "abc" }, + sha1Test{ "81fe8bfe87576c3ecb22426f8e57847382917acf", "abcd" }, + sha1Test{ "03de6c570bfe24bfc328ccd7ca46b76eadaf4334", "abcde" }, + sha1Test{ "1f8ac10f23c5b5bc1167bda84b833e5c057a77d2", "abcdef" }, + sha1Test{ "2fb5e13419fc89246865e7a324f476ec624e8740", "abcdefg" }, + sha1Test{ "425af12a0743502b322e93a015bcf868e324d56a", "abcdefgh" }, + sha1Test{ "c63b19f1e4c8b5f76b25c49b8b87f57d8e4872a1", "abcdefghi" }, + sha1Test{ "d68c19a0a345b7eab78d5e11e991c026ec60db63", "abcdefghij" }, + sha1Test{ "ebf81ddcbe5bf13aaabdc4d65354fdf2044f38a7", "Discard medicine more than two years old." }, + sha1Test{ "e5dea09392dd886ca63531aaa00571dc07554bb6", "He who has a shady past knows that nice guys finish last." }, + sha1Test{ "45988f7234467b94e3e9494434c96ee3609d8f8f", "I wouldn't marry him with a ten foot pole." }, + sha1Test{ "55dee037eb7460d5a692d1ce11330b260e40c988", "Free! Free!/A trip/to Mars/for 900/empty jars/Burma Shave" }, + sha1Test{ "b7bc5fb91080c7de6b582ea281f8a396d7c0aee8", "The days of the digital watch are numbered. -Tom Stoppard" }, + sha1Test{ "c3aed9358f7c77f523afe86135f06b95b3999797", "Nepal premier won't resign." }, + sha1Test{ "6e29d302bf6e3a5e4305ff318d983197d6906bb9", "For every action there is an equal and opposite government program." }, + sha1Test{ "597f6a540010f94c15d71806a99a2c8710e747bd", "His money is twice tainted: 'taint yours and 'taint mine." }, + sha1Test{ "6859733b2590a8a091cecf50086febc5ceef1e80", "There is no reason for any individual to have a computer in their home. -Ken Olsen, 1977" }, + sha1Test{ "514b2630ec089b8aee18795fc0cf1f4860cdacad", "It's a tiny change to the code and not completely disgusting. - Bob Manchek" }, + sha1Test{ "c5ca0d4a7b6676fc7aa72caa41cc3d5df567ed69", "size: a.out: bad magic" }, + sha1Test{ "74c51fa9a04eadc8c1bbeaa7fc442f834b90a00a", "The major problem is with sendmail. -Mark Horton" }, + sha1Test{ "0b4c4ce5f52c3ad2821852a8dc00217fa18b8b66", "Give me a rock, paper and scissors and I will move the world. CCFestoon" }, + sha1Test{ "3ae7937dd790315beb0f48330e8642237c61550a", "If the enemy is within range, then so are you." }, + sha1Test{ "410a2b296df92b9a47412b13281df8f830a9f44b", "It's well we cannot hear the screams/That we create in others' dreams." }, + sha1Test{ "841e7c85ca1adcddbdd0187f1289acb5c642f7f5", "You remind me of a TV show, but that's all right: I watch it anyway." }, + sha1Test{ "163173b825d03b952601376b25212df66763e1db", "C is as portable as Stonehedge!!" }, + sha1Test{ "32b0377f2687eb88e22106f133c586ab314d5279", "Even if I could be Shakespeare, I think I should still choose to be Faraday. - A. Huxley" }, + sha1Test{ "0885aaf99b569542fd165fa44e322718f4a984e0", "The fugacity of a constituent in a mixture of gases at a given temperature is proportional to its mole fraction. Lewis-Randall Rule" }, + sha1Test{ "6627d6904d71420b0bf3886ab629623538689f45", "How can you write a big system without C++? -Paul Glick" }, +} func TestGolden(t *testing.T) { for i := 0; i < len(golden); i++ { diff --git a/src/lib/http/server.go b/src/lib/http/server.go index 086621ae1a..ffb81cc90c 100644 --- a/src/lib/http/server.go +++ b/src/lib/http/server.go @@ -247,7 +247,7 @@ func (h *redirectHandler) ServeHTTP(c *Conn, req *Request) { } func RedirectHandler(to string) Handler { - return &redirectHandler(to); + return &redirectHandler{to}; } // Path-based HTTP request multiplexer. @@ -265,7 +265,7 @@ type ServeMux struct { } func NewServeMux() *ServeMux { - return &ServeMux(make(map[string] Handler)); + return &ServeMux{make(map[string] Handler)}; } var DefaultServeMux = NewServeMux(); diff --git a/src/lib/http/status.go b/src/lib/http/status.go index f7409eb4c5..82a8b214c4 100644 --- a/src/lib/http/status.go +++ b/src/lib/http/status.go @@ -53,7 +53,7 @@ const ( StatusHTTPVersionNotSupported = 505; ) -var statusText = map[int]string ( +var statusText = map[int]string { StatusContinue: "Continue", StatusSwitchingProtocols: "Switching Protocols", @@ -98,5 +98,5 @@ var statusText = map[int]string ( StatusServiceUnavailable: "Service Unavailable", StatusGatewayTimeout: "Gateway Timeout", StatusHTTPVersionNotSupported: "HTTP Version Not Supported", -) +} diff --git a/src/lib/io/io.go b/src/lib/io/io.go index 0325912cd9..e5f02eb709 100644 --- a/src/lib/io/io.go +++ b/src/lib/io/io.go @@ -91,7 +91,7 @@ func MakeFullReader(r Read) Read { // already a fullRead return r } - return &fullRead(r) + return &fullRead{r} } // Copies n bytes (or until EOF is reached) from src to dst. diff --git a/src/lib/io/pipe.go b/src/lib/io/pipe.go index 736f49798c..6ef080f4d4 100644 --- a/src/lib/io/pipe.go +++ b/src/lib/io/pipe.go @@ -58,7 +58,7 @@ func (p *pipe) Read(data []byte) (n int, err *os.Error) { // If write block is done, finish the write. if len(p.wpend) == 0 { p.wpend = nil; - p.cw <- pipeReturn(p.wtot, nil); + p.cw <- pipeReturn{p.wtot, nil}; p.wtot = 0; } @@ -91,7 +91,7 @@ func (p *pipe) CloseReader() *os.Error { // Stop the current write. if !p.wclosed { - p.cw <- pipeReturn(p.wtot, os.EPIPE); + p.cw <- pipeReturn{p.wtot, os.EPIPE}; } return nil; diff --git a/src/lib/io/pipe_test.go b/src/lib/io/pipe_test.go index c187702f2b..9811976002 100644 --- a/src/lib/io/pipe_test.go +++ b/src/lib/io/pipe_test.go @@ -85,7 +85,7 @@ func TestPipe2(t *testing.T) { func writer(w io.WriteClose, buf []byte, c chan pipeReturn) { n, err := w.Write(buf); w.Close(); - c <- pipeReturn(n, err); + c <- pipeReturn{n, err}; } func TestPipe3(t *testing.T) { diff --git a/src/lib/json/generic.go b/src/lib/json/generic.go index 89c6921341..08ae8dc29f 100644 --- a/src/lib/json/generic.go +++ b/src/lib/json/generic.go @@ -45,7 +45,7 @@ func JsonToString(j Json) string { } type _Null struct { } -var Null Json = &_Null() +var Null Json = &_Null{} func (*_Null) Kind() int { return NullKind } func (*_Null) String() string { return "null" } func (*_Null) Number() float64 { return 0 } @@ -240,7 +240,7 @@ func (b *_JsonBuilder) Get() Json { } func (b *_JsonBuilder) Float64(f float64) { - b.Put(&_Number(f, _Null())) + b.Put(&_Number{f, _Null{}}) } func (b *_JsonBuilder) Int64(i int64) { @@ -252,7 +252,7 @@ func (b *_JsonBuilder) Uint64(i uint64) { } func (b *_JsonBuilder) Bool(tf bool) { - b.Put(&_Bool(tf, _Null())) + b.Put(&_Bool{tf, _Null{}}) } func (b *_JsonBuilder) Null() { @@ -260,16 +260,16 @@ func (b *_JsonBuilder) Null() { } func (b *_JsonBuilder) String(s string) { - b.Put(&_String(s, _Null())) + b.Put(&_String{s, _Null{}}) } func (b *_JsonBuilder) Array() { - b.Put(&_Array(array.New(0), _Null())) + b.Put(&_Array{array.New(0), _Null{}}) } func (b *_JsonBuilder) Map() { - b.Put(&_Map(make(map[string]Json), _Null())) + b.Put(&_Map{make(map[string]Json), _Null{}}) } func (b *_JsonBuilder) Elem(i int) Builder { diff --git a/src/lib/json/generic_test.go b/src/lib/json/generic_test.go index 6e409b3e4c..ab3e24fb80 100644 --- a/src/lib/json/generic_test.go +++ b/src/lib/json/generic_test.go @@ -9,7 +9,7 @@ import ( "testing"; ) -var jsontests = []string ( +var jsontests = []string { `null`, `true`, `false`, @@ -22,7 +22,7 @@ var jsontests = []string ( `[1,2,"abc",null,true,false]`, `{}`, `{"a":1}`, -) +} func TestJson(t *testing.T) { for i := 0; i < len(jsontests); i++ { diff --git a/src/lib/json/struct.go b/src/lib/json/struct.go index 7d48dff4b8..82e0a80a7b 100644 --- a/src/lib/json/struct.go +++ b/src/lib/json/struct.go @@ -163,7 +163,7 @@ func (b *_StructBuilder) Elem(i int) Builder { av.SetLen(i+1); } if i < av.Len() { - return &_StructBuilder( av.Elem(i) ) + return &_StructBuilder{ av.Elem(i) } } } return nobuilder @@ -195,7 +195,7 @@ func (b *_StructBuilder) Key(k string) Builder { for i := 0; i < t.Len(); i++ { name, typ, tag, off := t.Field(i); if k == name { - return &_StructBuilder( sv.Field(i) ) + return &_StructBuilder{ sv.Field(i) } } } } @@ -205,7 +205,7 @@ func (b *_StructBuilder) Key(k string) Builder { func Unmarshal(s string, val interface{}) (ok bool, errtok string) { var errindx int; var val1 interface{}; - b := &_StructBuilder( reflect.NewValue(val) ); + b := &_StructBuilder{ reflect.NewValue(val) }; ok, errindx, errtok = Parse(s, b); if !ok { return false, errtok diff --git a/src/lib/log.go b/src/lib/log.go index 6e03709cdc..1134ace32c 100644 --- a/src/lib/log.go +++ b/src/lib/log.go @@ -43,7 +43,7 @@ type Logger struct { } func NewLogger(out0, out1 io.Write, prefix string, flag int) *Logger { - return &Logger(out0, out1, prefix, flag) + return &Logger{out0, out1, prefix, flag} } var ( diff --git a/src/lib/log_test.go b/src/lib/log_test.go index aa8cb6e8e8..23e58b9901 100644 --- a/src/lib/log_test.go +++ b/src/lib/log_test.go @@ -29,21 +29,21 @@ type tester struct { pattern string; // regexp that log output must match; we add ^ and expected_text$ always } -var tests = []tester ( +var tests = []tester { // individual pieces: - tester( 0, "", "" ), - tester( 0, "XXX", "XXX" ), - tester( Lok|Ldate, "", Rdate+" " ), - tester( Lok|Ltime, "", Rtime+" " ), - tester( Lok|Ltime|Lmicroseconds, "", Rtime+Rmicroseconds+" " ), - tester( Lok|Lmicroseconds, "", Rtime+Rmicroseconds+" " ), // microsec implies time - tester( Lok|Llongfile, "", Rlongfile+" " ), - tester( Lok|Lshortfile, "", Rshortfile+" " ), - tester( Lok|Llongfile|Lshortfile, "", Rshortfile+" " ), // shortfile overrides longfile + tester{ 0, "", "" }, + tester{ 0, "XXX", "XXX" }, + tester{ Lok|Ldate, "", Rdate+" " }, + tester{ Lok|Ltime, "", Rtime+" " }, + tester{ Lok|Ltime|Lmicroseconds, "", Rtime+Rmicroseconds+" " }, + tester{ Lok|Lmicroseconds, "", Rtime+Rmicroseconds+" " }, // microsec implies time + tester{ Lok|Llongfile, "", Rlongfile+" " }, + tester{ Lok|Lshortfile, "", Rshortfile+" " }, + tester{ Lok|Llongfile|Lshortfile, "", Rshortfile+" " }, // shortfile overrides longfile // everything at once: - tester( Lok|Ldate|Ltime|Lmicroseconds|Llongfile, "XXX", "XXX"+Rdate+" "+Rtime+Rmicroseconds+" "+Rlongfile+" " ), - tester( Lok|Ldate|Ltime|Lmicroseconds|Lshortfile, "XXX", "XXX"+Rdate+" "+Rtime+Rmicroseconds+" "+Rshortfile+" " ), -) + tester{ Lok|Ldate|Ltime|Lmicroseconds|Llongfile, "XXX", "XXX"+Rdate+" "+Rtime+Rmicroseconds+" "+Rlongfile+" " }, + tester{ Lok|Ldate|Ltime|Lmicroseconds|Lshortfile, "XXX", "XXX"+Rdate+" "+Rtime+Rmicroseconds+" "+Rshortfile+" " }, +} // Test using Log("hello", 23, "world") or using Logf("hello %d world", 23) func testLog(t *testing.T, flag int, prefix string, pattern string, useLogf bool) { diff --git a/src/lib/math/all_test.go b/src/lib/math/all_test.go index 2f01ff9e50..c5d5c01c41 100644 --- a/src/lib/math/all_test.go +++ b/src/lib/math/all_test.go @@ -9,7 +9,7 @@ import ( "testing"; ) -var vf = []float64 ( +var vf = []float64 { 4.9790119248836735e+00, 7.7388724745781045e+00, -2.7688005719200159e-01, @@ -20,8 +20,8 @@ var vf = []float64 ( 2.7279399104360102e+00, 1.8253080916808550e+00, -8.6859247685756013e+00, -) -var asin = []float64 ( +} +var asin = []float64 { 5.2117697218417440e-01, 8.8495619865825236e-01, -2.7691544662819413e-02, @@ -32,8 +32,8 @@ var asin = []float64 ( 2.7629597861677200e-01, 1.8355989225745148e-01, -1.0523547536021498e+00, -) -var atan = []float64 ( +} +var atan = []float64 { 1.3725902621296217e+00, 1.4422906096452980e+00, -2.7011324359471755e-01, @@ -44,8 +44,8 @@ var atan = []float64 ( 1.2194305844639670e+00, 1.0696031952318783e+00, -1.4561721938838085e+00, -) -var exp = []float64 ( +} +var exp = []float64 { 1.4533071302642137e+02, 2.2958822575694450e+03, 7.5814542574851666e-01, @@ -56,8 +56,8 @@ var exp = []float64 ( 1.5301332413189379e+01, 6.2047063430646876e+00, 1.6894712385826522e-04, -) -var floor = []float64 ( +} +var floor = []float64 { 4.0000000000000000e+00, 7.0000000000000000e+00, -1.0000000000000000e+00, @@ -68,8 +68,8 @@ var floor = []float64 ( 2.0000000000000000e+00, 1.0000000000000000e+00, -9.0000000000000000e+00, -) -var log = []float64 ( +} +var log = []float64 { 1.6052314626930630e+00, 2.0462560018708768e+00, -1.2841708730962657e+00, @@ -80,8 +80,8 @@ var log = []float64 ( 1.0035467127723465e+00, 6.0174879014578053e-01, 2.1617038728473527e+00, -) -var pow = []float64 ( +} +var pow = []float64 { 9.5282232631648415e+04, 5.4811599352999900e+07, 5.2859121715894400e-01, @@ -92,8 +92,8 @@ var pow = []float64 ( 5.3449040147551940e+02, 6.6881821384514159e+01, 2.0609869004248744e-09, -) -var sin = []float64 ( +} +var sin = []float64 { -9.6466616586009283e-01, 9.9338225271646543e-01, -2.7335587039794395e-01, @@ -104,8 +104,8 @@ var sin = []float64 ( 4.0195666811555783e-01, 9.6778633541688000e-01, -6.7344058690503452e-01, -) -var sinh = []float64 ( +} +var sinh = []float64 { 7.2661916084208533e+01, 1.1479409110035194e+03, -2.8043136512812520e-01, @@ -116,8 +116,8 @@ var sinh = []float64 ( 7.6179893137269143e+00, 3.0217691805496156e+00, -2.9595057572444951e+03, -) -var sqrt = []float64 ( +} +var sqrt = []float64 { 2.2313699659365484e+00, 2.7818829009464263e+00, 5.2619393496314792e-01, @@ -128,8 +128,8 @@ var sqrt = []float64 ( 1.6516476350711160e+00, 1.3510396336454586e+00, 2.9471892997524950e+00, -) -var tan = []float64 ( +} +var tan = []float64 { -3.6613165650402277e+00, 8.6490023264859754e+00, -2.8417941955033615e-01, @@ -140,8 +140,8 @@ var tan = []float64 ( -4.3898089147528178e-01, -3.8438855602011305e+00, 9.1098879337768517e-01, -) -var tanh = []float64 ( +} +var tanh = []float64 { 9.9990531206936328e-01, 9.9999962057085307e-01, -2.7001505097318680e-01, @@ -152,7 +152,7 @@ var tanh = []float64 ( 9.9149409509772863e-01, 9.4936501296239700e-01, -9.9999994291374019e-01, -) +} func tolerance(a,b,e float64) bool { d := a-b; diff --git a/src/lib/net/dialgoogle_test.go b/src/lib/net/dialgoogle_test.go index 248b90de90..9e4cff4d60 100644 --- a/src/lib/net/dialgoogle_test.go +++ b/src/lib/net/dialgoogle_test.go @@ -50,7 +50,7 @@ func doDialTCP(t *testing.T, network, addr string) { fd.Close() } -var googleaddrs = []string ( +var googleaddrs = []string { "74.125.19.99:80", "www.google.com:80", "74.125.19.99:http", @@ -62,7 +62,7 @@ var googleaddrs = []string ( "[0:0:0:0:000000:ffff:74.125.19.99]:80", "[0:0:0:0:0:ffff::74.125.19.99]:80", "[2001:4860:0:2001::68]:80" // ipv6.google.com; removed if ipv6 flag not set -) +} func TestDialGoogle(t *testing.T) { // If no ipv6 tunnel, don't try the last address. diff --git a/src/lib/net/dnsclient.go b/src/lib/net/dnsclient.go index 499d3663a9..2d75538f3a 100644 --- a/src/lib/net/dnsclient.go +++ b/src/lib/net/dnsclient.go @@ -46,9 +46,9 @@ func _Exchange(cfg *DNS_Config, c Conn, name string) (m *DNS_Msg, err *os.Error) } out := new(DNS_Msg); out.id = 0x1234; - out.question = []DNS_Question( - DNS_Question( name, DNS_TypeA, DNS_ClassINET ) - ); + out.question = []DNS_Question{ + DNS_Question{ name, DNS_TypeA, DNS_ClassINET } + }; out.recursion_desired = true; msg, ok := out.Pack(); if !ok { diff --git a/src/lib/net/dnsmsg.go b/src/lib/net/dnsmsg.go index 245991d249..d9d5ad23cc 100644 --- a/src/lib/net/dnsmsg.go +++ b/src/lib/net/dnsmsg.go @@ -197,7 +197,7 @@ type DNS_RR_A struct { // packing sequence. // Map of constructors for each RR wire type. -var rr_mk = map[int] func()DNS_RR ( +var rr_mk = map[int] func()DNS_RR { DNS_TypeCNAME: func() DNS_RR { return new(DNS_RR_CNAME) }, DNS_TypeHINFO: func() DNS_RR { return new(DNS_RR_HINFO) }, DNS_TypeMB: func() DNS_RR { return new(DNS_RR_MB) }, @@ -210,7 +210,7 @@ var rr_mk = map[int] func()DNS_RR ( DNS_TypeSOA: func() DNS_RR { return new(DNS_RR_SOA) }, DNS_TypeTXT: func() DNS_RR { return new(DNS_RR_TXT) }, DNS_TypeA: func() DNS_RR { return new(DNS_RR_A) }, -) +} // Pack a domain name s into msg[off:]. // Domain names are a sequence of counted strings diff --git a/src/lib/net/ip_test.go b/src/lib/net/ip_test.go index c67a7dd1b1..1626f31565 100644 --- a/src/lib/net/ip_test.go +++ b/src/lib/net/ip_test.go @@ -10,7 +10,7 @@ import ( ) func ipv4(a, b, c, d byte) []byte { - return []byte( 0,0,0,0, 0,0,0,0, 0,0,255,255, a,b,c,d ) + return []byte{ 0,0,0,0, 0,0,0,0, 0,0,255,255, a,b,c,d } } func isEqual(a []byte, b []byte) bool { @@ -32,16 +32,17 @@ type parseIPTest struct { in string; out []byte; } -var parseiptests = []parseIPTest ( - parseIPTest("127.0.1.2", ipv4(127, 0, 1, 2)), - parseIPTest("127.0.0.1", ipv4(127, 0, 0, 1)), - parseIPTest("127.0.0.256", nil), - parseIPTest("abc", nil), - parseIPTest("::ffff:127.0.0.1", ipv4(127, 0, 0, 1)), - parseIPTest("2001:4860:0:2001::68", - []byte(0x20,0x01, 0x48,0x60, 0,0, 0x20,0x01, 0,0, 0,0, 0,0, 0x00,0x68)), - parseIPTest("::ffff:4a7d:1363", ipv4(74, 125, 19, 99)), -) +var parseiptests = []parseIPTest{ + parseIPTest{"127.0.1.2", ipv4(127, 0, 1, 2)}, + parseIPTest{"127.0.0.1", ipv4(127, 0, 0, 1)}, + parseIPTest{"127.0.0.256", nil}, + parseIPTest{"abc", nil}, + parseIPTest{"::ffff:127.0.0.1", ipv4(127, 0, 0, 1)}, + parseIPTest{"2001:4860:0:2001::68", + []byte{0x20,0x01, 0x48,0x60, 0,0, 0x20,0x01, + 0,0, 0,0, 0,0, 0x00,0x68}}, + parseIPTest{"::ffff:4a7d:1363", ipv4(74, 125, 19, 99)}, +} func TestParseIP(t *testing.T) { for i := 0; i < len(parseiptests); i++ { diff --git a/src/lib/net/net_darwin.go b/src/lib/net/net_darwin.go index 2d5d11ee9d..d31ea52acc 100644 --- a/src/lib/net/net_darwin.go +++ b/src/lib/net/net_darwin.go @@ -24,7 +24,7 @@ func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) { for i := 0; i < IPv4len; i++ { sa.Addr[i] = p[i] } - return unsafe.Pointer(sa).(*syscall.Sockaddr), nil + return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil } func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) { @@ -40,21 +40,21 @@ func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) { for i := 0; i < IPv6len; i++ { sa.Addr[i] = p[i] } - return unsafe.Pointer(sa).(*syscall.Sockaddr), nil + return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil } func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Error) { switch sa1.Family { case syscall.AF_INET: - sa := unsafe.Pointer(sa1).(*syscall.SockaddrInet4); + sa := (*syscall.SockaddrInet4)(unsafe.Pointer(sa1)); a := ToIPv6(sa.Addr); if a == nil { return nil, 0, os.EINVAL } return a, int(sa.Port[0])<<8 + int(sa.Port[1]), nil; case syscall.AF_INET6: - sa := unsafe.Pointer(sa1).(*syscall.SockaddrInet6); + sa := (*syscall.SockaddrInet6)(unsafe.Pointer(sa1)); a := ToIPv6(sa.Addr); if a == nil { return nil, 0, os.EINVAL diff --git a/src/lib/net/net_linux.go b/src/lib/net/net_linux.go index 01274c92f3..7041277949 100644 --- a/src/lib/net/net_linux.go +++ b/src/lib/net/net_linux.go @@ -23,7 +23,7 @@ func IPv4ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) { for i := 0; i < IPv4len; i++ { sa.Addr[i] = p[i] } - return unsafe.Pointer(sa).(*syscall.Sockaddr), nil + return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil } var ipv6zero [16]byte; @@ -48,20 +48,20 @@ func IPv6ToSockaddr(p []byte, port int) (sa1 *syscall.Sockaddr, err *os.Error) { for i := 0; i < IPv6len; i++ { sa.Addr[i] = p[i] } - return unsafe.Pointer(sa).(*syscall.Sockaddr), nil + return (*syscall.Sockaddr)(unsafe.Pointer(sa)), nil } func SockaddrToIP(sa1 *syscall.Sockaddr) (p []byte, port int, err *os.Error) { switch sa1.Family { case syscall.AF_INET: - sa := unsafe.Pointer(sa1).(*syscall.SockaddrInet4); + sa := (*syscall.SockaddrInet4)(unsafe.Pointer(sa1)); a := ToIPv6(sa.Addr); if a == nil { return nil, 0, os.EINVAL } return a, int(sa.Port[0])<<8 + int(sa.Port[1]), nil; case syscall.AF_INET6: - sa := unsafe.Pointer(sa1).(*syscall.SockaddrInet6); + sa := (*syscall.SockaddrInet6)(unsafe.Pointer(sa1)); a := ToIPv6(sa.Addr); if a == nil { return nil, 0, os.EINVAL diff --git a/src/lib/net/parse.go b/src/lib/net/parse.go index b8a13e32d9..e1f55f19a4 100644 --- a/src/lib/net/parse.go +++ b/src/lib/net/parse.go @@ -60,7 +60,7 @@ func open(name string) *file { if err != nil { return nil } - return &file(fd, make([]byte, 1024)[0:0]); + return &file{fd, make([]byte, 1024)[0:0]}; } func byteIndex(s string, c byte) int { diff --git a/src/lib/net/port_test.go b/src/lib/net/port_test.go index f48ced0754..f6123fd8d5 100644 --- a/src/lib/net/port_test.go +++ b/src/lib/net/port_test.go @@ -16,37 +16,37 @@ type portTest struct { ok bool; } -var porttests = []portTest ( - portTest( "tcp", "echo", 7, true ), - portTest( "tcp", "discard", 9, true ), - portTest( "tcp", "systat", 11, true ), - portTest( "tcp", "daytime", 13, true ), - portTest( "tcp", "chargen", 19, true ), - portTest( "tcp", "ftp-data", 20, true ), - portTest( "tcp", "ftp", 21, true ), - portTest( "tcp", "ssh", 22, true ), - portTest( "tcp", "telnet", 23, true ), - portTest( "tcp", "smtp", 25, true ), - portTest( "tcp", "time", 37, true ), - portTest( "tcp", "domain", 53, true ), - portTest( "tcp", "gopher", 70, true ), - portTest( "tcp", "finger", 79, true ), - portTest( "tcp", "http", 80, true ), +var porttests = []portTest { + portTest{ "tcp", "echo", 7, true }, + portTest{ "tcp", "discard", 9, true }, + portTest{ "tcp", "systat", 11, true }, + portTest{ "tcp", "daytime", 13, true }, + portTest{ "tcp", "chargen", 19, true }, + portTest{ "tcp", "ftp-data", 20, true }, + portTest{ "tcp", "ftp", 21, true }, + portTest{ "tcp", "ssh", 22, true }, + portTest{ "tcp", "telnet", 23, true }, + portTest{ "tcp", "smtp", 25, true }, + portTest{ "tcp", "time", 37, true }, + portTest{ "tcp", "domain", 53, true }, + portTest{ "tcp", "gopher", 70, true }, + portTest{ "tcp", "finger", 79, true }, + portTest{ "tcp", "http", 80, true }, - portTest( "udp", "echo", 7, true ), - portTest( "udp", "tacacs", 49, true ), - portTest( "udp", "tftp", 69, true ), - portTest( "udp", "bootpc", 68, true ), - portTest( "udp", "bootps", 67, true ), - portTest( "udp", "domain", 53, true ), - portTest( "udp", "ntp", 123, true ), - portTest( "udp", "snmp", 161, true ), - portTest( "udp", "syslog", 514, true ), - portTest( "udp", "nfs", 2049, true ), + portTest{ "udp", "echo", 7, true }, + portTest{ "udp", "tacacs", 49, true }, + portTest{ "udp", "tftp", 69, true }, + portTest{ "udp", "bootpc", 68, true }, + portTest{ "udp", "bootps", 67, true }, + portTest{ "udp", "domain", 53, true }, + portTest{ "udp", "ntp", 123, true }, + portTest{ "udp", "snmp", 161, true }, + portTest{ "udp", "syslog", 514, true }, + portTest{ "udp", "nfs", 2049, true }, - portTest( "--badnet--", "zzz", 0, false ), - portTest( "tcp", "--badport--", 0, false ), -) + portTest{ "--badnet--", "zzz", 0, false }, + portTest{ "tcp", "--badport--", 0, false }, +} func TestLookupPort(t *testing.T) { for i := 0; i < len(porttests); i++ { diff --git a/src/lib/os/dir_amd64_darwin.go b/src/lib/os/dir_amd64_darwin.go index 2821076dc6..41f6211359 100644 --- a/src/lib/os/dir_amd64_darwin.go +++ b/src/lib/os/dir_amd64_darwin.go @@ -45,7 +45,7 @@ func Readdirnames(fd *FD, count int) (names []string, err *os.Error) { } // Drain the buffer for count != 0 && d.bufp < d.nbuf { - dirent := unsafe.Pointer(&d.buf[d.bufp]).(*syscall.Dirent); + dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int64(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. continue diff --git a/src/lib/os/dir_amd64_linux.go b/src/lib/os/dir_amd64_linux.go index f73febc4c7..7a2ec73004 100644 --- a/src/lib/os/dir_amd64_linux.go +++ b/src/lib/os/dir_amd64_linux.go @@ -42,7 +42,7 @@ func Readdirnames(fd *FD, count int) (names []string, err *os.Error) { // Refill the buffer if necessary if d.bufp == d.nbuf { var errno int64; - dbuf := unsafe.Pointer(&d.buf[0]).(*syscall.Dirent); + dbuf := (*syscall.Dirent)(unsafe.Pointer(&d.buf[0])); d.nbuf, errno = syscall.Getdents(fd.fd, dbuf, int64(len(d.buf))); if d.nbuf < 0 { return names, os.ErrnoToError(errno) @@ -54,7 +54,7 @@ func Readdirnames(fd *FD, count int) (names []string, err *os.Error) { } // Drain the buffer for count != 0 && d.bufp < d.nbuf { - dirent := unsafe.Pointer(&d.buf[d.bufp]).(*syscall.Dirent); + dirent := (*syscall.Dirent)(unsafe.Pointer(&d.buf[d.bufp])); d.bufp += int64(dirent.Reclen); if dirent.Ino == 0 { // File absent in directory. continue diff --git a/src/lib/os/error.go b/src/lib/os/error.go index d85d237aa8..63b2dbccac 100644 --- a/src/lib/os/error.go +++ b/src/lib/os/error.go @@ -33,7 +33,7 @@ func NewError(s string) *Error { if ok { return err } - err = &Error(s); + err = &Error{s}; errorStringTab[s] = err; return err; } diff --git a/src/lib/os/file.go b/src/lib/os/file.go index 24aab1256d..b41f2418eb 100644 --- a/src/lib/os/file.go +++ b/src/lib/os/file.go @@ -35,7 +35,7 @@ func NewFD(fd int64, name string) *FD { if fd < 0 { return nil } - return &FD(fd, name, nil) + return &FD{fd, name, nil} } var ( diff --git a/src/lib/os/os_test.go b/src/lib/os/os_test.go index 354d7c4eed..535008e1d5 100644 --- a/src/lib/os/os_test.go +++ b/src/lib/os/os_test.go @@ -10,7 +10,7 @@ import ( "testing"; ) -var dot = []string( +var dot = []string{ "dir_amd64_darwin.go", "dir_amd64_linux.go", "env.go", @@ -21,13 +21,13 @@ var dot = []string( "types.go", "stat_amd64_darwin.go", "stat_amd64_linux.go" -) +} -var etc = []string( +var etc = []string{ "group", "hosts", "passwd", -) +} func size(file string, t *testing.T) uint64 { fd, err := Open(file, O_RDONLY, 0); diff --git a/src/lib/reflect/all_test.go b/src/lib/reflect/all_test.go index 828e287aa6..f6428fdf38 100644 --- a/src/lib/reflect/all_test.go +++ b/src/lib/reflect/all_test.go @@ -168,7 +168,7 @@ func TestAll(tt *testing.T) { // TODO(r): wrap up better } { var i int = 7; - var tmp = &T(123, 456.75, "hello", &i); + var tmp = &T{123, 456.75, "hello", &i}; value := reflect.NewValue(tmp); assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "reflect.T{123, 456.75, hello, *int(@)}"); } @@ -188,7 +188,7 @@ func TestAll(tt *testing.T) { // TODO(r): wrap up better // } { type AA []int; - var tmp = AA(1,2,3,4,5,6,7,8,9,10); + var tmp = AA{1,2,3,4,5,6,7,8,9,10}; value := reflect.NewValue(&tmp); // TODO: NewValue(tmp) too assert(reflect.ValueToString(value.(reflect.PtrValue).Sub()), "reflect.AA·all_test{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"); value.(reflect.PtrValue).Sub().(reflect.ArrayValue).Elem(4).(reflect.IntValue).Set(123); @@ -297,9 +297,9 @@ func TestInterfaceGet(t *testing.T) { } func TestCopyArray(t *testing.T) { - a := []int( 1, 2, 3, 4, 10, 9, 8, 7 ); - b := []int( 11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44 ); - c := []int( 11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44 ); + a := []int{ 1, 2, 3, 4, 10, 9, 8, 7 }; + b := []int{ 11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44 }; + c := []int{ 11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44 }; va := NewValue(&a); vb := NewValue(&b); for i := 0; i < len(b); i++ { @@ -332,7 +332,7 @@ func TestCopyArray(t *testing.T) { } func TestBigUnnamedStruct(t *testing.T) { - b := struct{a,b,c,d int64}(1, 2, 3, 4); + b := struct{a,b,c,d int64}{1, 2, 3, 4}; v := NewValue(b); b1 := v.Interface().(struct{a,b,c,d int64}); if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d { @@ -344,7 +344,7 @@ type big struct { a, b, c, d, e int64 } func TestBigStruct(t *testing.T) { - b := big(1, 2, 3, 4, 5); + b := big{1, 2, 3, 4, 5}; v := NewValue(b); b1 := v.Interface().(big); if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e { diff --git a/src/lib/reflect/type.go b/src/lib/reflect/type.go index 31de06ce42..438f5b2323 100644 --- a/src/lib/reflect/type.go +++ b/src/lib/reflect/type.go @@ -101,7 +101,7 @@ type basicType struct { } func newBasicType(name string, kind int, size int) Type { - return &basicType( commonType(kind, name, name, size) ) + return &basicType{ commonType{kind, name, name, size} } } // Prebuilt basic types @@ -136,7 +136,7 @@ type stubType struct { } func newStubType(name string, typ Type) *stubType { - return &stubType(name, typ) + return &stubType{name, typ} } func (t *stubType) Get() Type { @@ -159,7 +159,7 @@ type ptrTypeStruct struct { } func newPtrTypeStruct(name, typestring string, sub *stubType) *ptrTypeStruct { - return &ptrTypeStruct( commonType(PtrKind, typestring, name, ptrsize), sub) + return &ptrTypeStruct{ commonType{PtrKind, typestring, name, ptrsize}, sub} } func (t *ptrTypeStruct) Sub() Type { @@ -183,7 +183,7 @@ type arrayTypeStruct struct { } func newArrayTypeStruct(name, typestring string, open bool, len int, elem *stubType) *arrayTypeStruct { - return &arrayTypeStruct( commonType(ArrayKind, typestring, name, 0), elem, open, len) + return &arrayTypeStruct{ commonType{ArrayKind, typestring, name, 0}, elem, open, len} } func (t *arrayTypeStruct) Size() int { @@ -221,7 +221,7 @@ type mapTypeStruct struct { } func newMapTypeStruct(name, typestring string, key, elem *stubType) *mapTypeStruct { - return &mapTypeStruct( commonType(MapKind, typestring, name, ptrsize), key, elem) + return &mapTypeStruct{ commonType{MapKind, typestring, name, ptrsize}, key, elem} } func (t *mapTypeStruct) Key() Type { @@ -253,7 +253,7 @@ type chanTypeStruct struct { } func newChanTypeStruct(name, typestring string, dir int, elem *stubType) *chanTypeStruct { - return &chanTypeStruct( commonType(ChanKind, typestring, name, ptrsize), elem, dir) + return &chanTypeStruct{ commonType{ChanKind, typestring, name, ptrsize}, elem, dir} } func (t *chanTypeStruct) Dir() int { @@ -286,7 +286,7 @@ type structTypeStruct struct { } func newStructTypeStruct(name, typestring string, field []structField) *structTypeStruct { - return &structTypeStruct( commonType(StructKind, typestring, name, 0), field) + return &structTypeStruct{ commonType{StructKind, typestring, name, 0}, field} } // TODO: not portable; depends on 6g @@ -339,7 +339,7 @@ type interfaceTypeStruct struct { } func newInterfaceTypeStruct(name, typestring string, field []structField) *interfaceTypeStruct { - return &interfaceTypeStruct( commonType(InterfaceKind, typestring, name, interfacesize), field ) + return &interfaceTypeStruct{ commonType{InterfaceKind, typestring, name, interfacesize}, field } } func (t *interfaceTypeStruct) Field(i int) (name string, typ Type, tag string, offset int) { @@ -367,7 +367,7 @@ type funcTypeStruct struct { } func newFuncTypeStruct(name, typestring string, in, out *structTypeStruct) *funcTypeStruct { - return &funcTypeStruct( commonType(FuncKind, typestring, name, 0), in, out ) + return &funcTypeStruct{ commonType{FuncKind, typestring, name, 0}, in, out } } func (t *funcTypeStruct) Size() int { diff --git a/src/lib/reflect/value.go b/src/lib/reflect/value.go index ba430c22d7..9056d74d59 100644 --- a/src/lib/reflect/value.go +++ b/src/lib/reflect/value.go @@ -48,12 +48,12 @@ func (c *commonValue) Addr() Addr { func (c *commonValue) Interface() interface {} { var i interface {}; if c.typ.Size() > 8 { // TODO(rsc): how do we know it is 8? - i = sys.Unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true); + i = sys.Unreflect(uint64(uintptr(c.addr)), c.typ.String(), true); } else { if uintptr(c.addr) == 0 { panicln("reflect: address 0 for", c.typ.String()); } - i = sys.Unreflect(uint64(uintptr(*c.addr.(*Addr))), c.typ.String(), false); + i = sys.Unreflect(uint64(uintptr(*(*Addr)(c.addr))), c.typ.String(), false); } return i; } @@ -74,7 +74,7 @@ type missingValueStruct struct { } func missingCreator(typ Type, addr Addr) Value { - return &missingValueStruct( commonValue(MissingKind, typ, addr) ) + return &missingValueStruct{ commonValue{MissingKind, typ, addr} } } // -- Int @@ -90,15 +90,15 @@ type intValueStruct struct { } func intCreator(typ Type, addr Addr) Value { - return &intValueStruct( commonValue(IntKind, typ, addr) ) + return &intValueStruct{ commonValue{IntKind, typ, addr} } } func (v *intValueStruct) Get() int { - return *v.addr.(*int) + return *(*int)(v.addr) } func (v *intValueStruct) Set(i int) { - *v.addr.(*int) = i + *(*int)(v.addr) = i } // -- Int8 @@ -114,15 +114,15 @@ type int8ValueStruct struct { } func int8Creator(typ Type, addr Addr) Value { - return &int8ValueStruct( commonValue(Int8Kind, typ, addr) ) + return &int8ValueStruct{ commonValue{Int8Kind, typ, addr} } } func (v *int8ValueStruct) Get() int8 { - return *v.addr.(*int8) + return *(*int8)(v.addr) } func (v *int8ValueStruct) Set(i int8) { - *v.addr.(*int8) = i + *(*int8)(v.addr) = i } // -- Int16 @@ -138,15 +138,15 @@ type int16ValueStruct struct { } func int16Creator(typ Type, addr Addr) Value { - return &int16ValueStruct( commonValue(Int16Kind, typ, addr) ) + return &int16ValueStruct{ commonValue{Int16Kind, typ, addr} } } func (v *int16ValueStruct) Get() int16 { - return *v.addr.(*int16) + return *(*int16)(v.addr) } func (v *int16ValueStruct) Set(i int16) { - *v.addr.(*int16) = i + *(*int16)(v.addr) = i } // -- Int32 @@ -162,15 +162,15 @@ type int32ValueStruct struct { } func int32Creator(typ Type, addr Addr) Value { - return &int32ValueStruct( commonValue(Int32Kind, typ, addr) ) + return &int32ValueStruct{ commonValue{Int32Kind, typ, addr} } } func (v *int32ValueStruct) Get() int32 { - return *v.addr.(*int32) + return *(*int32)(v.addr) } func (v *int32ValueStruct) Set(i int32) { - *v.addr.(*int32) = i + *(*int32)(v.addr) = i } // -- Int64 @@ -186,15 +186,15 @@ type int64ValueStruct struct { } func int64Creator(typ Type, addr Addr) Value { - return &int64ValueStruct( commonValue(Int64Kind, typ, addr) ) + return &int64ValueStruct{ commonValue{Int64Kind, typ, addr} } } func (v *int64ValueStruct) Get() int64 { - return *v.addr.(*int64) + return *(*int64)(v.addr) } func (v *int64ValueStruct) Set(i int64) { - *v.addr.(*int64) = i + *(*int64)(v.addr) = i } // -- Uint @@ -210,15 +210,15 @@ type uintValueStruct struct { } func uintCreator(typ Type, addr Addr) Value { - return &uintValueStruct( commonValue(UintKind, typ, addr) ) + return &uintValueStruct{ commonValue{UintKind, typ, addr} } } func (v *uintValueStruct) Get() uint { - return *v.addr.(*uint) + return *(*uint)(v.addr) } func (v *uintValueStruct) Set(i uint) { - *v.addr.(*uint) = i + *(*uint)(v.addr) = i } // -- Uint8 @@ -234,15 +234,15 @@ type uint8ValueStruct struct { } func uint8Creator(typ Type, addr Addr) Value { - return &uint8ValueStruct( commonValue(Uint8Kind, typ, addr) ) + return &uint8ValueStruct{ commonValue{Uint8Kind, typ, addr} } } func (v *uint8ValueStruct) Get() uint8 { - return *v.addr.(*uint8) + return *(*uint8)(v.addr) } func (v *uint8ValueStruct) Set(i uint8) { - *v.addr.(*uint8) = i + *(*uint8)(v.addr) = i } // -- Uint16 @@ -258,15 +258,15 @@ type uint16ValueStruct struct { } func uint16Creator(typ Type, addr Addr) Value { - return &uint16ValueStruct( commonValue(Uint16Kind, typ, addr) ) + return &uint16ValueStruct{ commonValue{Uint16Kind, typ, addr} } } func (v *uint16ValueStruct) Get() uint16 { - return *v.addr.(*uint16) + return *(*uint16)(v.addr) } func (v *uint16ValueStruct) Set(i uint16) { - *v.addr.(*uint16) = i + *(*uint16)(v.addr) = i } // -- Uint32 @@ -282,15 +282,15 @@ type uint32ValueStruct struct { } func uint32Creator(typ Type, addr Addr) Value { - return &uint32ValueStruct( commonValue(Uint32Kind, typ, addr) ) + return &uint32ValueStruct{ commonValue{Uint32Kind, typ, addr} } } func (v *uint32ValueStruct) Get() uint32 { - return *v.addr.(*uint32) + return *(*uint32)(v.addr) } func (v *uint32ValueStruct) Set(i uint32) { - *v.addr.(*uint32) = i + *(*uint32)(v.addr) = i } // -- Uint64 @@ -306,15 +306,15 @@ type uint64ValueStruct struct { } func uint64Creator(typ Type, addr Addr) Value { - return &uint64ValueStruct( commonValue(Uint64Kind, typ, addr) ) + return &uint64ValueStruct{ commonValue{Uint64Kind, typ, addr} } } func (v *uint64ValueStruct) Get() uint64 { - return *v.addr.(*uint64) + return *(*uint64)(v.addr) } func (v *uint64ValueStruct) Set(i uint64) { - *v.addr.(*uint64) = i + *(*uint64)(v.addr) = i } // -- Uintptr @@ -330,15 +330,15 @@ type uintptrValueStruct struct { } func uintptrCreator(typ Type, addr Addr) Value { - return &uintptrValueStruct( commonValue(UintptrKind, typ, addr) ) + return &uintptrValueStruct{ commonValue{UintptrKind, typ, addr} } } func (v *uintptrValueStruct) Get() uintptr { - return *v.addr.(*uintptr) + return *(*uintptr)(v.addr) } func (v *uintptrValueStruct) Set(i uintptr) { - *v.addr.(*uintptr) = i + *(*uintptr)(v.addr) = i } // -- Float @@ -354,15 +354,15 @@ type floatValueStruct struct { } func floatCreator(typ Type, addr Addr) Value { - return &floatValueStruct( commonValue(FloatKind, typ, addr) ) + return &floatValueStruct{ commonValue{FloatKind, typ, addr} } } func (v *floatValueStruct) Get() float { - return *v.addr.(*float) + return *(*float)(v.addr) } func (v *floatValueStruct) Set(f float) { - *v.addr.(*float) = f + *(*float)(v.addr) = f } // -- Float32 @@ -378,15 +378,15 @@ type float32ValueStruct struct { } func float32Creator(typ Type, addr Addr) Value { - return &float32ValueStruct( commonValue(Float32Kind, typ, addr) ) + return &float32ValueStruct{ commonValue{Float32Kind, typ, addr} } } func (v *float32ValueStruct) Get() float32 { - return *v.addr.(*float32) + return *(*float32)(v.addr) } func (v *float32ValueStruct) Set(f float32) { - *v.addr.(*float32) = f + *(*float32)(v.addr) = f } // -- Float64 @@ -402,15 +402,15 @@ type float64ValueStruct struct { } func float64Creator(typ Type, addr Addr) Value { - return &float64ValueStruct( commonValue(Float64Kind, typ, addr) ) + return &float64ValueStruct{ commonValue{Float64Kind, typ, addr} } } func (v *float64ValueStruct) Get() float64 { - return *v.addr.(*float64) + return *(*float64)(v.addr) } func (v *float64ValueStruct) Set(f float64) { - *v.addr.(*float64) = f + *(*float64)(v.addr) = f } // -- Float80 @@ -426,17 +426,17 @@ type float80ValueStruct struct { } func float80Creator(typ Type, addr Addr) Value { - return &float80ValueStruct( commonValue(Float80Kind, typ, addr) ) + return &float80ValueStruct{ commonValue{Float80Kind, typ, addr} } } /* BUG: can't gen code for float80s func (v *Float80ValueStruct) Get() float80 { - return *v.addr.(*float80) + return *(*float80)(v.addr) } func (v *Float80ValueStruct) Set(f float80) { - *v.addr.(*float80) = f + *(*float80)(v.addr) = f } */ @@ -453,15 +453,15 @@ type stringValueStruct struct { } func stringCreator(typ Type, addr Addr) Value { - return &stringValueStruct( commonValue(StringKind, typ, addr) ) + return &stringValueStruct{ commonValue{StringKind, typ, addr} } } func (v *stringValueStruct) Get() string { - return *v.addr.(*string) + return *(*string)(v.addr) } func (v *stringValueStruct) Set(s string) { - *v.addr.(*string) = s + *(*string)(v.addr) = s } // -- Bool @@ -477,15 +477,15 @@ type boolValueStruct struct { } func boolCreator(typ Type, addr Addr) Value { - return &boolValueStruct( commonValue(BoolKind, typ, addr) ) + return &boolValueStruct{ commonValue{BoolKind, typ, addr} } } func (v *boolValueStruct) Get() bool { - return *v.addr.(*bool) + return *(*bool)(v.addr) } func (v *boolValueStruct) Set(b bool) { - *v.addr.(*bool) = b + *(*bool)(v.addr) = b } // -- Pointer @@ -502,7 +502,7 @@ type ptrValueStruct struct { } func (v *ptrValueStruct) Get() Addr { - return *v.addr.(*Addr) + return *(*Addr)(v.addr) } func (v *ptrValueStruct) Sub() Value { @@ -516,11 +516,11 @@ func (v *ptrValueStruct) SetSub(subv Value) { panicln("reflect: incompatible types in PtrValue.SetSub:", a.String(), b.String()); } - *v.addr.(*Addr) = subv.Addr(); + *(*Addr)(v.addr) = subv.Addr(); } func ptrCreator(typ Type, addr Addr) Value { - return &ptrValueStruct( commonValue(PtrKind, typ, addr) ); + return &ptrValueStruct{ commonValue{PtrKind, typ, addr} }; } // -- Array @@ -644,7 +644,7 @@ func arrayCreator(typ Type, addr Addr) Value { v.typ = typ; v.elemtype = arraytype.Elem(); v.elemsize = v.elemtype.Size(); - v.slice = addr.(*runtimeSlice); + v.slice = (*runtimeSlice)(addr); return v; } v := new(arrayValueStruct); @@ -670,7 +670,7 @@ type mapValueStruct struct { } func mapCreator(typ Type, addr Addr) Value { - return &mapValueStruct( commonValue(MapKind, typ, addr) ) + return &mapValueStruct{ commonValue{MapKind, typ, addr} } } func (v *mapValueStruct) Len() int { @@ -693,7 +693,7 @@ type chanValueStruct struct { } func chanCreator(typ Type, addr Addr) Value { - return &chanValueStruct( commonValue(ChanKind, typ, addr) ) + return &chanValueStruct{ commonValue{ChanKind, typ, addr} } } // -- Struct @@ -720,7 +720,7 @@ func (v *structValueStruct) Field(i int) Value { func structCreator(typ Type, addr Addr) Value { t := typ.(StructType); nfield := t.Len(); - v := &structValueStruct( commonValue(StructKind, typ, addr), make([]Value, nfield) ); + v := &structValueStruct{ commonValue{StructKind, typ, addr}, make([]Value, nfield) }; for i := 0; i < nfield; i++ { name, ftype, str, offset := t.Field(i); addr_uint := uintptr(addr) + uintptr(offset); @@ -742,11 +742,11 @@ type interfaceValueStruct struct { } func (v *interfaceValueStruct) Get() interface{} { - return *v.addr.(*interface{}) + return *(*interface{})(v.addr) } func interfaceCreator(typ Type, addr Addr) Value { - return &interfaceValueStruct( commonValue(InterfaceKind, typ, addr) ) + return &interfaceValueStruct{ commonValue{InterfaceKind, typ, addr} } } // -- Func @@ -760,10 +760,10 @@ type funcValueStruct struct { } func funcCreator(typ Type, addr Addr) Value { - return &funcValueStruct( commonValue(FuncKind, typ, addr) ) + return &funcValueStruct{ commonValue{FuncKind, typ, addr} } } -var creator = map[int] creatorFn ( +var creator = map[int] creatorFn { MissingKind : missingCreator, IntKind : intCreator, Int8Kind : int8Creator, @@ -789,7 +789,7 @@ var creator = map[int] creatorFn ( StructKind : structCreator, InterfaceKind : interfaceCreator, FuncKind : funcCreator, -) +} var typecache = make(map[string] Type); @@ -858,13 +858,13 @@ func copyArray(dst ArrayValue, src ArrayValue, n int) { for i := uintptr(0); i < end; i += 8{ di := Addr(dstp + i); si := Addr(srcp + i); - *di.(*uint64) = *si.(*uint64); + *(*uint64)(di) = *(*uint64)(si); } } else { for i := uintptr(0); i < end; i++ { di := Addr(dstp + i); si := Addr(srcp + i); - *di.(*byte) = *si.(*byte); + *(*byte)(di) = *(*byte)(si); } } } @@ -880,12 +880,12 @@ func NewValue(e interface {}) Value { if indir { // Content of interface is a pointer. - return newValueAddr(typ, value.(uintptr).(Addr)); + return newValueAddr(typ, Addr(uintptr(value))); } // Content of interface is a value; // need a permanent copy to take its address. ap := new(uint64); *ap = value; - return newValueAddr(typ, ap.(Addr)); + return newValueAddr(typ, Addr(ap)); } diff --git a/src/lib/regexp/all_test.go b/src/lib/regexp/all_test.go index 3c2e8bacdf..5e9754934f 100644 --- a/src/lib/regexp/all_test.go +++ b/src/lib/regexp/all_test.go @@ -10,7 +10,7 @@ import ( "testing"; ) -var good_re = []string( +var good_re = []string{ ``, `.`, `^.$`, @@ -27,27 +27,27 @@ var good_re = []string( `[]`, `[abc]`, `[^1234]`, -) +} // TODO: nice to do this with a map type stringError struct { re string; err *os.Error; } -var bad_re = []stringError( - stringError( `*`, regexp.ErrBareClosure ), - stringError( `(abc`, regexp.ErrUnmatchedLpar ), - stringError( `abc)`, regexp.ErrUnmatchedRpar ), - stringError( `x[a-z`, regexp.ErrUnmatchedLbkt ), - stringError( `abc]`, regexp.ErrUnmatchedRbkt ), - stringError( `[z-a]`, regexp.ErrBadRange ), - stringError( `abc\`, regexp.ErrExtraneousBackslash ), - stringError( `a**`, regexp.ErrBadClosure ), - stringError( `a*+`, regexp.ErrBadClosure ), - stringError( `a??`, regexp.ErrBadClosure ), - stringError( `*`, regexp.ErrBareClosure ), - stringError( `\x`, regexp.ErrBadBackslash ), -) +var bad_re = []stringError{ + stringError{ `*`, regexp.ErrBareClosure }, + stringError{ `(abc`, regexp.ErrUnmatchedLpar }, + stringError{ `abc)`, regexp.ErrUnmatchedRpar }, + stringError{ `x[a-z`, regexp.ErrUnmatchedLbkt }, + stringError{ `abc]`, regexp.ErrUnmatchedRbkt }, + stringError{ `[z-a]`, regexp.ErrBadRange }, + stringError{ `abc\`, regexp.ErrExtraneousBackslash }, + stringError{ `a**`, regexp.ErrBadClosure }, + stringError{ `a*+`, regexp.ErrBadClosure }, + stringError{ `a??`, regexp.ErrBadClosure }, + stringError{ `*`, regexp.ErrBareClosure }, + stringError{ `\x`, regexp.ErrBadBackslash }, +} type vec []int; @@ -57,33 +57,33 @@ type tester struct { match vec; } -var matches = []tester ( - tester( ``, "", vec(0,0) ), - tester( `a`, "a", vec(0,1) ), - tester( `x`, "y", vec() ), - tester( `b`, "abc", vec(1,2) ), - tester( `.`, "a", vec(0,1) ), - tester( `.*`, "abcdef", vec(0,6) ), - tester( `^abcd$`, "abcd", vec(0,4) ), - tester( `^bcd'`, "abcdef", vec() ), - tester( `^abcd$`, "abcde", vec() ), - tester( `a+`, "baaab", vec(1,4) ), - tester( `a*`, "baaab", vec(0,0) ), - tester( `[a-z]+`, "abcd", vec(0,4) ), - tester( `[^a-z]+`, "ab1234cd", vec(2,6) ), - tester( `[a\-\]z]+`, "az]-bcz", vec(0,4) ), - tester( `[日本語]+`, "日本語日本語", vec(0,18) ), - tester( `()`, "", vec(0,0, 0,0) ), - tester( `(a)`, "a", vec(0,1, 0,1) ), - tester( `(.)(.)`, "日a", vec(0,4, 0,3, 3,4) ), - tester( `(.*)`, "", vec(0,0, 0,0) ), - tester( `(.*)`, "abcd", vec(0,4, 0,4) ), - tester( `(..)(..)`, "abcd", vec(0,4, 0,2, 2,4) ), - tester( `(([^xyz]*)(d))`, "abcd", vec(0,4, 0,4, 0,3, 3,4) ), - tester( `((a|b|c)*(d))`, "abcd", vec(0,4, 0,4, 2,3, 3,4) ), - tester( `(((a|b|c)*)(d))`, "abcd", vec(0,4, 0,4, 0,3, 2,3, 3,4) ), - tester( `a*(|(b))c*`, "aacc", vec(0,4, 2,2, -1,-1) ), -) +var matches = []tester { + tester{ ``, "", vec{0,0} }, + tester{ `a`, "a", vec{0,1} }, + tester{ `x`, "y", vec{} }, + tester{ `b`, "abc", vec{1,2} }, + tester{ `.`, "a", vec{0,1} }, + tester{ `.*`, "abcdef", vec{0,6} }, + tester{ `^abcd$`, "abcd", vec{0,4} }, + tester{ `^bcd'`, "abcdef", vec{} }, + tester{ `^abcd$`, "abcde", vec{} }, + tester{ `a+`, "baaab", vec{1,4} }, + tester{ `a*`, "baaab", vec{0,0} }, + tester{ `[a-z]+`, "abcd", vec{0,4} }, + tester{ `[^a-z]+`, "ab1234cd", vec{2,6} }, + tester{ `[a\-\]z]+`, "az]-bcz", vec{0,4} }, + tester{ `[日本語]+`, "日本語日本語", vec{0,18} }, + tester{ `()`, "", vec{0,0, 0,0} }, + tester{ `(a)`, "a", vec{0,1, 0,1} }, + tester{ `(.)(.)`, "日a", vec{0,4, 0,3, 3,4} }, + tester{ `(.*)`, "", vec{0,0, 0,0} }, + tester{ `(.*)`, "abcd", vec{0,4, 0,4} }, + tester{ `(..)(..)`, "abcd", vec{0,4, 0,2, 2,4} }, + tester{ `(([^xyz]*)(d))`, "abcd", vec{0,4, 0,4, 0,3, 3,4} }, + tester{ `((a|b|c)*(d))`, "abcd", vec{0,4, 0,4, 2,3, 3,4} }, + tester{ `(((a|b|c)*)(d))`, "abcd", vec{0,4, 0,4, 0,3, 2,3, 3,4} }, + tester{ `a*(|(b))c*`, "aacc", vec{0,4, 2,2, -1,-1} }, +} func compileTest(t *testing.T, expr string, error *os.Error) regexp.Regexp { re, err := regexp.Compile(expr); diff --git a/src/lib/sort_test.go b/src/lib/sort_test.go index f9d924c4e8..aa80aa10e3 100644 --- a/src/lib/sort_test.go +++ b/src/lib/sort_test.go @@ -12,9 +12,9 @@ import ( ) -var ints = [...]int(74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586) -var floats = [...]float(74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8) -var strings = [...]string("", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***") +var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586} +var floats = [...]float{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8} +var strings = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"} func TestSortIntArray(t *testing.T) { data := ints; @@ -134,9 +134,9 @@ func lg(n int) int { } func TestBentleyMcIlroy(t *testing.T) { - sizes := []int(100, 1023, 1024, 1025); - dists := []string("sawtooth", "rand", "stagger", "plateau", "shuffle"); - modes := []string("copy", "reverse", "reverse1", "reverse2", "sort", "dither"); + sizes := []int{100, 1023, 1024, 1025}; + dists := []string{"sawtooth", "rand", "stagger", "plateau", "shuffle"}; + modes := []string{"copy", "reverse", "reverse1", "reverse2", "sort", "dither"}; var tmp1, tmp2 [1025]int; for ni := 0; ni < len(sizes); ni++ { n := sizes[ni]; @@ -205,7 +205,7 @@ func TestBentleyMcIlroy(t *testing.T) { } desc := fmt.Sprintf("n=%d m=%d dist=%s mode=%s", n, m, dists[dist], modes[mode]); - d := &testingData(desc, t, mdata[0:n], n*lg(n)*12/10, 0); + d := &testingData{desc, t, mdata[0:n], n*lg(n)*12/10, 0}; sort.Sort(d); // If we were testing C qsort, we'd have to make a copy diff --git a/src/lib/strconv/atof.go b/src/lib/strconv/atof.go index d1a0f4a9e7..3585944163 100644 --- a/src/lib/strconv/atof.go +++ b/src/lib/strconv/atof.go @@ -106,9 +106,9 @@ func stringToDecimal(s string) (neg bool, d *decimal, trunc bool, ok bool) { } // decimal power of ten to binary power of two. -var powtab = []int( +var powtab = []int{ 1, 3, 6, 9, 13, 16, 19, 23, 26 -) +} func decimalToFloatBits(neg bool, d *decimal, trunc bool, flt *floatInfo) (b uint64, overflow bool) { var exp int; @@ -232,14 +232,14 @@ func decimalAtof32Int(neg bool, d *decimal) float32 { } // Exact powers of 10. -var float64pow10 = []float64 ( +var float64pow10 = []float64 { 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22 -) -var float32pow10 = []float32 ( +} +var float32pow10 = []float32 { 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10 -) +} // If possible to convert decimal d to 64-bit float f exactly, // entirely in floating-point math, do so, avoiding the expense of decimalToFloatBits. diff --git a/src/lib/strconv/atof_test.go b/src/lib/strconv/atof_test.go index abc1998714..7f1f0a1312 100644 --- a/src/lib/strconv/atof_test.go +++ b/src/lib/strconv/atof_test.go @@ -16,80 +16,80 @@ type atofTest struct { err *os.Error; } -var atoftests = []atofTest ( - atofTest( "", "0", os.EINVAL ), - atofTest( "1", "1", nil ), - atofTest( "+1", "1", nil ), - atofTest( "1x", "0", os.EINVAL ), - atofTest( "1.1.", "0", os.EINVAL ), - atofTest( "1e23", "1e+23", nil ), - atofTest( "100000000000000000000000", "1e+23", nil ), - atofTest( "1e-100", "1e-100", nil ), - atofTest( "123456700", "1.234567e+08", nil ), - atofTest( "99999999999999974834176", "9.999999999999997e+22", nil ), - atofTest( "100000000000000000000001", "1.0000000000000001e+23", nil ), - atofTest( "100000000000000008388608", "1.0000000000000001e+23", nil ), - atofTest( "100000000000000016777215", "1.0000000000000001e+23", nil ), - atofTest( "100000000000000016777216", "1.0000000000000003e+23", nil ), - atofTest( "-1", "-1", nil ), - atofTest( "-0", "-0", nil ), - atofTest( "1e-20", "1e-20", nil ), - atofTest( "625e-3", "0.625", nil ), +var atoftests = []atofTest { + atofTest{ "", "0", os.EINVAL }, + atofTest{ "1", "1", nil }, + atofTest{ "+1", "1", nil }, + atofTest{ "1x", "0", os.EINVAL }, + atofTest{ "1.1.", "0", os.EINVAL }, + atofTest{ "1e23", "1e+23", nil }, + atofTest{ "100000000000000000000000", "1e+23", nil }, + atofTest{ "1e-100", "1e-100", nil }, + atofTest{ "123456700", "1.234567e+08", nil }, + atofTest{ "99999999999999974834176", "9.999999999999997e+22", nil }, + atofTest{ "100000000000000000000001", "1.0000000000000001e+23", nil }, + atofTest{ "100000000000000008388608", "1.0000000000000001e+23", nil }, + atofTest{ "100000000000000016777215", "1.0000000000000001e+23", nil }, + atofTest{ "100000000000000016777216", "1.0000000000000003e+23", nil }, + atofTest{ "-1", "-1", nil }, + atofTest{ "-0", "-0", nil }, + atofTest{ "1e-20", "1e-20", nil }, + atofTest{ "625e-3", "0.625", nil }, // largest float64 - atofTest( "1.7976931348623157e308", "1.7976931348623157e+308", nil ), - atofTest( "-1.7976931348623157e308", "-1.7976931348623157e+308", nil ), + atofTest{ "1.7976931348623157e308", "1.7976931348623157e+308", nil }, + atofTest{ "-1.7976931348623157e308", "-1.7976931348623157e+308", nil }, // next float64 - too large - atofTest( "1.7976931348623159e308", "+Inf", os.ERANGE ), - atofTest( "-1.7976931348623159e308", "-Inf", os.ERANGE ), + atofTest{ "1.7976931348623159e308", "+Inf", os.ERANGE }, + atofTest{ "-1.7976931348623159e308", "-Inf", os.ERANGE }, // the border is ...158079 // borderline - okay - atofTest( "1.7976931348623158e308", "1.7976931348623157e+308", nil ), - atofTest( "-1.7976931348623158e308", "-1.7976931348623157e+308", nil ), + atofTest{ "1.7976931348623158e308", "1.7976931348623157e+308", nil }, + atofTest{ "-1.7976931348623158e308", "-1.7976931348623157e+308", nil }, // borderline - too large - atofTest( "1.797693134862315808e308", "+Inf", os.ERANGE ), - atofTest( "-1.797693134862315808e308", "-Inf", os.ERANGE ), + atofTest{ "1.797693134862315808e308", "+Inf", os.ERANGE }, + atofTest{ "-1.797693134862315808e308", "-Inf", os.ERANGE }, // a little too large - atofTest( "1e308", "1e+308", nil ), - atofTest( "2e308", "+Inf", os.ERANGE ), - atofTest( "1e309", "+Inf", os.ERANGE ), + atofTest{ "1e308", "1e+308", nil }, + atofTest{ "2e308", "+Inf", os.ERANGE }, + atofTest{ "1e309", "+Inf", os.ERANGE }, // way too large - atofTest( "1e310", "+Inf", os.ERANGE ), - atofTest( "-1e310", "-Inf", os.ERANGE ), - atofTest( "1e400", "+Inf", os.ERANGE ), - atofTest( "-1e400", "-Inf", os.ERANGE ), - atofTest( "1e400000", "+Inf", os.ERANGE ), - atofTest( "-1e400000", "-Inf", os.ERANGE ), + atofTest{ "1e310", "+Inf", os.ERANGE }, + atofTest{ "-1e310", "-Inf", os.ERANGE }, + atofTest{ "1e400", "+Inf", os.ERANGE }, + atofTest{ "-1e400", "-Inf", os.ERANGE }, + atofTest{ "1e400000", "+Inf", os.ERANGE }, + atofTest{ "-1e400000", "-Inf", os.ERANGE }, // denormalized - atofTest( "1e-305", "1e-305", nil ), - atofTest( "1e-306", "1e-306", nil ), - atofTest( "1e-307", "1e-307", nil ), - atofTest( "1e-308", "1e-308", nil ), - atofTest( "1e-309", "1e-309", nil ), - atofTest( "1e-310", "1e-310", nil ), - atofTest( "1e-322", "1e-322", nil ), + atofTest{ "1e-305", "1e-305", nil }, + atofTest{ "1e-306", "1e-306", nil }, + atofTest{ "1e-307", "1e-307", nil }, + atofTest{ "1e-308", "1e-308", nil }, + atofTest{ "1e-309", "1e-309", nil }, + atofTest{ "1e-310", "1e-310", nil }, + atofTest{ "1e-322", "1e-322", nil }, // smallest denormal - atofTest( "5e-324", "5e-324", nil ), + atofTest{ "5e-324", "5e-324", nil }, // too small - atofTest( "4e-324", "0", nil ), + atofTest{ "4e-324", "0", nil }, // way too small - atofTest( "1e-350", "0", nil ), - atofTest( "1e-400000", "0", nil ), + atofTest{ "1e-350", "0", nil }, + atofTest{ "1e-400000", "0", nil }, // try to overflow exponent - atofTest( "1e-4294967296", "0", nil ), - atofTest( "1e+4294967296", "+Inf", os.ERANGE ), - atofTest( "1e-18446744073709551616", "0", nil ), - atofTest( "1e+18446744073709551616", "+Inf", os.ERANGE ), + atofTest{ "1e-4294967296", "0", nil }, + atofTest{ "1e+4294967296", "+Inf", os.ERANGE }, + atofTest{ "1e-18446744073709551616", "0", nil }, + atofTest{ "1e+18446744073709551616", "+Inf", os.ERANGE }, // Parse errors - atofTest( "1e", "0", os.EINVAL ), - atofTest( "1e-", "0", os.EINVAL ), - atofTest( ".e-1", "0", os.EINVAL ), -) + atofTest{ "1e", "0", os.EINVAL }, + atofTest{ "1e-", "0", os.EINVAL }, + atofTest{ ".e-1", "0", os.EINVAL }, +} func testAtof(t *testing.T, opt bool) { oldopt := strconv.optimize; diff --git a/src/lib/strconv/atoi_test.go b/src/lib/strconv/atoi_test.go index 0128eb70b6..3940ebc782 100644 --- a/src/lib/strconv/atoi_test.go +++ b/src/lib/strconv/atoi_test.go @@ -17,26 +17,26 @@ type atoui64Test struct { err *os.Error; } -var atoui64tests = []atoui64Test ( - atoui64Test("", 0, os.EINVAL), - atoui64Test("0", 0, nil), - atoui64Test("1", 1, nil), - atoui64Test("12345", 12345, nil), - atoui64Test("012345", 012345, nil), - atoui64Test("0x12345", 0x12345, nil), - atoui64Test("0X12345", 0x12345, nil), - atoui64Test("12345x", 0, os.EINVAL), - atoui64Test("98765432100", 98765432100, nil), - atoui64Test("18446744073709551615", 1<<64-1, nil), - atoui64Test("18446744073709551616", 1<<64-1, os.ERANGE), - atoui64Test("18446744073709551620", 1<<64-1, os.ERANGE), - atoui64Test("0xFFFFFFFFFFFFFFFF", 1<<64-1, nil), - atoui64Test("0x10000000000000000", 1<<64-1, os.ERANGE), - atoui64Test("01777777777777777777777", 1<<64-1, nil), - atoui64Test("01777777777777777777778", 0, os.EINVAL), - atoui64Test("02000000000000000000000", 1<<64-1, os.ERANGE), - atoui64Test("0200000000000000000000", 1<<61, nil), -) +var atoui64tests = []atoui64Test { + atoui64Test{"", 0, os.EINVAL}, + atoui64Test{"0", 0, nil}, + atoui64Test{"1", 1, nil}, + atoui64Test{"12345", 12345, nil}, + atoui64Test{"012345", 012345, nil}, + atoui64Test{"0x12345", 0x12345, nil}, + atoui64Test{"0X12345", 0x12345, nil}, + atoui64Test{"12345x", 0, os.EINVAL}, + atoui64Test{"98765432100", 98765432100, nil}, + atoui64Test{"18446744073709551615", 1<<64-1, nil}, + atoui64Test{"18446744073709551616", 1<<64-1, os.ERANGE}, + atoui64Test{"18446744073709551620", 1<<64-1, os.ERANGE}, + atoui64Test{"0xFFFFFFFFFFFFFFFF", 1<<64-1, nil}, + atoui64Test{"0x10000000000000000", 1<<64-1, os.ERANGE}, + atoui64Test{"01777777777777777777777", 1<<64-1, nil}, + atoui64Test{"01777777777777777777778", 0, os.EINVAL}, + atoui64Test{"02000000000000000000000", 1<<64-1, os.ERANGE}, + atoui64Test{"0200000000000000000000", 1<<61, nil}, +} type atoi64Test struct { in string; @@ -44,29 +44,29 @@ type atoi64Test struct { err *os.Error; } -var atoi64test = []atoi64Test ( - atoi64Test("", 0, os.EINVAL), - atoi64Test("0", 0, nil), - atoi64Test("-0", 0, nil), - atoi64Test("1", 1, nil), - atoi64Test("-1", -1, nil), - atoi64Test("12345", 12345, nil), - atoi64Test("-12345", -12345, nil), - atoi64Test("012345", 012345, nil), - atoi64Test("-012345", -012345, nil), - atoi64Test("0x12345", 0x12345, nil), - atoi64Test("-0X12345", -0x12345, nil), - atoi64Test("12345x", 0, os.EINVAL), - atoi64Test("-12345x", 0, os.EINVAL), - atoi64Test("98765432100", 98765432100, nil), - atoi64Test("-98765432100", -98765432100, nil), - atoi64Test("9223372036854775807", 1<<63-1, nil), - atoi64Test("-9223372036854775807", -(1<<63-1), nil), - atoi64Test("9223372036854775808", 1<<63-1, os.ERANGE), - atoi64Test("-9223372036854775808", -1<<63, nil), - atoi64Test("9223372036854775809", 1<<63-1, os.ERANGE), - atoi64Test("-9223372036854775809", -1<<63, os.ERANGE), -) +var atoi64test = []atoi64Test { + atoi64Test{"", 0, os.EINVAL}, + atoi64Test{"0", 0, nil}, + atoi64Test{"-0", 0, nil}, + atoi64Test{"1", 1, nil}, + atoi64Test{"-1", -1, nil}, + atoi64Test{"12345", 12345, nil}, + atoi64Test{"-12345", -12345, nil}, + atoi64Test{"012345", 012345, nil}, + atoi64Test{"-012345", -012345, nil}, + atoi64Test{"0x12345", 0x12345, nil}, + atoi64Test{"-0X12345", -0x12345, nil}, + atoi64Test{"12345x", 0, os.EINVAL}, + atoi64Test{"-12345x", 0, os.EINVAL}, + atoi64Test{"98765432100", 98765432100, nil}, + atoi64Test{"-98765432100", -98765432100, nil}, + atoi64Test{"9223372036854775807", 1<<63-1, nil}, + atoi64Test{"-9223372036854775807", -(1<<63-1), nil}, + atoi64Test{"9223372036854775808", 1<<63-1, os.ERANGE}, + atoi64Test{"-9223372036854775808", -1<<63, nil}, + atoi64Test{"9223372036854775809", 1<<63-1, os.ERANGE}, + atoi64Test{"-9223372036854775809", -1<<63, os.ERANGE}, +} type atoui32Test struct { in string; @@ -74,19 +74,19 @@ type atoui32Test struct { err *os.Error; } -var atoui32tests = []atoui32Test ( - atoui32Test("", 0, os.EINVAL), - atoui32Test("0", 0, nil), - atoui32Test("1", 1, nil), - atoui32Test("12345", 12345, nil), - atoui32Test("012345", 012345, nil), - atoui32Test("0x12345", 0x12345, nil), - atoui32Test("0X12345", 0x12345, nil), - atoui32Test("12345x", 0, os.EINVAL), - atoui32Test("987654321", 987654321, nil), - atoui32Test("4294967295", 1<<32-1, nil), - atoui32Test("4294967296", 1<<32-1, os.ERANGE), -) +var atoui32tests = []atoui32Test { + atoui32Test{"", 0, os.EINVAL}, + atoui32Test{"0", 0, nil}, + atoui32Test{"1", 1, nil}, + atoui32Test{"12345", 12345, nil}, + atoui32Test{"012345", 012345, nil}, + atoui32Test{"0x12345", 0x12345, nil}, + atoui32Test{"0X12345", 0x12345, nil}, + atoui32Test{"12345x", 0, os.EINVAL}, + atoui32Test{"987654321", 987654321, nil}, + atoui32Test{"4294967295", 1<<32-1, nil}, + atoui32Test{"4294967296", 1<<32-1, os.ERANGE}, +} type atoi32Test struct { in string; @@ -94,29 +94,29 @@ type atoi32Test struct { err *os.Error; } -var atoi32tests = []atoi32Test ( - atoi32Test("", 0, os.EINVAL), - atoi32Test("0", 0, nil), - atoi32Test("-0", 0, nil), - atoi32Test("1", 1, nil), - atoi32Test("-1", -1, nil), - atoi32Test("12345", 12345, nil), - atoi32Test("-12345", -12345, nil), - atoi32Test("012345", 012345, nil), - atoi32Test("-012345", -012345, nil), - atoi32Test("0x12345", 0x12345, nil), - atoi32Test("-0X12345", -0x12345, nil), - atoi32Test("12345x", 0, os.EINVAL), - atoi32Test("-12345x", 0, os.EINVAL), - atoi32Test("987654321", 987654321, nil), - atoi32Test("-987654321", -987654321, nil), - atoi32Test("2147483647", 1<<31-1, nil), - atoi32Test("-2147483647", -(1<<31-1), nil), - atoi32Test("2147483648", 1<<31-1, os.ERANGE), - atoi32Test("-2147483648", -1<<31, nil), - atoi32Test("2147483649", 1<<31-1, os.ERANGE), - atoi32Test("-2147483649", -1<<31, os.ERANGE), -) +var atoi32tests = []atoi32Test { + atoi32Test{"", 0, os.EINVAL}, + atoi32Test{"0", 0, nil}, + atoi32Test{"-0", 0, nil}, + atoi32Test{"1", 1, nil}, + atoi32Test{"-1", -1, nil}, + atoi32Test{"12345", 12345, nil}, + atoi32Test{"-12345", -12345, nil}, + atoi32Test{"012345", 012345, nil}, + atoi32Test{"-012345", -012345, nil}, + atoi32Test{"0x12345", 0x12345, nil}, + atoi32Test{"-0X12345", -0x12345, nil}, + atoi32Test{"12345x", 0, os.EINVAL}, + atoi32Test{"-12345x", 0, os.EINVAL}, + atoi32Test{"987654321", 987654321, nil}, + atoi32Test{"-987654321", -987654321, nil}, + atoi32Test{"2147483647", 1<<31-1, nil}, + atoi32Test{"-2147483647", -(1<<31-1), nil}, + atoi32Test{"2147483648", 1<<31-1, os.ERANGE}, + atoi32Test{"-2147483648", -1<<31, nil}, + atoi32Test{"2147483649", 1<<31-1, os.ERANGE}, + atoi32Test{"-2147483649", -1<<31, os.ERANGE}, +} func TestAtoui64(t *testing.T) { for i := 0; i < len(atoui64tests); i++ { diff --git a/src/lib/strconv/decimal.go b/src/lib/strconv/decimal.go index 37a5ab9c6b..4808e93463 100644 --- a/src/lib/strconv/decimal.go +++ b/src/lib/strconv/decimal.go @@ -192,7 +192,7 @@ type leftCheat struct { cutoff string; // minus one digit if original < a. } -var leftcheats = []leftCheat ( +var leftcheats = []leftCheat { // Leading digits of 1/2^i = 5^i. // 5^23 is not an exact 64-bit floating point number, // so have to use bc for the math. @@ -205,35 +205,35 @@ var leftcheats = []leftCheat ( int(log2*NR+1), $0, 2**NR) }' */ - leftCheat( 0, "" ), - leftCheat( 1, "5" ), // * 2 - leftCheat( 1, "25" ), // * 4 - leftCheat( 1, "125" ), // * 8 - leftCheat( 2, "625" ), // * 16 - leftCheat( 2, "3125" ), // * 32 - leftCheat( 2, "15625" ), // * 64 - leftCheat( 3, "78125" ), // * 128 - leftCheat( 3, "390625" ), // * 256 - leftCheat( 3, "1953125" ), // * 512 - leftCheat( 4, "9765625" ), // * 1024 - leftCheat( 4, "48828125" ), // * 2048 - leftCheat( 4, "244140625" ), // * 4096 - leftCheat( 4, "1220703125" ), // * 8192 - leftCheat( 5, "6103515625" ), // * 16384 - leftCheat( 5, "30517578125" ), // * 32768 - leftCheat( 5, "152587890625" ), // * 65536 - leftCheat( 6, "762939453125" ), // * 131072 - leftCheat( 6, "3814697265625" ), // * 262144 - leftCheat( 6, "19073486328125" ), // * 524288 - leftCheat( 7, "95367431640625" ), // * 1048576 - leftCheat( 7, "476837158203125" ), // * 2097152 - leftCheat( 7, "2384185791015625" ), // * 4194304 - leftCheat( 7, "11920928955078125" ), // * 8388608 - leftCheat( 8, "59604644775390625" ), // * 16777216 - leftCheat( 8, "298023223876953125" ), // * 33554432 - leftCheat( 8, "1490116119384765625" ), // * 67108864 - leftCheat( 9, "7450580596923828125" ), // * 134217728 -) + leftCheat{ 0, "" }, + leftCheat{ 1, "5" }, // * 2 + leftCheat{ 1, "25" }, // * 4 + leftCheat{ 1, "125" }, // * 8 + leftCheat{ 2, "625" }, // * 16 + leftCheat{ 2, "3125" }, // * 32 + leftCheat{ 2, "15625" }, // * 64 + leftCheat{ 3, "78125" }, // * 128 + leftCheat{ 3, "390625" }, // * 256 + leftCheat{ 3, "1953125" }, // * 512 + leftCheat{ 4, "9765625" }, // * 1024 + leftCheat{ 4, "48828125" }, // * 2048 + leftCheat{ 4, "244140625" }, // * 4096 + leftCheat{ 4, "1220703125" }, // * 8192 + leftCheat{ 5, "6103515625" }, // * 16384 + leftCheat{ 5, "30517578125" }, // * 32768 + leftCheat{ 5, "152587890625" }, // * 65536 + leftCheat{ 6, "762939453125" }, // * 131072 + leftCheat{ 6, "3814697265625" }, // * 262144 + leftCheat{ 6, "19073486328125" }, // * 524288 + leftCheat{ 7, "95367431640625" }, // * 1048576 + leftCheat{ 7, "476837158203125" }, // * 2097152 + leftCheat{ 7, "2384185791015625" }, // * 4194304 + leftCheat{ 7, "11920928955078125" }, // * 8388608 + leftCheat{ 8, "59604644775390625" }, // * 16777216 + leftCheat{ 8, "298023223876953125" }, // * 33554432 + leftCheat{ 8, "1490116119384765625" }, // * 67108864 + leftCheat{ 9, "7450580596923828125" }, // * 134217728 +} // Is the leading prefix of b lexicographically less than s? func prefixIsLessThan(b []byte, s string) bool { diff --git a/src/lib/strconv/decimal_test.go b/src/lib/strconv/decimal_test.go index 7af0d254d0..bc82861bdd 100644 --- a/src/lib/strconv/decimal_test.go +++ b/src/lib/strconv/decimal_test.go @@ -16,18 +16,18 @@ type shiftTest struct { out string; } -var shifttests = []shiftTest ( - shiftTest( 0, -100, "0" ), - shiftTest( 0, 100, "0" ), - shiftTest( 1, 100, "1267650600228229401496703205376" ), - shiftTest( 1, -100, +var shifttests = []shiftTest { + shiftTest{ 0, -100, "0" }, + shiftTest{ 0, 100, "0" }, + shiftTest{ 1, 100, "1267650600228229401496703205376" }, + shiftTest{ 1, -100, "0.00000000000000000000000000000078886090522101180541" - "17285652827862296732064351090230047702789306640625" ), - shiftTest( 12345678, 8, "3160493568" ), - shiftTest( 12345678, -8, "48225.3046875" ), - shiftTest( 195312, 9, "99999744" ), - shiftTest( 1953125, 9, "1000000000" ), -) + "17285652827862296732064351090230047702789306640625" }, + shiftTest{ 12345678, 8, "3160493568" }, + shiftTest{ 12345678, -8, "48225.3046875" }, + shiftTest{ 195312, 9, "99999744" }, + shiftTest{ 1953125, 9, "1000000000" }, +} func TestDecimalShift(t *testing.T) { ok := true; @@ -48,23 +48,23 @@ type roundTest struct { int uint64; } -var roundtests = []roundTest ( - roundTest( 0, 4, "0", "0", "0", 0 ), - roundTest( 12344999, 4, "12340000", "12340000", "12350000", 12340000 ), - roundTest( 12345000, 4, "12340000", "12340000", "12350000", 12340000 ), - roundTest( 12345001, 4, "12340000", "12350000", "12350000", 12350000 ), - roundTest( 23454999, 4, "23450000", "23450000", "23460000", 23450000 ), - roundTest( 23455000, 4, "23450000", "23460000", "23460000", 23460000 ), - roundTest( 23455001, 4, "23450000", "23460000", "23460000", 23460000 ), +var roundtests = []roundTest { + roundTest{ 0, 4, "0", "0", "0", 0 }, + roundTest{ 12344999, 4, "12340000", "12340000", "12350000", 12340000 }, + roundTest{ 12345000, 4, "12340000", "12340000", "12350000", 12340000 }, + roundTest{ 12345001, 4, "12340000", "12350000", "12350000", 12350000 }, + roundTest{ 23454999, 4, "23450000", "23450000", "23460000", 23450000 }, + roundTest{ 23455000, 4, "23450000", "23460000", "23460000", 23460000 }, + roundTest{ 23455001, 4, "23450000", "23460000", "23460000", 23460000 }, - roundTest( 99994999, 4, "99990000", "99990000", "100000000", 99990000 ), - roundTest( 99995000, 4, "99990000", "100000000", "100000000", 100000000 ), - roundTest( 99999999, 4, "99990000", "100000000", "100000000", 100000000 ), + roundTest{ 99994999, 4, "99990000", "99990000", "100000000", 99990000 }, + roundTest{ 99995000, 4, "99990000", "100000000", "100000000", 100000000 }, + roundTest{ 99999999, 4, "99990000", "100000000", "100000000", 100000000 }, - roundTest( 12994999, 4, "12990000", "12990000", "13000000", 12990000 ), - roundTest( 12995000, 4, "12990000", "13000000", "13000000", 13000000 ), - roundTest( 12999999, 4, "12990000", "13000000", "13000000", 13000000 ), -) + roundTest{ 12994999, 4, "12990000", "12990000", "13000000", 12990000 }, + roundTest{ 12995000, 4, "12990000", "13000000", "13000000", 13000000 }, + roundTest{ 12999999, 4, "12990000", "13000000", "13000000", 13000000 }, +} func TestDecimalRound(t *testing.T) { for i := 0; i < len(roundtests); i++ { @@ -93,18 +93,18 @@ type roundIntTest struct { int uint64; } -var roundinttests = []roundIntTest ( - roundIntTest( 0, 100, 0 ), - roundIntTest( 512, -8, 2 ), - roundIntTest( 513, -8, 2 ), - roundIntTest( 640, -8, 2 ), - roundIntTest( 641, -8, 3 ), - roundIntTest( 384, -8, 2 ), - roundIntTest( 385, -8, 2 ), - roundIntTest( 383, -8, 1 ), - roundIntTest( 1, 100, 1<<64-1 ), - roundIntTest( 1000, 0, 1000 ), -) +var roundinttests = []roundIntTest { + roundIntTest{ 0, 100, 0 }, + roundIntTest{ 512, -8, 2 }, + roundIntTest{ 513, -8, 2 }, + roundIntTest{ 640, -8, 2 }, + roundIntTest{ 641, -8, 3 }, + roundIntTest{ 384, -8, 2 }, + roundIntTest{ 385, -8, 2 }, + roundIntTest{ 383, -8, 1 }, + roundIntTest{ 1, 100, 1<<64-1 }, + roundIntTest{ 1000, 0, 1000 }, +} func TestDecimalRoundedInteger(t *testing.T) { for i := 0; i < len(roundinttests); i++ { diff --git a/src/lib/strconv/ftoa.go b/src/lib/strconv/ftoa.go index 75bb3a21fa..52835c803e 100644 --- a/src/lib/strconv/ftoa.go +++ b/src/lib/strconv/ftoa.go @@ -21,8 +21,8 @@ type floatInfo struct { expbits uint; bias int; } -var float32info = floatInfo( 23, 8, -127 ) -var float64info = floatInfo( 52, 11, -1023 ) +var float32info = floatInfo{ 23, 8, -127 } +var float64info = floatInfo{ 52, 11, -1023 } func fmtB(neg bool, mant uint64, exp int, flt *floatInfo) string func fmtE(neg bool, d *decimal, prec int) string diff --git a/src/lib/strconv/ftoa_test.go b/src/lib/strconv/ftoa_test.go index 09fdeaca57..0f0baa5145 100644 --- a/src/lib/strconv/ftoa_test.go +++ b/src/lib/strconv/ftoa_test.go @@ -24,80 +24,80 @@ const ( above1e23 = 100000000000000008388608; ) -var ftoatests = []ftoaTest ( - ftoaTest( 1, 'e', 5, "1.00000e+00" ), - ftoaTest( 1, 'f', 5, "1.00000" ), - ftoaTest( 1, 'g', 5, "1" ), - ftoaTest( 1, 'g', -1, "1" ), - ftoaTest( 20, 'g', -1, "20" ), - ftoaTest( 1234567.8, 'g', -1, "1.2345678e+06" ), - ftoaTest( 200000, 'g', -1, "200000" ), - ftoaTest( 2000000, 'g', -1, "2e+06" ), - - ftoaTest( 0, 'e', 5, "0.00000e+00" ), - ftoaTest( 0, 'f', 5, "0.00000" ), - ftoaTest( 0, 'g', 5, "0" ), - ftoaTest( 0, 'g', -1, "0" ), - - ftoaTest( -1, 'e', 5, "-1.00000e+00" ), - ftoaTest( -1, 'f', 5, "-1.00000" ), - ftoaTest( -1, 'g', 5, "-1" ), - ftoaTest( -1, 'g', -1, "-1" ), - - ftoaTest( 12, 'e', 5, "1.20000e+01" ), - ftoaTest( 12, 'f', 5, "12.00000" ), - ftoaTest( 12, 'g', 5, "12" ), - ftoaTest( 12, 'g', -1, "12" ), - - ftoaTest( 123456700, 'e', 5, "1.23457e+08" ), - ftoaTest( 123456700, 'f', 5, "123456700.00000" ), - ftoaTest( 123456700, 'g', 5, "1.2346e+08" ), - ftoaTest( 123456700, 'g', -1, "1.234567e+08" ), - - ftoaTest( 1.2345e6, 'e', 5, "1.23450e+06" ), - ftoaTest( 1.2345e6, 'f', 5, "1234500.00000" ), - ftoaTest( 1.2345e6, 'g', 5, "1.2345e+06" ), - - ftoaTest( 1e23, 'e', 17, "9.99999999999999916e+22" ), - ftoaTest( 1e23, 'f', 17, "99999999999999991611392.00000000000000000" ), - ftoaTest( 1e23, 'g', 17, "9.9999999999999992e+22" ), - - ftoaTest( 1e23, 'e', -1, "1e+23" ), - ftoaTest( 1e23, 'f', -1, "100000000000000000000000" ), - ftoaTest( 1e23, 'g', -1, "1e+23" ), - - ftoaTest( below1e23, 'e', 17, "9.99999999999999748e+22" ), - ftoaTest( below1e23, 'f', 17, "99999999999999974834176.00000000000000000" ), - ftoaTest( below1e23, 'g', 17, "9.9999999999999975e+22" ), - - ftoaTest( below1e23, 'e', -1, "9.999999999999997e+22" ), - ftoaTest( below1e23, 'f', -1, "99999999999999970000000" ), - ftoaTest( below1e23, 'g', -1, "9.999999999999997e+22" ), - - ftoaTest( above1e23, 'e', 17, "1.00000000000000008e+23" ), - ftoaTest( above1e23, 'f', 17, "100000000000000008388608.00000000000000000" ), - ftoaTest( above1e23, 'g', 17, "1.0000000000000001e+23" ), - - ftoaTest( above1e23, 'e', -1, "1.0000000000000001e+23" ), - ftoaTest( above1e23, 'f', -1, "100000000000000010000000" ), - ftoaTest( above1e23, 'g', -1, "1.0000000000000001e+23" ), - - ftoaTest( fdiv(5e-304, 1e20), 'g', -1, "5e-324" ), - ftoaTest( fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" ), - - ftoaTest( 32, 'g', -1, "32" ), - ftoaTest( 32, 'g', 0, "3e+01" ), - - ftoaTest( 100, 'x', -1, "%x" ), - - ftoaTest( math.NaN(), 'g', -1, "NaN" ), - ftoaTest( -math.NaN(), 'g', -1, "NaN" ), - ftoaTest( math.Inf(0), 'g', -1, "+Inf" ), - ftoaTest( math.Inf(-1), 'g', -1, "-Inf" ), - ftoaTest( -math.Inf(0), 'g', -1, "-Inf" ), - - ftoaTest( -1, 'b', -1, "-4503599627370496p-52" ), -) +var ftoatests = []ftoaTest { + ftoaTest{ 1, 'e', 5, "1.00000e+00" }, + ftoaTest{ 1, 'f', 5, "1.00000" }, + ftoaTest{ 1, 'g', 5, "1" }, + ftoaTest{ 1, 'g', -1, "1" }, + ftoaTest{ 20, 'g', -1, "20" }, + ftoaTest{ 1234567.8, 'g', -1, "1.2345678e+06" }, + ftoaTest{ 200000, 'g', -1, "200000" }, + ftoaTest{ 2000000, 'g', -1, "2e+06" }, + + ftoaTest{ 0, 'e', 5, "0.00000e+00" }, + ftoaTest{ 0, 'f', 5, "0.00000" }, + ftoaTest{ 0, 'g', 5, "0" }, + ftoaTest{ 0, 'g', -1, "0" }, + + ftoaTest{ -1, 'e', 5, "-1.00000e+00" }, + ftoaTest{ -1, 'f', 5, "-1.00000" }, + ftoaTest{ -1, 'g', 5, "-1" }, + ftoaTest{ -1, 'g', -1, "-1" }, + + ftoaTest{ 12, 'e', 5, "1.20000e+01" }, + ftoaTest{ 12, 'f', 5, "12.00000" }, + ftoaTest{ 12, 'g', 5, "12" }, + ftoaTest{ 12, 'g', -1, "12" }, + + ftoaTest{ 123456700, 'e', 5, "1.23457e+08" }, + ftoaTest{ 123456700, 'f', 5, "123456700.00000" }, + ftoaTest{ 123456700, 'g', 5, "1.2346e+08" }, + ftoaTest{ 123456700, 'g', -1, "1.234567e+08" }, + + ftoaTest{ 1.2345e6, 'e', 5, "1.23450e+06" }, + ftoaTest{ 1.2345e6, 'f', 5, "1234500.00000" }, + ftoaTest{ 1.2345e6, 'g', 5, "1.2345e+06" }, + + ftoaTest{ 1e23, 'e', 17, "9.99999999999999916e+22" }, + ftoaTest{ 1e23, 'f', 17, "99999999999999991611392.00000000000000000" }, + ftoaTest{ 1e23, 'g', 17, "9.9999999999999992e+22" }, + + ftoaTest{ 1e23, 'e', -1, "1e+23" }, + ftoaTest{ 1e23, 'f', -1, "100000000000000000000000" }, + ftoaTest{ 1e23, 'g', -1, "1e+23" }, + + ftoaTest{ below1e23, 'e', 17, "9.99999999999999748e+22" }, + ftoaTest{ below1e23, 'f', 17, "99999999999999974834176.00000000000000000" }, + ftoaTest{ below1e23, 'g', 17, "9.9999999999999975e+22" }, + + ftoaTest{ below1e23, 'e', -1, "9.999999999999997e+22" }, + ftoaTest{ below1e23, 'f', -1, "99999999999999970000000" }, + ftoaTest{ below1e23, 'g', -1, "9.999999999999997e+22" }, + + ftoaTest{ above1e23, 'e', 17, "1.00000000000000008e+23" }, + ftoaTest{ above1e23, 'f', 17, "100000000000000008388608.00000000000000000" }, + ftoaTest{ above1e23, 'g', 17, "1.0000000000000001e+23" }, + + ftoaTest{ above1e23, 'e', -1, "1.0000000000000001e+23" }, + ftoaTest{ above1e23, 'f', -1, "100000000000000010000000" }, + ftoaTest{ above1e23, 'g', -1, "1.0000000000000001e+23" }, + + ftoaTest{ fdiv(5e-304, 1e20), 'g', -1, "5e-324" }, + ftoaTest{ fdiv(-5e-304, 1e20), 'g', -1, "-5e-324" }, + + ftoaTest{ 32, 'g', -1, "32" }, + ftoaTest{ 32, 'g', 0, "3e+01" }, + + ftoaTest{ 100, 'x', -1, "%x" }, + + ftoaTest{ math.NaN(), 'g', -1, "NaN" }, + ftoaTest{ -math.NaN(), 'g', -1, "NaN" }, + ftoaTest{ math.Inf(0), 'g', -1, "+Inf" }, + ftoaTest{ math.Inf(-1), 'g', -1, "-Inf" }, + ftoaTest{ -math.Inf(0), 'g', -1, "-Inf" }, + + ftoaTest{ -1, 'b', -1, "-4503599627370496p-52" }, +} func TestFtoa(t *testing.T) { if strconv.FloatSize != 32 { diff --git a/src/lib/strconv/itoa_test.go b/src/lib/strconv/itoa_test.go index f67f08739f..34caf9a325 100644 --- a/src/lib/strconv/itoa_test.go +++ b/src/lib/strconv/itoa_test.go @@ -17,47 +17,47 @@ type itob64Test struct { out string; } -var itob64tests = []itob64Test ( - itob64Test( 0, 10, "0" ), - itob64Test( 1, 10, "1" ), - itob64Test( -1, 10, "-1" ), - itob64Test( 12345678, 10, "12345678" ), - itob64Test( -987654321, 10, "-987654321" ), - itob64Test( 1<<31-1, 10, "2147483647" ), - itob64Test( -1<<31+1, 10, "-2147483647" ), - itob64Test( 1<<31, 10, "2147483648" ), - itob64Test( -1<<31, 10, "-2147483648" ), - itob64Test( 1<<31+1, 10, "2147483649" ), - itob64Test( -1<<31-1, 10, "-2147483649" ), - itob64Test( 1<<32-1, 10, "4294967295" ), - itob64Test( -1<<32+1, 10, "-4294967295" ), - itob64Test( 1<<32, 10, "4294967296" ), - itob64Test( -1<<32, 10, "-4294967296" ), - itob64Test( 1<<32+1, 10, "4294967297" ), - itob64Test( -1<<32-1, 10, "-4294967297" ), - itob64Test( 1<<50, 10, "1125899906842624" ), - itob64Test( 1<<63-1, 10, "9223372036854775807" ), - itob64Test( -1<<63+1, 10, "-9223372036854775807" ), - itob64Test( -1<<63, 10, "-9223372036854775808" ), - - itob64Test( 0, 2, "0" ), - itob64Test( 10, 2, "1010" ), - itob64Test( -1, 2, "-1" ), - itob64Test( 1<<15, 2, "1000000000000000" ), - - itob64Test( -8, 8, "-10" ), - itob64Test( 057635436545, 8, "57635436545" ), - itob64Test( 1<<24, 8, "100000000" ), - - itob64Test( 16, 16, "10" ), - itob64Test( -0x123456789abcdef, 16, "-123456789abcdef" ), - itob64Test( 1<<63-1, 16, "7fffffffffffffff" ), - - itob64Test( 16, 17, "g" ), - itob64Test( 25, 25, "10" ), - itob64Test( (((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35+32, 35, "holycow" ), - itob64Test( (((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36+32, 36, "holycow" ), -) +var itob64tests = []itob64Test { + itob64Test{ 0, 10, "0" }, + itob64Test{ 1, 10, "1" }, + itob64Test{ -1, 10, "-1" }, + itob64Test{ 12345678, 10, "12345678" }, + itob64Test{ -987654321, 10, "-987654321" }, + itob64Test{ 1<<31-1, 10, "2147483647" }, + itob64Test{ -1<<31+1, 10, "-2147483647" }, + itob64Test{ 1<<31, 10, "2147483648" }, + itob64Test{ -1<<31, 10, "-2147483648" }, + itob64Test{ 1<<31+1, 10, "2147483649" }, + itob64Test{ -1<<31-1, 10, "-2147483649" }, + itob64Test{ 1<<32-1, 10, "4294967295" }, + itob64Test{ -1<<32+1, 10, "-4294967295" }, + itob64Test{ 1<<32, 10, "4294967296" }, + itob64Test{ -1<<32, 10, "-4294967296" }, + itob64Test{ 1<<32+1, 10, "4294967297" }, + itob64Test{ -1<<32-1, 10, "-4294967297" }, + itob64Test{ 1<<50, 10, "1125899906842624" }, + itob64Test{ 1<<63-1, 10, "9223372036854775807" }, + itob64Test{ -1<<63+1, 10, "-9223372036854775807" }, + itob64Test{ -1<<63, 10, "-9223372036854775808" }, + + itob64Test{ 0, 2, "0" }, + itob64Test{ 10, 2, "1010" }, + itob64Test{ -1, 2, "-1" }, + itob64Test{ 1<<15, 2, "1000000000000000" }, + + itob64Test{ -8, 8, "-10" }, + itob64Test{ 057635436545, 8, "57635436545" }, + itob64Test{ 1<<24, 8, "100000000" }, + + itob64Test{ 16, 16, "10" }, + itob64Test{ -0x123456789abcdef, 16, "-123456789abcdef" }, + itob64Test{ 1<<63-1, 16, "7fffffffffffffff" }, + + itob64Test{ 16, 17, "g" }, + itob64Test{ 25, 25, "10" }, + itob64Test{ (((((17*35+24)*35+21)*35+34)*35+12)*35+24)*35+32, 35, "holycow" }, + itob64Test{ (((((17*36+24)*36+21)*36+34)*36+12)*36+24)*36+32, 36, "holycow" }, +} func TestItoa(t *testing.T) { for i := 0; i < len(itob64tests); i++ { @@ -102,11 +102,10 @@ type uitoa64Test struct { } // TODO: should be able to call this atoui64tests. -var uitoa64tests = []uitoa64Test ( - uitoa64Test( 1<<63-1, "9223372036854775807" ), - uitoa64Test( 1<<63, "9223372036854775808" ), - uitoa64Test( 1<<63+1, "9223372036854775809" ), - uitoa64Test( 1<<64-2, "18446744073709551614" ), - uitoa64Test( 1<<64-1, "18446744073709551615" ), -) - +var uitoa64tests = []uitoa64Test { + uitoa64Test{ 1<<63-1, "9223372036854775807" }, + uitoa64Test{ 1<<63, "9223372036854775808" }, + uitoa64Test{ 1<<63+1, "9223372036854775809" }, + uitoa64Test{ 1<<64-2, "18446744073709551614" }, + uitoa64Test{ 1<<64-1, "18446744073709551615" }, +} diff --git a/src/lib/strconv/quote_test.go b/src/lib/strconv/quote_test.go index 06d72f7537..8421fcde49 100644 --- a/src/lib/strconv/quote_test.go +++ b/src/lib/strconv/quote_test.go @@ -14,14 +14,14 @@ type quoteTest struct { out string; } -var quotetests = []quoteTest ( - quoteTest( "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` ), - quoteTest( "\\", `"\\"` ), - quoteTest( "abc\xffdef", `"abc\xffdef"` ), - quoteTest( "\u263a", `"\u263a"` ), - quoteTest( "\U0010ffff", `"\U0010ffff"` ), - quoteTest( "\x04", `"\x04"` ), -) +var quotetests = []quoteTest { + quoteTest{ "\a\b\f\r\n\t\v", `"\a\b\f\r\n\t\v"` }, + quoteTest{ "\\", `"\\"` }, + quoteTest{ "abc\xffdef", `"abc\xffdef"` }, + quoteTest{ "\u263a", `"\u263a"` }, + quoteTest{ "\U0010ffff", `"\U0010ffff"` }, + quoteTest{ "\x04", `"\x04"` }, +} func TestQuote(t *testing.T) { for i := 0; i < len(quotetests); i++ { @@ -37,46 +37,46 @@ type canBackquoteTest struct { out bool; } -var canbackquotetests = []canBackquoteTest ( - canBackquoteTest( "`", false ), - canBackquoteTest( string(0), false ), - canBackquoteTest( string(1), false ), - canBackquoteTest( string(2), false ), - canBackquoteTest( string(3), false ), - canBackquoteTest( string(4), false ), - canBackquoteTest( string(5), false ), - canBackquoteTest( string(6), false ), - canBackquoteTest( string(7), false ), - canBackquoteTest( string(8), false ), - canBackquoteTest( string(9), false ), - canBackquoteTest( string(10), false ), - canBackquoteTest( string(11), false ), - canBackquoteTest( string(12), false ), - canBackquoteTest( string(13), false ), - canBackquoteTest( string(14), false ), - canBackquoteTest( string(15), false ), - canBackquoteTest( string(16), false ), - canBackquoteTest( string(17), false ), - canBackquoteTest( string(18), false ), - canBackquoteTest( string(19), false ), - canBackquoteTest( string(20), false ), - canBackquoteTest( string(21), false ), - canBackquoteTest( string(22), false ), - canBackquoteTest( string(23), false ), - canBackquoteTest( string(24), false ), - canBackquoteTest( string(25), false ), - canBackquoteTest( string(26), false ), - canBackquoteTest( string(27), false ), - canBackquoteTest( string(28), false ), - canBackquoteTest( string(29), false ), - canBackquoteTest( string(30), false ), - canBackquoteTest( string(31), false ), - canBackquoteTest( `' !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`, true ), - canBackquoteTest( `0123456789`, true ), - canBackquoteTest( `ABCDEFGHIJKLMNOPQRSTUVWXYZ`, true ), - canBackquoteTest( `abcdefghijklmnopqrstuvwxyz`, true ), - canBackquoteTest( `☺`, true ), -) +var canbackquotetests = []canBackquoteTest { + canBackquoteTest{ "`", false }, + canBackquoteTest{ string(0), false }, + canBackquoteTest{ string(1), false }, + canBackquoteTest{ string(2), false }, + canBackquoteTest{ string(3), false }, + canBackquoteTest{ string(4), false }, + canBackquoteTest{ string(5), false }, + canBackquoteTest{ string(6), false }, + canBackquoteTest{ string(7), false }, + canBackquoteTest{ string(8), false }, + canBackquoteTest{ string(9), false }, + canBackquoteTest{ string(10), false }, + canBackquoteTest{ string(11), false }, + canBackquoteTest{ string(12), false }, + canBackquoteTest{ string(13), false }, + canBackquoteTest{ string(14), false }, + canBackquoteTest{ string(15), false }, + canBackquoteTest{ string(16), false }, + canBackquoteTest{ string(17), false }, + canBackquoteTest{ string(18), false }, + canBackquoteTest{ string(19), false }, + canBackquoteTest{ string(20), false }, + canBackquoteTest{ string(21), false }, + canBackquoteTest{ string(22), false }, + canBackquoteTest{ string(23), false }, + canBackquoteTest{ string(24), false }, + canBackquoteTest{ string(25), false }, + canBackquoteTest{ string(26), false }, + canBackquoteTest{ string(27), false }, + canBackquoteTest{ string(28), false }, + canBackquoteTest{ string(29), false }, + canBackquoteTest{ string(30), false }, + canBackquoteTest{ string(31), false }, + canBackquoteTest{ `' !"#$%&'()*+,-./:;<=>?@[\]^_{|}~`, true }, + canBackquoteTest{ `0123456789`, true }, + canBackquoteTest{ `ABCDEFGHIJKLMNOPQRSTUVWXYZ`, true }, + canBackquoteTest{ `abcdefghijklmnopqrstuvwxyz`, true }, + canBackquoteTest{ `☺`, true }, +} func TestCanBackquote(t *testing.T) { for i := 0; i < len(canbackquotetests); i++ { diff --git a/src/lib/strings_test.go b/src/lib/strings_test.go index 0efe254ce5..2cbf70b93b 100644 --- a/src/lib/strings_test.go +++ b/src/lib/strings_test.go @@ -30,10 +30,10 @@ type ExplodeTest struct { s string; a []string; } -var explodetests = []ExplodeTest ( - ExplodeTest( abcd, []string("a", "b", "c", "d") ), - ExplodeTest( faces, []string("☺", "☻", "☹" ) ), -) +var explodetests = []ExplodeTest { + ExplodeTest{ abcd, []string{"a", "b", "c", "d"} }, + ExplodeTest{ faces, []string{"☺", "☻", "☹" } }, +} func TestExplode(t *testing.T) { for i := 0; i < len(explodetests); i++ { tt := explodetests[i]; @@ -54,16 +54,16 @@ type SplitTest struct { sep string; a []string; } -var splittests = []SplitTest ( - SplitTest( abcd, "a", []string("", "bcd") ), - SplitTest( abcd, "z", []string("abcd") ), - SplitTest( abcd, "", []string("a", "b", "c", "d") ), - SplitTest( commas, ",", []string("1", "2", "3", "4") ), - SplitTest( dots, "...", []string("1", ".2", ".3", ".4") ), - SplitTest( faces, "☹", []string("☺☻", "") ), - SplitTest( faces, "~", []string(faces) ), - SplitTest( faces, "", []string("☺", "☻", "☹") ), -) +var splittests = []SplitTest { + SplitTest{ abcd, "a", []string{"", "bcd"} }, + SplitTest{ abcd, "z", []string{"abcd"} }, + SplitTest{ abcd, "", []string{"a", "b", "c", "d"} }, + SplitTest{ commas, ",", []string{"1", "2", "3", "4"} }, + SplitTest{ dots, "...", []string{"1", ".2", ".3", ".4"} }, + SplitTest{ faces, "☹", []string{"☺☻", ""} }, + SplitTest{ faces, "~", []string{faces} }, + SplitTest{ faces, "", []string{"☺", "☻", "☹"} }, +} func TestSplit(t *testing.T) { for i := 0; i < len(splittests); i++ { tt := splittests[i]; diff --git a/src/lib/tabwriter/tabwriter.go b/src/lib/tabwriter/tabwriter.go index 5b02ff2f11..de37204d15 100644 --- a/src/lib/tabwriter/tabwriter.go +++ b/src/lib/tabwriter/tabwriter.go @@ -202,7 +202,7 @@ func (b *Writer) write0(buf []byte) *os.Error { } -var newline = []byte('\n') +var newline = []byte{'\n'} func (b *Writer) writePadding(textw, cellw int) (err *os.Error) { if b.padbytes[0] == '\t' { diff --git a/src/lib/time/time.go b/src/lib/time/time.go index abc1b56438..665b1c5ca4 100644 --- a/src/lib/time/time.go +++ b/src/lib/time/time.go @@ -46,12 +46,12 @@ type Time struct { Zone string; } -var nonleapyear = []int( +var nonleapyear = []int{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 -) -var leapyear = []int( +} +var leapyear = []int{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 -) +} func months(year int64) []int { if year%4 == 0 && (year%100 != 0 || year%400 == 0) { @@ -220,7 +220,7 @@ func (t *Time) Seconds() int64 { return sec } -var longDayNames = []string( +var longDayNames = []string{ "Sunday", "Monday", "Tuesday", @@ -228,9 +228,9 @@ var longDayNames = []string( "Thursday", "Friday", "Saturday" -) +} -var shortDayNames = []string( +var shortDayNames = []string{ "Sun", "Mon", "Tue", @@ -238,9 +238,9 @@ var shortDayNames = []string( "Thu", "Fri", "Sat" -) +} -var shortMonthNames = []string( +var shortMonthNames = []string{ "Jan", "Feb", "Mar", @@ -253,7 +253,7 @@ var shortMonthNames = []string( "Oct", "Nov", "Dec" -) +} func copy(dst []byte, s string) { for i := 0; i < len(s); i++ { diff --git a/src/lib/time/time_test.go b/src/lib/time/time_test.go index a816e1d50e..41e6736e83 100644 --- a/src/lib/time/time_test.go +++ b/src/lib/time/time_test.go @@ -22,20 +22,20 @@ type TimeTest struct { golden Time; } -var utctests = []TimeTest ( - TimeTest(0, Time(1970, 1, 1, 0, 0, 0, Thursday, 0, "UTC")), - TimeTest(1221681866, Time(2008, 9, 17, 20, 4, 26, Wednesday, 0, "UTC")), - TimeTest(-1221681866, Time(1931, 4, 16, 3, 55, 34, Thursday, 0, "UTC")), - TimeTest(1e18, Time(31688740476, 10, 23, 1, 46, 40, Friday, 0, "UTC")), - TimeTest(-1e18, Time(-31688736537, 3, 10, 22, 13, 20, Tuesday, 0, "UTC")), - TimeTest(0x7fffffffffffffff, Time(292277026596, 12, 4, 15, 30, 7, Sunday, 0, "UTC")), - TimeTest(-0x8000000000000000, Time(-292277022657, 1, 27, 8, 29, 52, Sunday, 0, "UTC")) -) +var utctests = []TimeTest { + TimeTest{0, Time{1970, 1, 1, 0, 0, 0, Thursday, 0, "UTC"}}, + TimeTest{1221681866, Time{2008, 9, 17, 20, 4, 26, Wednesday, 0, "UTC"}}, + TimeTest{-1221681866, Time{1931, 4, 16, 3, 55, 34, Thursday, 0, "UTC"}}, + TimeTest{1e18, Time{31688740476, 10, 23, 1, 46, 40, Friday, 0, "UTC"}}, + TimeTest{-1e18, Time{-31688736537, 3, 10, 22, 13, 20, Tuesday, 0, "UTC"}}, + TimeTest{0x7fffffffffffffff, Time{292277026596, 12, 4, 15, 30, 7, Sunday, 0, "UTC"}}, + TimeTest{-0x8000000000000000, Time{-292277022657, 1, 27, 8, 29, 52, Sunday, 0, "UTC"}} +} -var localtests = []TimeTest ( - TimeTest(0, Time(1969, 12, 31, 16, 0, 0, Wednesday, -8*60*60, "PST")), - TimeTest(1221681866, Time(2008, 9, 17, 13, 4, 26, Wednesday, -7*60*60, "PDT")) -) +var localtests = []TimeTest { + TimeTest{0, Time{1969, 12, 31, 16, 0, 0, Wednesday, -8*60*60, "PST"}}, + TimeTest{1221681866, Time{2008, 9, 17, 13, 4, 26, Wednesday, -7*60*60, "PDT"}} +} func same(t, u *Time) bool { return t.Year == u.Year diff --git a/src/lib/time/zoneinfo.go b/src/lib/time/zoneinfo.go index ea75f8cb98..577434c915 100644 --- a/src/lib/time/zoneinfo.go +++ b/src/lib/time/zoneinfo.go @@ -88,7 +88,7 @@ type zonetime struct { } func parseinfo(bytes []byte) (zt []zonetime, err *os.Error) { - d := data(bytes, false); + d := data{bytes, false}; // 4-byte magic "TZif" if magic := d.read(4); string(magic) != "TZif" { @@ -127,19 +127,19 @@ func parseinfo(bytes []byte) (zt []zonetime, err *os.Error) { } // Transition times. - txtimes := data(d.read(n[NTime]*4), false); + txtimes := data{d.read(n[NTime]*4), false}; // Time zone indices for transition times. txzones := d.read(n[NTime]); // Zone info structures - zonedata := data(d.read(n[NZone]*6), false); + zonedata := data{d.read(n[NZone]*6), false}; // Time zone abbreviations. abbrev := d.read(n[NChar]); // Leap-second time pairs - leapdata := data(d.read(n[NLeap]*8), false); + leapdata := data{d.read(n[NLeap]*8), false}; // Whether tx times associated with local time types // are specified as standard time or wall time. diff --git a/src/lib/unicode/letter.go b/src/lib/unicode/letter.go index 61310bca91..3b1221b87b 100644 --- a/src/lib/unicode/letter.go +++ b/src/lib/unicode/letter.go @@ -18,512 +18,512 @@ type Range struct { stride int; } -var Upper = []Range( - Range(0x0041, 0x005a, 1), - Range(0x00c0, 0x00d6, 1), - Range(0x00d8, 0x00de, 1), - Range(0x0100, 0x0136, 2), - Range(0x0139, 0x0147, 2), - Range(0x014a, 0x0176, 2), - Range(0x0178, 0x0179, 1), - Range(0x017b, 0x017d, 2), - Range(0x0181, 0x0182, 1), - Range(0x0184, 0x0184, 1), - Range(0x0186, 0x0187, 1), - Range(0x0189, 0x018b, 1), - Range(0x018e, 0x0191, 1), - Range(0x0193, 0x0194, 1), - Range(0x0196, 0x0198, 1), - Range(0x019c, 0x019d, 1), - Range(0x019f, 0x01a0, 1), - Range(0x01a2, 0x01a4, 2), - Range(0x01a6, 0x01a7, 1), - Range(0x01a9, 0x01ac, 3), - Range(0x01ae, 0x01af, 1), - Range(0x01b1, 0x01b3, 1), - Range(0x01b5, 0x01b5, 1), - Range(0x01b7, 0x01b8, 1), - Range(0x01bc, 0x01c4, 8), - Range(0x01c7, 0x01cd, 3), - Range(0x01cf, 0x01db, 2), - Range(0x01de, 0x01ee, 2), - Range(0x01f1, 0x01f4, 3), - Range(0x01f6, 0x01f8, 1), - Range(0x01fa, 0x0232, 2), - Range(0x023a, 0x023b, 1), - Range(0x023d, 0x023e, 1), - Range(0x0241, 0x0241, 1), - Range(0x0243, 0x0246, 1), - Range(0x0248, 0x024e, 2), - Range(0x0370, 0x0372, 2), - Range(0x0376, 0x0386, 16), - Range(0x0388, 0x038a, 1), - Range(0x038c, 0x038c, 1), - Range(0x038e, 0x038f, 1), - Range(0x0391, 0x03a1, 1), - Range(0x03a3, 0x03ab, 1), - Range(0x03cf, 0x03cf, 1), - Range(0x03d2, 0x03d4, 1), - Range(0x03d8, 0x03ee, 2), - Range(0x03f4, 0x03f7, 3), - Range(0x03f9, 0x03fa, 1), - Range(0x03fd, 0x042f, 1), - Range(0x0460, 0x0480, 2), - Range(0x048a, 0x04be, 2), - Range(0x04c0, 0x04c1, 1), - Range(0x04c3, 0x04cd, 2), - Range(0x04d0, 0x0522, 2), - Range(0x0531, 0x0556, 1), - Range(0x10a0, 0x10c5, 1), - Range(0x1e00, 0x1e94, 2), - Range(0x1e9e, 0x1efe, 2), - Range(0x1f08, 0x1f0f, 1), - Range(0x1f18, 0x1f1d, 1), - Range(0x1f28, 0x1f2f, 1), - Range(0x1f38, 0x1f3f, 1), - Range(0x1f48, 0x1f4d, 1), - Range(0x1f59, 0x1f5f, 2), - Range(0x1f68, 0x1f6f, 1), - Range(0x1fb8, 0x1fbb, 1), - Range(0x1fc8, 0x1fcb, 1), - Range(0x1fd8, 0x1fdb, 1), - Range(0x1fe8, 0x1fec, 1), - Range(0x1ff8, 0x1ffb, 1), - Range(0x2102, 0x2107, 5), - Range(0x210b, 0x210d, 1), - Range(0x2110, 0x2112, 1), - Range(0x2115, 0x2115, 1), - Range(0x2119, 0x211d, 1), - Range(0x2124, 0x2128, 2), - Range(0x212a, 0x212d, 1), - Range(0x2130, 0x2133, 1), - Range(0x213e, 0x213f, 1), - Range(0x2145, 0x2183, 62), - Range(0x2c00, 0x2c2e, 1), - Range(0x2c60, 0x2c60, 1), - Range(0x2c62, 0x2c64, 1), - Range(0x2c67, 0x2c6b, 2), - Range(0x2c6d, 0x2c6f, 1), - Range(0x2c72, 0x2c75, 3), - Range(0x2c80, 0x2ce2, 2), - Range(0xa640, 0xa65e, 2), - Range(0xa662, 0xa66c, 2), - Range(0xa680, 0xa696, 2), - Range(0xa722, 0xa72e, 2), - Range(0xa732, 0xa76e, 2), - Range(0xa779, 0xa77b, 2), - Range(0xa77d, 0xa77e, 1), - Range(0xa780, 0xa786, 2), - Range(0xa78b, 0xa78b, 1), - Range(0xff21, 0xff3a, 1), - Range(0x10400, 0x10427, 1), - Range(0x1d400, 0x1d419, 1), - Range(0x1d434, 0x1d44d, 1), - Range(0x1d468, 0x1d481, 1), - Range(0x1d49c, 0x1d49c, 1), - Range(0x1d49e, 0x1d49f, 1), - Range(0x1d4a2, 0x1d4a2, 1), - Range(0x1d4a5, 0x1d4a6, 1), - Range(0x1d4a9, 0x1d4ac, 1), - Range(0x1d4ae, 0x1d4b5, 1), - Range(0x1d4d0, 0x1d4e9, 1), - Range(0x1d504, 0x1d505, 1), - Range(0x1d507, 0x1d50a, 1), - Range(0x1d50d, 0x1d514, 1), - Range(0x1d516, 0x1d51c, 1), - Range(0x1d538, 0x1d539, 1), - Range(0x1d53b, 0x1d53e, 1), - Range(0x1d540, 0x1d544, 1), - Range(0x1d546, 0x1d546, 1), - Range(0x1d54a, 0x1d550, 1), - Range(0x1d56c, 0x1d585, 1), - Range(0x1d5a0, 0x1d5b9, 1), - Range(0x1d5d4, 0x1d5ed, 1), - Range(0x1d608, 0x1d621, 1), - Range(0x1d63c, 0x1d655, 1), - Range(0x1d670, 0x1d689, 1), - Range(0x1d6a8, 0x1d6c0, 1), - Range(0x1d6e2, 0x1d6fa, 1), - Range(0x1d71c, 0x1d734, 1), - Range(0x1d756, 0x1d76e, 1), - Range(0x1d790, 0x1d7a8, 1), - Range(0x1d7ca, 0x1d7ca, 1), -) +var Upper = []Range{ + Range{0x0041, 0x005a, 1}, + Range{0x00c0, 0x00d6, 1}, + Range{0x00d8, 0x00de, 1}, + Range{0x0100, 0x0136, 2}, + Range{0x0139, 0x0147, 2}, + Range{0x014a, 0x0176, 2}, + Range{0x0178, 0x0179, 1}, + Range{0x017b, 0x017d, 2}, + Range{0x0181, 0x0182, 1}, + Range{0x0184, 0x0184, 1}, + Range{0x0186, 0x0187, 1}, + Range{0x0189, 0x018b, 1}, + Range{0x018e, 0x0191, 1}, + Range{0x0193, 0x0194, 1}, + Range{0x0196, 0x0198, 1}, + Range{0x019c, 0x019d, 1}, + Range{0x019f, 0x01a0, 1}, + Range{0x01a2, 0x01a4, 2}, + Range{0x01a6, 0x01a7, 1}, + Range{0x01a9, 0x01ac, 3}, + Range{0x01ae, 0x01af, 1}, + Range{0x01b1, 0x01b3, 1}, + Range{0x01b5, 0x01b5, 1}, + Range{0x01b7, 0x01b8, 1}, + Range{0x01bc, 0x01c4, 8}, + Range{0x01c7, 0x01cd, 3}, + Range{0x01cf, 0x01db, 2}, + Range{0x01de, 0x01ee, 2}, + Range{0x01f1, 0x01f4, 3}, + Range{0x01f6, 0x01f8, 1}, + Range{0x01fa, 0x0232, 2}, + Range{0x023a, 0x023b, 1}, + Range{0x023d, 0x023e, 1}, + Range{0x0241, 0x0241, 1}, + Range{0x0243, 0x0246, 1}, + Range{0x0248, 0x024e, 2}, + Range{0x0370, 0x0372, 2}, + Range{0x0376, 0x0386, 16}, + Range{0x0388, 0x038a, 1}, + Range{0x038c, 0x038c, 1}, + Range{0x038e, 0x038f, 1}, + Range{0x0391, 0x03a1, 1}, + Range{0x03a3, 0x03ab, 1}, + Range{0x03cf, 0x03cf, 1}, + Range{0x03d2, 0x03d4, 1}, + Range{0x03d8, 0x03ee, 2}, + Range{0x03f4, 0x03f7, 3}, + Range{0x03f9, 0x03fa, 1}, + Range{0x03fd, 0x042f, 1}, + Range{0x0460, 0x0480, 2}, + Range{0x048a, 0x04be, 2}, + Range{0x04c0, 0x04c1, 1}, + Range{0x04c3, 0x04cd, 2}, + Range{0x04d0, 0x0522, 2}, + Range{0x0531, 0x0556, 1}, + Range{0x10a0, 0x10c5, 1}, + Range{0x1e00, 0x1e94, 2}, + Range{0x1e9e, 0x1efe, 2}, + Range{0x1f08, 0x1f0f, 1}, + Range{0x1f18, 0x1f1d, 1}, + Range{0x1f28, 0x1f2f, 1}, + Range{0x1f38, 0x1f3f, 1}, + Range{0x1f48, 0x1f4d, 1}, + Range{0x1f59, 0x1f5f, 2}, + Range{0x1f68, 0x1f6f, 1}, + Range{0x1fb8, 0x1fbb, 1}, + Range{0x1fc8, 0x1fcb, 1}, + Range{0x1fd8, 0x1fdb, 1}, + Range{0x1fe8, 0x1fec, 1}, + Range{0x1ff8, 0x1ffb, 1}, + Range{0x2102, 0x2107, 5}, + Range{0x210b, 0x210d, 1}, + Range{0x2110, 0x2112, 1}, + Range{0x2115, 0x2115, 1}, + Range{0x2119, 0x211d, 1}, + Range{0x2124, 0x2128, 2}, + Range{0x212a, 0x212d, 1}, + Range{0x2130, 0x2133, 1}, + Range{0x213e, 0x213f, 1}, + Range{0x2145, 0x2183, 62}, + Range{0x2c00, 0x2c2e, 1}, + Range{0x2c60, 0x2c60, 1}, + Range{0x2c62, 0x2c64, 1}, + Range{0x2c67, 0x2c6b, 2}, + Range{0x2c6d, 0x2c6f, 1}, + Range{0x2c72, 0x2c75, 3}, + Range{0x2c80, 0x2ce2, 2}, + Range{0xa640, 0xa65e, 2}, + Range{0xa662, 0xa66c, 2}, + Range{0xa680, 0xa696, 2}, + Range{0xa722, 0xa72e, 2}, + Range{0xa732, 0xa76e, 2}, + Range{0xa779, 0xa77b, 2}, + Range{0xa77d, 0xa77e, 1}, + Range{0xa780, 0xa786, 2}, + Range{0xa78b, 0xa78b, 1}, + Range{0xff21, 0xff3a, 1}, + Range{0x10400, 0x10427, 1}, + Range{0x1d400, 0x1d419, 1}, + Range{0x1d434, 0x1d44d, 1}, + Range{0x1d468, 0x1d481, 1}, + Range{0x1d49c, 0x1d49c, 1}, + Range{0x1d49e, 0x1d49f, 1}, + Range{0x1d4a2, 0x1d4a2, 1}, + Range{0x1d4a5, 0x1d4a6, 1}, + Range{0x1d4a9, 0x1d4ac, 1}, + Range{0x1d4ae, 0x1d4b5, 1}, + Range{0x1d4d0, 0x1d4e9, 1}, + Range{0x1d504, 0x1d505, 1}, + Range{0x1d507, 0x1d50a, 1}, + Range{0x1d50d, 0x1d514, 1}, + Range{0x1d516, 0x1d51c, 1}, + Range{0x1d538, 0x1d539, 1}, + Range{0x1d53b, 0x1d53e, 1}, + Range{0x1d540, 0x1d544, 1}, + Range{0x1d546, 0x1d546, 1}, + Range{0x1d54a, 0x1d550, 1}, + Range{0x1d56c, 0x1d585, 1}, + Range{0x1d5a0, 0x1d5b9, 1}, + Range{0x1d5d4, 0x1d5ed, 1}, + Range{0x1d608, 0x1d621, 1}, + Range{0x1d63c, 0x1d655, 1}, + Range{0x1d670, 0x1d689, 1}, + Range{0x1d6a8, 0x1d6c0, 1}, + Range{0x1d6e2, 0x1d6fa, 1}, + Range{0x1d71c, 0x1d734, 1}, + Range{0x1d756, 0x1d76e, 1}, + Range{0x1d790, 0x1d7a8, 1}, + Range{0x1d7ca, 0x1d7ca, 1}, +} -var Letter = []Range ( - Range(0x0041, 0x005a, 1), - Range(0x0061, 0x007a, 1), - Range(0x00aa, 0x00b5, 11), - Range(0x00ba, 0x00ba, 1), - Range(0x00c0, 0x00d6, 1), - Range(0x00d8, 0x00f6, 1), - Range(0x00f8, 0x02c1, 1), - Range(0x02c6, 0x02d1, 1), - Range(0x02e0, 0x02e4, 1), - Range(0x02ec, 0x02ee, 2), - Range(0x0370, 0x0374, 1), - Range(0x0376, 0x0377, 1), - Range(0x037a, 0x037d, 1), - Range(0x0386, 0x0386, 1), - Range(0x0388, 0x038a, 1), - Range(0x038c, 0x038c, 1), - Range(0x038e, 0x03a1, 1), - Range(0x03a3, 0x03f5, 1), - Range(0x03f7, 0x0481, 1), - Range(0x048a, 0x0523, 1), - Range(0x0531, 0x0556, 1), - Range(0x0559, 0x0559, 1), - Range(0x0561, 0x0587, 1), - Range(0x05d0, 0x05ea, 1), - Range(0x05f0, 0x05f2, 1), - Range(0x0621, 0x064a, 1), - Range(0x066e, 0x066f, 1), - Range(0x0671, 0x06d3, 1), - Range(0x06d5, 0x06d5, 1), - Range(0x06e5, 0x06e6, 1), - Range(0x06ee, 0x06ef, 1), - Range(0x06fa, 0x06fc, 1), - Range(0x06ff, 0x0710, 17), - Range(0x0712, 0x072f, 1), - Range(0x074d, 0x07a5, 1), - Range(0x07b1, 0x07b1, 1), - Range(0x07ca, 0x07ea, 1), - Range(0x07f4, 0x07f5, 1), - Range(0x07fa, 0x07fa, 1), - Range(0x0904, 0x0939, 1), - Range(0x093d, 0x0950, 19), - Range(0x0958, 0x0961, 1), - Range(0x0971, 0x0972, 1), - Range(0x097b, 0x097f, 1), - Range(0x0985, 0x098c, 1), - Range(0x098f, 0x0990, 1), - Range(0x0993, 0x09a8, 1), - Range(0x09aa, 0x09b0, 1), - Range(0x09b2, 0x09b2, 1), - Range(0x09b6, 0x09b9, 1), - Range(0x09bd, 0x09ce, 17), - Range(0x09dc, 0x09dd, 1), - Range(0x09df, 0x09e1, 1), - Range(0x09f0, 0x09f1, 1), - Range(0x0a05, 0x0a0a, 1), - Range(0x0a0f, 0x0a10, 1), - Range(0x0a13, 0x0a28, 1), - Range(0x0a2a, 0x0a30, 1), - Range(0x0a32, 0x0a33, 1), - Range(0x0a35, 0x0a36, 1), - Range(0x0a38, 0x0a39, 1), - Range(0x0a59, 0x0a5c, 1), - Range(0x0a5e, 0x0a5e, 1), - Range(0x0a72, 0x0a74, 1), - Range(0x0a85, 0x0a8d, 1), - Range(0x0a8f, 0x0a91, 1), - Range(0x0a93, 0x0aa8, 1), - Range(0x0aaa, 0x0ab0, 1), - Range(0x0ab2, 0x0ab3, 1), - Range(0x0ab5, 0x0ab9, 1), - Range(0x0abd, 0x0ad0, 19), - Range(0x0ae0, 0x0ae1, 1), - Range(0x0b05, 0x0b0c, 1), - Range(0x0b0f, 0x0b10, 1), - Range(0x0b13, 0x0b28, 1), - Range(0x0b2a, 0x0b30, 1), - Range(0x0b32, 0x0b33, 1), - Range(0x0b35, 0x0b39, 1), - Range(0x0b3d, 0x0b3d, 1), - Range(0x0b5c, 0x0b5d, 1), - Range(0x0b5f, 0x0b61, 1), - Range(0x0b71, 0x0b83, 18), - Range(0x0b85, 0x0b8a, 1), - Range(0x0b8e, 0x0b90, 1), - Range(0x0b92, 0x0b95, 1), - Range(0x0b99, 0x0b9a, 1), - Range(0x0b9c, 0x0b9c, 1), - Range(0x0b9e, 0x0b9f, 1), - Range(0x0ba3, 0x0ba4, 1), - Range(0x0ba8, 0x0baa, 1), - Range(0x0bae, 0x0bb9, 1), - Range(0x0bd0, 0x0bd0, 1), - Range(0x0c05, 0x0c0c, 1), - Range(0x0c0e, 0x0c10, 1), - Range(0x0c12, 0x0c28, 1), - Range(0x0c2a, 0x0c33, 1), - Range(0x0c35, 0x0c39, 1), - Range(0x0c3d, 0x0c3d, 1), - Range(0x0c58, 0x0c59, 1), - Range(0x0c60, 0x0c61, 1), - Range(0x0c85, 0x0c8c, 1), - Range(0x0c8e, 0x0c90, 1), - Range(0x0c92, 0x0ca8, 1), - Range(0x0caa, 0x0cb3, 1), - Range(0x0cb5, 0x0cb9, 1), - Range(0x0cbd, 0x0cde, 33), - Range(0x0ce0, 0x0ce1, 1), - Range(0x0d05, 0x0d0c, 1), - Range(0x0d0e, 0x0d10, 1), - Range(0x0d12, 0x0d28, 1), - Range(0x0d2a, 0x0d39, 1), - Range(0x0d3d, 0x0d3d, 1), - Range(0x0d60, 0x0d61, 1), - Range(0x0d7a, 0x0d7f, 1), - Range(0x0d85, 0x0d96, 1), - Range(0x0d9a, 0x0db1, 1), - Range(0x0db3, 0x0dbb, 1), - Range(0x0dbd, 0x0dbd, 1), - Range(0x0dc0, 0x0dc6, 1), - Range(0x0e01, 0x0e30, 1), - Range(0x0e32, 0x0e33, 1), - Range(0x0e40, 0x0e46, 1), - Range(0x0e81, 0x0e82, 1), - Range(0x0e84, 0x0e84, 1), - Range(0x0e87, 0x0e88, 1), - Range(0x0e8a, 0x0e8d, 3), - Range(0x0e94, 0x0e97, 1), - Range(0x0e99, 0x0e9f, 1), - Range(0x0ea1, 0x0ea3, 1), - Range(0x0ea5, 0x0ea7, 2), - Range(0x0eaa, 0x0eab, 1), - Range(0x0ead, 0x0eb0, 1), - Range(0x0eb2, 0x0eb3, 1), - Range(0x0ebd, 0x0ebd, 1), - Range(0x0ec0, 0x0ec4, 1), - Range(0x0ec6, 0x0ec6, 1), - Range(0x0edc, 0x0edd, 1), - Range(0x0f00, 0x0f00, 1), - Range(0x0f40, 0x0f47, 1), - Range(0x0f49, 0x0f6c, 1), - Range(0x0f88, 0x0f8b, 1), - Range(0x1000, 0x102a, 1), - Range(0x103f, 0x103f, 1), - Range(0x1050, 0x1055, 1), - Range(0x105a, 0x105d, 1), - Range(0x1061, 0x1061, 1), - Range(0x1065, 0x1066, 1), - Range(0x106e, 0x1070, 1), - Range(0x1075, 0x1081, 1), - Range(0x108e, 0x108e, 1), - Range(0x10a0, 0x10c5, 1), - Range(0x10d0, 0x10fa, 1), - Range(0x10fc, 0x10fc, 1), - Range(0x1100, 0x1159, 1), - Range(0x115f, 0x11a2, 1), - Range(0x11a8, 0x11f9, 1), - Range(0x1200, 0x1248, 1), - Range(0x124a, 0x124d, 1), - Range(0x1250, 0x1256, 1), - Range(0x1258, 0x1258, 1), - Range(0x125a, 0x125d, 1), - Range(0x1260, 0x1288, 1), - Range(0x128a, 0x128d, 1), - Range(0x1290, 0x12b0, 1), - Range(0x12b2, 0x12b5, 1), - Range(0x12b8, 0x12be, 1), - Range(0x12c0, 0x12c0, 1), - Range(0x12c2, 0x12c5, 1), - Range(0x12c8, 0x12d6, 1), - Range(0x12d8, 0x1310, 1), - Range(0x1312, 0x1315, 1), - Range(0x1318, 0x135a, 1), - Range(0x1380, 0x138f, 1), - Range(0x13a0, 0x13f4, 1), - Range(0x1401, 0x166c, 1), - Range(0x166f, 0x1676, 1), - Range(0x1681, 0x169a, 1), - Range(0x16a0, 0x16ea, 1), - Range(0x1700, 0x170c, 1), - Range(0x170e, 0x1711, 1), - Range(0x1720, 0x1731, 1), - Range(0x1740, 0x1751, 1), - Range(0x1760, 0x176c, 1), - Range(0x176e, 0x1770, 1), - Range(0x1780, 0x17b3, 1), - Range(0x17d7, 0x17dc, 5), - Range(0x1820, 0x1877, 1), - Range(0x1880, 0x18a8, 1), - Range(0x18aa, 0x18aa, 1), - Range(0x1900, 0x191c, 1), - Range(0x1950, 0x196d, 1), - Range(0x1970, 0x1974, 1), - Range(0x1980, 0x19a9, 1), - Range(0x19c1, 0x19c7, 1), - Range(0x1a00, 0x1a16, 1), - Range(0x1b05, 0x1b33, 1), - Range(0x1b45, 0x1b4b, 1), - Range(0x1b83, 0x1ba0, 1), - Range(0x1bae, 0x1baf, 1), - Range(0x1c00, 0x1c23, 1), - Range(0x1c4d, 0x1c4f, 1), - Range(0x1c5a, 0x1c7d, 1), - Range(0x1d00, 0x1dbf, 1), - Range(0x1e00, 0x1f15, 1), - Range(0x1f18, 0x1f1d, 1), - Range(0x1f20, 0x1f45, 1), - Range(0x1f48, 0x1f4d, 1), - Range(0x1f50, 0x1f57, 1), - Range(0x1f59, 0x1f5d, 2), - Range(0x1f5f, 0x1f7d, 1), - Range(0x1f80, 0x1fb4, 1), - Range(0x1fb6, 0x1fbc, 1), - Range(0x1fbe, 0x1fbe, 1), - Range(0x1fc2, 0x1fc4, 1), - Range(0x1fc6, 0x1fcc, 1), - Range(0x1fd0, 0x1fd3, 1), - Range(0x1fd6, 0x1fdb, 1), - Range(0x1fe0, 0x1fec, 1), - Range(0x1ff2, 0x1ff4, 1), - Range(0x1ff6, 0x1ffc, 1), - Range(0x2071, 0x207f, 14), - Range(0x2090, 0x2094, 1), - Range(0x2102, 0x2107, 5), - Range(0x210a, 0x2113, 1), - Range(0x2115, 0x2115, 1), - Range(0x2119, 0x211d, 1), - Range(0x2124, 0x2128, 2), - Range(0x212a, 0x212d, 1), - Range(0x212f, 0x2139, 1), - Range(0x213c, 0x213f, 1), - Range(0x2145, 0x2149, 1), - Range(0x214e, 0x214e, 1), - Range(0x2183, 0x2184, 1), - Range(0x2c00, 0x2c2e, 1), - Range(0x2c30, 0x2c5e, 1), - Range(0x2c60, 0x2c6f, 1), - Range(0x2c71, 0x2c7d, 1), - Range(0x2c80, 0x2ce4, 1), - Range(0x2d00, 0x2d25, 1), - Range(0x2d30, 0x2d65, 1), - Range(0x2d6f, 0x2d6f, 1), - Range(0x2d80, 0x2d96, 1), - Range(0x2da0, 0x2da6, 1), - Range(0x2da8, 0x2dae, 1), - Range(0x2db0, 0x2db6, 1), - Range(0x2db8, 0x2dbe, 1), - Range(0x2dc0, 0x2dc6, 1), - Range(0x2dc8, 0x2dce, 1), - Range(0x2dd0, 0x2dd6, 1), - Range(0x2dd8, 0x2dde, 1), - Range(0x2e2f, 0x2e2f, 1), - Range(0x3005, 0x3006, 1), - Range(0x3031, 0x3035, 1), - Range(0x303b, 0x303c, 1), - Range(0x3041, 0x3096, 1), - Range(0x309d, 0x309f, 1), - Range(0x30a1, 0x30fa, 1), - Range(0x30fc, 0x30ff, 1), - Range(0x3105, 0x312d, 1), - Range(0x3131, 0x318e, 1), - Range(0x31a0, 0x31b7, 1), - Range(0x31f0, 0x31ff, 1), - Range(0x3400, 0x4db5, 1), - Range(0x4e00, 0x9fc3, 1), - Range(0xa000, 0xa48c, 1), - Range(0xa500, 0xa60c, 1), - Range(0xa610, 0xa61f, 1), - Range(0xa62a, 0xa62b, 1), - Range(0xa640, 0xa65f, 1), - Range(0xa662, 0xa66e, 1), - Range(0xa67f, 0xa697, 1), - Range(0xa717, 0xa71f, 1), - Range(0xa722, 0xa788, 1), - Range(0xa78b, 0xa78c, 1), - Range(0xa7fb, 0xa801, 1), - Range(0xa803, 0xa805, 1), - Range(0xa807, 0xa80a, 1), - Range(0xa80c, 0xa822, 1), - Range(0xa840, 0xa873, 1), - Range(0xa882, 0xa8b3, 1), - Range(0xa90a, 0xa925, 1), - Range(0xa930, 0xa946, 1), - Range(0xaa00, 0xaa28, 1), - Range(0xaa40, 0xaa42, 1), - Range(0xaa44, 0xaa4b, 1), - Range(0xac00, 0xd7a3, 1), - Range(0xf900, 0xfa2d, 1), - Range(0xfa30, 0xfa6a, 1), - Range(0xfa70, 0xfad9, 1), - Range(0xfb00, 0xfb06, 1), - Range(0xfb13, 0xfb17, 1), - Range(0xfb1d, 0xfb1d, 1), - Range(0xfb1f, 0xfb28, 1), - Range(0xfb2a, 0xfb36, 1), - Range(0xfb38, 0xfb3c, 1), - Range(0xfb3e, 0xfb3e, 1), - Range(0xfb40, 0xfb41, 1), - Range(0xfb43, 0xfb44, 1), - Range(0xfb46, 0xfbb1, 1), - Range(0xfbd3, 0xfd3d, 1), - Range(0xfd50, 0xfd8f, 1), - Range(0xfd92, 0xfdc7, 1), - Range(0xfdf0, 0xfdfb, 1), - Range(0xfe70, 0xfe74, 1), - Range(0xfe76, 0xfefc, 1), - Range(0xff21, 0xff3a, 1), - Range(0xff41, 0xff5a, 1), - Range(0xff66, 0xffbe, 1), - Range(0xffc2, 0xffc7, 1), - Range(0xffca, 0xffcf, 1), - Range(0xffd2, 0xffd7, 1), - Range(0xffda, 0xffdc, 1), - Range(0x10000, 0x1000b, 1), - Range(0x1000d, 0x10026, 1), - Range(0x10028, 0x1003a, 1), - Range(0x1003c, 0x1003d, 1), - Range(0x1003f, 0x1004d, 1), - Range(0x10050, 0x1005d, 1), - Range(0x10080, 0x100fa, 1), - Range(0x10280, 0x1029c, 1), - Range(0x102a0, 0x102d0, 1), - Range(0x10300, 0x1031e, 1), - Range(0x10330, 0x10340, 1), - Range(0x10342, 0x10349, 1), - Range(0x10380, 0x1039d, 1), - Range(0x103a0, 0x103c3, 1), - Range(0x103c8, 0x103cf, 1), - Range(0x10400, 0x1049d, 1), - Range(0x10800, 0x10805, 1), - Range(0x10808, 0x10808, 1), - Range(0x1080a, 0x10835, 1), - Range(0x10837, 0x10838, 1), - Range(0x1083c, 0x1083f, 3), - Range(0x10900, 0x10915, 1), - Range(0x10920, 0x10939, 1), - Range(0x10a00, 0x10a00, 1), - Range(0x10a10, 0x10a13, 1), - Range(0x10a15, 0x10a17, 1), - Range(0x10a19, 0x10a33, 1), - Range(0x12000, 0x1236e, 1), - Range(0x1d400, 0x1d454, 1), - Range(0x1d456, 0x1d49c, 1), - Range(0x1d49e, 0x1d49f, 1), - Range(0x1d4a2, 0x1d4a2, 1), - Range(0x1d4a5, 0x1d4a6, 1), - Range(0x1d4a9, 0x1d4ac, 1), - Range(0x1d4ae, 0x1d4b9, 1), - Range(0x1d4bb, 0x1d4bb, 1), - Range(0x1d4bd, 0x1d4c3, 1), - Range(0x1d4c5, 0x1d505, 1), - Range(0x1d507, 0x1d50a, 1), - Range(0x1d50d, 0x1d514, 1), - Range(0x1d516, 0x1d51c, 1), - Range(0x1d51e, 0x1d539, 1), - Range(0x1d53b, 0x1d53e, 1), - Range(0x1d540, 0x1d544, 1), - Range(0x1d546, 0x1d546, 1), - Range(0x1d54a, 0x1d550, 1), - Range(0x1d552, 0x1d6a5, 1), - Range(0x1d6a8, 0x1d6c0, 1), - Range(0x1d6c2, 0x1d6da, 1), - Range(0x1d6dc, 0x1d6fa, 1), - Range(0x1d6fc, 0x1d714, 1), - Range(0x1d716, 0x1d734, 1), - Range(0x1d736, 0x1d74e, 1), - Range(0x1d750, 0x1d76e, 1), - Range(0x1d770, 0x1d788, 1), - Range(0x1d78a, 0x1d7a8, 1), - Range(0x1d7aa, 0x1d7c2, 1), - Range(0x1d7c4, 0x1d7cb, 1), - Range(0x20000, 0x2a6d6, 1), - Range(0x2f800, 0x2fa1d, 1), -) +var Letter = []Range { + Range{0x0041, 0x005a, 1}, + Range{0x0061, 0x007a, 1}, + Range{0x00aa, 0x00b5, 11}, + Range{0x00ba, 0x00ba, 1}, + Range{0x00c0, 0x00d6, 1}, + Range{0x00d8, 0x00f6, 1}, + Range{0x00f8, 0x02c1, 1}, + Range{0x02c6, 0x02d1, 1}, + Range{0x02e0, 0x02e4, 1}, + Range{0x02ec, 0x02ee, 2}, + Range{0x0370, 0x0374, 1}, + Range{0x0376, 0x0377, 1}, + Range{0x037a, 0x037d, 1}, + Range{0x0386, 0x0386, 1}, + Range{0x0388, 0x038a, 1}, + Range{0x038c, 0x038c, 1}, + Range{0x038e, 0x03a1, 1}, + Range{0x03a3, 0x03f5, 1}, + Range{0x03f7, 0x0481, 1}, + Range{0x048a, 0x0523, 1}, + Range{0x0531, 0x0556, 1}, + Range{0x0559, 0x0559, 1}, + Range{0x0561, 0x0587, 1}, + Range{0x05d0, 0x05ea, 1}, + Range{0x05f0, 0x05f2, 1}, + Range{0x0621, 0x064a, 1}, + Range{0x066e, 0x066f, 1}, + Range{0x0671, 0x06d3, 1}, + Range{0x06d5, 0x06d5, 1}, + Range{0x06e5, 0x06e6, 1}, + Range{0x06ee, 0x06ef, 1}, + Range{0x06fa, 0x06fc, 1}, + Range{0x06ff, 0x0710, 17}, + Range{0x0712, 0x072f, 1}, + Range{0x074d, 0x07a5, 1}, + Range{0x07b1, 0x07b1, 1}, + Range{0x07ca, 0x07ea, 1}, + Range{0x07f4, 0x07f5, 1}, + Range{0x07fa, 0x07fa, 1}, + Range{0x0904, 0x0939, 1}, + Range{0x093d, 0x0950, 19}, + Range{0x0958, 0x0961, 1}, + Range{0x0971, 0x0972, 1}, + Range{0x097b, 0x097f, 1}, + Range{0x0985, 0x098c, 1}, + Range{0x098f, 0x0990, 1}, + Range{0x0993, 0x09a8, 1}, + Range{0x09aa, 0x09b0, 1}, + Range{0x09b2, 0x09b2, 1}, + Range{0x09b6, 0x09b9, 1}, + Range{0x09bd, 0x09ce, 17}, + Range{0x09dc, 0x09dd, 1}, + Range{0x09df, 0x09e1, 1}, + Range{0x09f0, 0x09f1, 1}, + Range{0x0a05, 0x0a0a, 1}, + Range{0x0a0f, 0x0a10, 1}, + Range{0x0a13, 0x0a28, 1}, + Range{0x0a2a, 0x0a30, 1}, + Range{0x0a32, 0x0a33, 1}, + Range{0x0a35, 0x0a36, 1}, + Range{0x0a38, 0x0a39, 1}, + Range{0x0a59, 0x0a5c, 1}, + Range{0x0a5e, 0x0a5e, 1}, + Range{0x0a72, 0x0a74, 1}, + Range{0x0a85, 0x0a8d, 1}, + Range{0x0a8f, 0x0a91, 1}, + Range{0x0a93, 0x0aa8, 1}, + Range{0x0aaa, 0x0ab0, 1}, + Range{0x0ab2, 0x0ab3, 1}, + Range{0x0ab5, 0x0ab9, 1}, + Range{0x0abd, 0x0ad0, 19}, + Range{0x0ae0, 0x0ae1, 1}, + Range{0x0b05, 0x0b0c, 1}, + Range{0x0b0f, 0x0b10, 1}, + Range{0x0b13, 0x0b28, 1}, + Range{0x0b2a, 0x0b30, 1}, + Range{0x0b32, 0x0b33, 1}, + Range{0x0b35, 0x0b39, 1}, + Range{0x0b3d, 0x0b3d, 1}, + Range{0x0b5c, 0x0b5d, 1}, + Range{0x0b5f, 0x0b61, 1}, + Range{0x0b71, 0x0b83, 18}, + Range{0x0b85, 0x0b8a, 1}, + Range{0x0b8e, 0x0b90, 1}, + Range{0x0b92, 0x0b95, 1}, + Range{0x0b99, 0x0b9a, 1}, + Range{0x0b9c, 0x0b9c, 1}, + Range{0x0b9e, 0x0b9f, 1}, + Range{0x0ba3, 0x0ba4, 1}, + Range{0x0ba8, 0x0baa, 1}, + Range{0x0bae, 0x0bb9, 1}, + Range{0x0bd0, 0x0bd0, 1}, + Range{0x0c05, 0x0c0c, 1}, + Range{0x0c0e, 0x0c10, 1}, + Range{0x0c12, 0x0c28, 1}, + Range{0x0c2a, 0x0c33, 1}, + Range{0x0c35, 0x0c39, 1}, + Range{0x0c3d, 0x0c3d, 1}, + Range{0x0c58, 0x0c59, 1}, + Range{0x0c60, 0x0c61, 1}, + Range{0x0c85, 0x0c8c, 1}, + Range{0x0c8e, 0x0c90, 1}, + Range{0x0c92, 0x0ca8, 1}, + Range{0x0caa, 0x0cb3, 1}, + Range{0x0cb5, 0x0cb9, 1}, + Range{0x0cbd, 0x0cde, 33}, + Range{0x0ce0, 0x0ce1, 1}, + Range{0x0d05, 0x0d0c, 1}, + Range{0x0d0e, 0x0d10, 1}, + Range{0x0d12, 0x0d28, 1}, + Range{0x0d2a, 0x0d39, 1}, + Range{0x0d3d, 0x0d3d, 1}, + Range{0x0d60, 0x0d61, 1}, + Range{0x0d7a, 0x0d7f, 1}, + Range{0x0d85, 0x0d96, 1}, + Range{0x0d9a, 0x0db1, 1}, + Range{0x0db3, 0x0dbb, 1}, + Range{0x0dbd, 0x0dbd, 1}, + Range{0x0dc0, 0x0dc6, 1}, + Range{0x0e01, 0x0e30, 1}, + Range{0x0e32, 0x0e33, 1}, + Range{0x0e40, 0x0e46, 1}, + Range{0x0e81, 0x0e82, 1}, + Range{0x0e84, 0x0e84, 1}, + Range{0x0e87, 0x0e88, 1}, + Range{0x0e8a, 0x0e8d, 3}, + Range{0x0e94, 0x0e97, 1}, + Range{0x0e99, 0x0e9f, 1}, + Range{0x0ea1, 0x0ea3, 1}, + Range{0x0ea5, 0x0ea7, 2}, + Range{0x0eaa, 0x0eab, 1}, + Range{0x0ead, 0x0eb0, 1}, + Range{0x0eb2, 0x0eb3, 1}, + Range{0x0ebd, 0x0ebd, 1}, + Range{0x0ec0, 0x0ec4, 1}, + Range{0x0ec6, 0x0ec6, 1}, + Range{0x0edc, 0x0edd, 1}, + Range{0x0f00, 0x0f00, 1}, + Range{0x0f40, 0x0f47, 1}, + Range{0x0f49, 0x0f6c, 1}, + Range{0x0f88, 0x0f8b, 1}, + Range{0x1000, 0x102a, 1}, + Range{0x103f, 0x103f, 1}, + Range{0x1050, 0x1055, 1}, + Range{0x105a, 0x105d, 1}, + Range{0x1061, 0x1061, 1}, + Range{0x1065, 0x1066, 1}, + Range{0x106e, 0x1070, 1}, + Range{0x1075, 0x1081, 1}, + Range{0x108e, 0x108e, 1}, + Range{0x10a0, 0x10c5, 1}, + Range{0x10d0, 0x10fa, 1}, + Range{0x10fc, 0x10fc, 1}, + Range{0x1100, 0x1159, 1}, + Range{0x115f, 0x11a2, 1}, + Range{0x11a8, 0x11f9, 1}, + Range{0x1200, 0x1248, 1}, + Range{0x124a, 0x124d, 1}, + Range{0x1250, 0x1256, 1}, + Range{0x1258, 0x1258, 1}, + Range{0x125a, 0x125d, 1}, + Range{0x1260, 0x1288, 1}, + Range{0x128a, 0x128d, 1}, + Range{0x1290, 0x12b0, 1}, + Range{0x12b2, 0x12b5, 1}, + Range{0x12b8, 0x12be, 1}, + Range{0x12c0, 0x12c0, 1}, + Range{0x12c2, 0x12c5, 1}, + Range{0x12c8, 0x12d6, 1}, + Range{0x12d8, 0x1310, 1}, + Range{0x1312, 0x1315, 1}, + Range{0x1318, 0x135a, 1}, + Range{0x1380, 0x138f, 1}, + Range{0x13a0, 0x13f4, 1}, + Range{0x1401, 0x166c, 1}, + Range{0x166f, 0x1676, 1}, + Range{0x1681, 0x169a, 1}, + Range{0x16a0, 0x16ea, 1}, + Range{0x1700, 0x170c, 1}, + Range{0x170e, 0x1711, 1}, + Range{0x1720, 0x1731, 1}, + Range{0x1740, 0x1751, 1}, + Range{0x1760, 0x176c, 1}, + Range{0x176e, 0x1770, 1}, + Range{0x1780, 0x17b3, 1}, + Range{0x17d7, 0x17dc, 5}, + Range{0x1820, 0x1877, 1}, + Range{0x1880, 0x18a8, 1}, + Range{0x18aa, 0x18aa, 1}, + Range{0x1900, 0x191c, 1}, + Range{0x1950, 0x196d, 1}, + Range{0x1970, 0x1974, 1}, + Range{0x1980, 0x19a9, 1}, + Range{0x19c1, 0x19c7, 1}, + Range{0x1a00, 0x1a16, 1}, + Range{0x1b05, 0x1b33, 1}, + Range{0x1b45, 0x1b4b, 1}, + Range{0x1b83, 0x1ba0, 1}, + Range{0x1bae, 0x1baf, 1}, + Range{0x1c00, 0x1c23, 1}, + Range{0x1c4d, 0x1c4f, 1}, + Range{0x1c5a, 0x1c7d, 1}, + Range{0x1d00, 0x1dbf, 1}, + Range{0x1e00, 0x1f15, 1}, + Range{0x1f18, 0x1f1d, 1}, + Range{0x1f20, 0x1f45, 1}, + Range{0x1f48, 0x1f4d, 1}, + Range{0x1f50, 0x1f57, 1}, + Range{0x1f59, 0x1f5d, 2}, + Range{0x1f5f, 0x1f7d, 1}, + Range{0x1f80, 0x1fb4, 1}, + Range{0x1fb6, 0x1fbc, 1}, + Range{0x1fbe, 0x1fbe, 1}, + Range{0x1fc2, 0x1fc4, 1}, + Range{0x1fc6, 0x1fcc, 1}, + Range{0x1fd0, 0x1fd3, 1}, + Range{0x1fd6, 0x1fdb, 1}, + Range{0x1fe0, 0x1fec, 1}, + Range{0x1ff2, 0x1ff4, 1}, + Range{0x1ff6, 0x1ffc, 1}, + Range{0x2071, 0x207f, 14}, + Range{0x2090, 0x2094, 1}, + Range{0x2102, 0x2107, 5}, + Range{0x210a, 0x2113, 1}, + Range{0x2115, 0x2115, 1}, + Range{0x2119, 0x211d, 1}, + Range{0x2124, 0x2128, 2}, + Range{0x212a, 0x212d, 1}, + Range{0x212f, 0x2139, 1}, + Range{0x213c, 0x213f, 1}, + Range{0x2145, 0x2149, 1}, + Range{0x214e, 0x214e, 1}, + Range{0x2183, 0x2184, 1}, + Range{0x2c00, 0x2c2e, 1}, + Range{0x2c30, 0x2c5e, 1}, + Range{0x2c60, 0x2c6f, 1}, + Range{0x2c71, 0x2c7d, 1}, + Range{0x2c80, 0x2ce4, 1}, + Range{0x2d00, 0x2d25, 1}, + Range{0x2d30, 0x2d65, 1}, + Range{0x2d6f, 0x2d6f, 1}, + Range{0x2d80, 0x2d96, 1}, + Range{0x2da0, 0x2da6, 1}, + Range{0x2da8, 0x2dae, 1}, + Range{0x2db0, 0x2db6, 1}, + Range{0x2db8, 0x2dbe, 1}, + Range{0x2dc0, 0x2dc6, 1}, + Range{0x2dc8, 0x2dce, 1}, + Range{0x2dd0, 0x2dd6, 1}, + Range{0x2dd8, 0x2dde, 1}, + Range{0x2e2f, 0x2e2f, 1}, + Range{0x3005, 0x3006, 1}, + Range{0x3031, 0x3035, 1}, + Range{0x303b, 0x303c, 1}, + Range{0x3041, 0x3096, 1}, + Range{0x309d, 0x309f, 1}, + Range{0x30a1, 0x30fa, 1}, + Range{0x30fc, 0x30ff, 1}, + Range{0x3105, 0x312d, 1}, + Range{0x3131, 0x318e, 1}, + Range{0x31a0, 0x31b7, 1}, + Range{0x31f0, 0x31ff, 1}, + Range{0x3400, 0x4db5, 1}, + Range{0x4e00, 0x9fc3, 1}, + Range{0xa000, 0xa48c, 1}, + Range{0xa500, 0xa60c, 1}, + Range{0xa610, 0xa61f, 1}, + Range{0xa62a, 0xa62b, 1}, + Range{0xa640, 0xa65f, 1}, + Range{0xa662, 0xa66e, 1}, + Range{0xa67f, 0xa697, 1}, + Range{0xa717, 0xa71f, 1}, + Range{0xa722, 0xa788, 1}, + Range{0xa78b, 0xa78c, 1}, + Range{0xa7fb, 0xa801, 1}, + Range{0xa803, 0xa805, 1}, + Range{0xa807, 0xa80a, 1}, + Range{0xa80c, 0xa822, 1}, + Range{0xa840, 0xa873, 1}, + Range{0xa882, 0xa8b3, 1}, + Range{0xa90a, 0xa925, 1}, + Range{0xa930, 0xa946, 1}, + Range{0xaa00, 0xaa28, 1}, + Range{0xaa40, 0xaa42, 1}, + Range{0xaa44, 0xaa4b, 1}, + Range{0xac00, 0xd7a3, 1}, + Range{0xf900, 0xfa2d, 1}, + Range{0xfa30, 0xfa6a, 1}, + Range{0xfa70, 0xfad9, 1}, + Range{0xfb00, 0xfb06, 1}, + Range{0xfb13, 0xfb17, 1}, + Range{0xfb1d, 0xfb1d, 1}, + Range{0xfb1f, 0xfb28, 1}, + Range{0xfb2a, 0xfb36, 1}, + Range{0xfb38, 0xfb3c, 1}, + Range{0xfb3e, 0xfb3e, 1}, + Range{0xfb40, 0xfb41, 1}, + Range{0xfb43, 0xfb44, 1}, + Range{0xfb46, 0xfbb1, 1}, + Range{0xfbd3, 0xfd3d, 1}, + Range{0xfd50, 0xfd8f, 1}, + Range{0xfd92, 0xfdc7, 1}, + Range{0xfdf0, 0xfdfb, 1}, + Range{0xfe70, 0xfe74, 1}, + Range{0xfe76, 0xfefc, 1}, + Range{0xff21, 0xff3a, 1}, + Range{0xff41, 0xff5a, 1}, + Range{0xff66, 0xffbe, 1}, + Range{0xffc2, 0xffc7, 1}, + Range{0xffca, 0xffcf, 1}, + Range{0xffd2, 0xffd7, 1}, + Range{0xffda, 0xffdc, 1}, + Range{0x10000, 0x1000b, 1}, + Range{0x1000d, 0x10026, 1}, + Range{0x10028, 0x1003a, 1}, + Range{0x1003c, 0x1003d, 1}, + Range{0x1003f, 0x1004d, 1}, + Range{0x10050, 0x1005d, 1}, + Range{0x10080, 0x100fa, 1}, + Range{0x10280, 0x1029c, 1}, + Range{0x102a0, 0x102d0, 1}, + Range{0x10300, 0x1031e, 1}, + Range{0x10330, 0x10340, 1}, + Range{0x10342, 0x10349, 1}, + Range{0x10380, 0x1039d, 1}, + Range{0x103a0, 0x103c3, 1}, + Range{0x103c8, 0x103cf, 1}, + Range{0x10400, 0x1049d, 1}, + Range{0x10800, 0x10805, 1}, + Range{0x10808, 0x10808, 1}, + Range{0x1080a, 0x10835, 1}, + Range{0x10837, 0x10838, 1}, + Range{0x1083c, 0x1083f, 3}, + Range{0x10900, 0x10915, 1}, + Range{0x10920, 0x10939, 1}, + Range{0x10a00, 0x10a00, 1}, + Range{0x10a10, 0x10a13, 1}, + Range{0x10a15, 0x10a17, 1}, + Range{0x10a19, 0x10a33, 1}, + Range{0x12000, 0x1236e, 1}, + Range{0x1d400, 0x1d454, 1}, + Range{0x1d456, 0x1d49c, 1}, + Range{0x1d49e, 0x1d49f, 1}, + Range{0x1d4a2, 0x1d4a2, 1}, + Range{0x1d4a5, 0x1d4a6, 1}, + Range{0x1d4a9, 0x1d4ac, 1}, + Range{0x1d4ae, 0x1d4b9, 1}, + Range{0x1d4bb, 0x1d4bb, 1}, + Range{0x1d4bd, 0x1d4c3, 1}, + Range{0x1d4c5, 0x1d505, 1}, + Range{0x1d507, 0x1d50a, 1}, + Range{0x1d50d, 0x1d514, 1}, + Range{0x1d516, 0x1d51c, 1}, + Range{0x1d51e, 0x1d539, 1}, + Range{0x1d53b, 0x1d53e, 1}, + Range{0x1d540, 0x1d544, 1}, + Range{0x1d546, 0x1d546, 1}, + Range{0x1d54a, 0x1d550, 1}, + Range{0x1d552, 0x1d6a5, 1}, + Range{0x1d6a8, 0x1d6c0, 1}, + Range{0x1d6c2, 0x1d6da, 1}, + Range{0x1d6dc, 0x1d6fa, 1}, + Range{0x1d6fc, 0x1d714, 1}, + Range{0x1d716, 0x1d734, 1}, + Range{0x1d736, 0x1d74e, 1}, + Range{0x1d750, 0x1d76e, 1}, + Range{0x1d770, 0x1d788, 1}, + Range{0x1d78a, 0x1d7a8, 1}, + Range{0x1d7aa, 0x1d7c2, 1}, + Range{0x1d7c4, 0x1d7cb, 1}, + Range{0x20000, 0x2a6d6, 1}, + Range{0x2f800, 0x2fa1d, 1}, +} func Is(ranges []Range, rune int) bool { // common case: rune is ASCII or Latin-1 diff --git a/src/lib/unicode/letter_test.go b/src/lib/unicode/letter_test.go index 7ff5546e1b..d39d74e6b9 100644 --- a/src/lib/unicode/letter_test.go +++ b/src/lib/unicode/letter_test.go @@ -9,7 +9,7 @@ import ( "unicode"; ) -var upper = []int( +var upper = []int{ 0x41, 0xc0, 0xd8, @@ -31,9 +31,9 @@ var upper = []int( 0x10400, 0x1d400, 0x1d7ca, -) +} -var notupper = []int( +var notupper = []int{ 0x40, 0x5b, 0x61, @@ -44,9 +44,9 @@ var notupper = []int( 0x2150, 0xffff, 0x10000, -) +} -var letter = []int( +var letter = []int{ 0x41, 0x61, 0xaa, @@ -79,9 +79,9 @@ var letter = []int( 0x20000, 0x2f800, 0x2fa1d, -) +} -var notletter = []int( +var notletter = []int{ 0x20, 0x35, 0x375, @@ -90,7 +90,7 @@ var notletter = []int( 0xfffe, 0x1ffff, 0x10ffff, -) +} func TestIsLetter(t *testing.T) { for i, r := range(upper) { diff --git a/src/lib/utf8_test.go b/src/lib/utf8_test.go index 5499263ae6..7999afd2ee 100644 --- a/src/lib/utf8_test.go +++ b/src/lib/utf8_test.go @@ -17,33 +17,33 @@ type Utf8Map struct { str string; } -var utf8map = []Utf8Map ( - Utf8Map( 0x0000, "\x00" ), - Utf8Map( 0x0001, "\x01" ), - Utf8Map( 0x007e, "\x7e" ), - Utf8Map( 0x007f, "\x7f" ), - Utf8Map( 0x0080, "\xc2\x80" ), - Utf8Map( 0x0081, "\xc2\x81" ), - Utf8Map( 0x00bf, "\xc2\xbf" ), - Utf8Map( 0x00c0, "\xc3\x80" ), - Utf8Map( 0x00c1, "\xc3\x81" ), - Utf8Map( 0x00c8, "\xc3\x88" ), - Utf8Map( 0x00d0, "\xc3\x90" ), - Utf8Map( 0x00e0, "\xc3\xa0" ), - Utf8Map( 0x00f0, "\xc3\xb0" ), - Utf8Map( 0x00f8, "\xc3\xb8" ), - Utf8Map( 0x00ff, "\xc3\xbf" ), - Utf8Map( 0x0100, "\xc4\x80" ), - Utf8Map( 0x07ff, "\xdf\xbf" ), - Utf8Map( 0x0800, "\xe0\xa0\x80" ), - Utf8Map( 0x0801, "\xe0\xa0\x81" ), - Utf8Map( 0xfffe, "\xef\xbf\xbe" ), - Utf8Map( 0xffff, "\xef\xbf\xbf" ), - Utf8Map( 0x10000, "\xf0\x90\x80\x80" ), - Utf8Map( 0x10001, "\xf0\x90\x80\x81" ), - Utf8Map( 0x10fffe, "\xf4\x8f\xbf\xbe" ), - Utf8Map( 0x10ffff, "\xf4\x8f\xbf\xbf" ), -) +var utf8map = []Utf8Map { + Utf8Map{ 0x0000, "\x00" }, + Utf8Map{ 0x0001, "\x01" }, + Utf8Map{ 0x007e, "\x7e" }, + Utf8Map{ 0x007f, "\x7f" }, + Utf8Map{ 0x0080, "\xc2\x80" }, + Utf8Map{ 0x0081, "\xc2\x81" }, + Utf8Map{ 0x00bf, "\xc2\xbf" }, + Utf8Map{ 0x00c0, "\xc3\x80" }, + Utf8Map{ 0x00c1, "\xc3\x81" }, + Utf8Map{ 0x00c8, "\xc3\x88" }, + Utf8Map{ 0x00d0, "\xc3\x90" }, + Utf8Map{ 0x00e0, "\xc3\xa0" }, + Utf8Map{ 0x00f0, "\xc3\xb0" }, + Utf8Map{ 0x00f8, "\xc3\xb8" }, + Utf8Map{ 0x00ff, "\xc3\xbf" }, + Utf8Map{ 0x0100, "\xc4\x80" }, + Utf8Map{ 0x07ff, "\xdf\xbf" }, + Utf8Map{ 0x0800, "\xe0\xa0\x80" }, + Utf8Map{ 0x0801, "\xe0\xa0\x81" }, + Utf8Map{ 0xfffe, "\xef\xbf\xbe" }, + Utf8Map{ 0xffff, "\xef\xbf\xbf" }, + Utf8Map{ 0x10000, "\xf0\x90\x80\x80" }, + Utf8Map{ 0x10001, "\xf0\x90\x80\x81" }, + Utf8Map{ 0x10fffe, "\xf4\x8f\xbf\xbe" }, + Utf8Map{ 0x10ffff, "\xf4\x8f\xbf\xbf" }, +} // io.StringBytes with one extra byte at end func bytes(s string) []byte { @@ -161,12 +161,12 @@ type RuneCountTest struct { in string; out int; } -var runecounttests = []RuneCountTest ( - RuneCountTest( "abcd", 4 ), - RuneCountTest( "☺☻☹", 3 ), - RuneCountTest( "1,2,3,4", 7 ), - RuneCountTest( "\xe2\x00", 2 ), -) +var runecounttests = []RuneCountTest { + RuneCountTest{ "abcd", 4 }, + RuneCountTest{ "☺☻☹", 3 }, + RuneCountTest{ "1,2,3,4", 7 }, + RuneCountTest{ "\xe2\x00", 2 }, +} func TestRuneCount(t *testing.T) { for i := 0; i < len(runecounttests); i++ { tt := runecounttests[i]; diff --git a/src/run.bash b/src/run.bash index 2c5636cfa4..a7e57f1fdb 100755 --- a/src/run.bash +++ b/src/run.bash @@ -48,11 +48,11 @@ time make GOMAXPROCS=10 make test ) || exit $? -(xcd ../usr/gri/pretty -make clean -time make -make smoketest -) || exit $? +# (xcd ../usr/gri/pretty +# make clean +# time make +# make smoketest +# ) || exit $? (xcd ../doc/progs time ./run diff --git a/test/235.go b/test/235.go index 26ed16ff27..e24106dd00 100644 --- a/test/235.go +++ b/test/235.go @@ -32,16 +32,16 @@ func min(xs []uint64) uint64 { func main() { - F := []uint64(2, 3, 5); + F := []uint64{2, 3, 5}; var n = len(F); - OUT := []uint64( + OUT := []uint64{ 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36, 40, 45, 48, 50, 54, 60, 64, 72, 75, 80, 81, 90, 96, 100, 108, 120, 125, 128, 135, 144, 150, 160, 162, 180, 192, 200, 216, 225, 240, 243, 250, 256, 270, 288, 300, 320, 324, 360, 375, 384, 400, 405, 432, 450, 480, 486, 500, 512, 540, 576, 600, 625, 640, 648, 675, 720, 729, 750, 768, 800, 810, 864, 900, 960, 972, 1000, 1024, 1080, 1125, 1152, 1200, 1215, - 1250, 1280, 1296, 1350, 1440, 1458, 1500, 1536, 1600 ); + 1250, 1280, 1296, 1350, 1440, 1458, 1500, 1536, 1600 }; x := uint64(1); ins := make([]T, n); diff --git a/test/bigalg.go b/test/bigalg.go index 5ac60cc0c5..afeccdf8f0 100644 --- a/test/bigalg.go +++ b/test/bigalg.go @@ -18,7 +18,7 @@ type T struct { d byte; } -var a = []int( 1, 2, 3 ) +var a = []int{ 1, 2, 3 } var NIL []int; func arraycmptest() { @@ -44,7 +44,7 @@ func SameArray(a, b []int) bool { return true; } -var t = T(1.5, 123, "hello", 255) +var t = T{1.5, 123, "hello", 255} var mt = make(map[int]T) var ma = make(map[int][]int) diff --git a/test/bugs/bug117.go b/test/bugs/bug117.go index acb45e4a92..a18e68849a 100644 --- a/test/bugs/bug117.go +++ b/test/bugs/bug117.go @@ -14,7 +14,7 @@ func fn(p PS) int { return p.get() } func main() { - s := S(1); + s := S{1}; if s.get() != 1 { panic() } diff --git a/test/chan/powser1.go b/test/chan/powser1.go index 501a252310..c167da1927 100644 --- a/test/chan/powser1.go +++ b/test/chan/powser1.go @@ -158,7 +158,7 @@ func getn(in []*dch) []rat { // Get one rat from each of 2 demand channels func get2(in0 *dch, in1 *dch) []rat { - return getn([]*dch(in0, in1)); + return getn([]*dch{in0, in1}); } func copy(in *dch, out *dch) { diff --git a/test/chan/powser2.go b/test/chan/powser2.go index bf798b3fa7..b48110819b 100644 --- a/test/chan/powser2.go +++ b/test/chan/powser2.go @@ -167,7 +167,7 @@ func getn(in []*dch) []item { // Get one item from each of 2 demand channels func get2(in0 *dch, in1 *dch) []item { - return getn([]*dch(in0, in1)); + return getn([]*dch{in0, in1}); } func copy(in *dch, out *dch){ diff --git a/test/chan/sieve.go b/test/chan/sieve.go index 2cde55e64b..0cebdc6412 100644 --- a/test/chan/sieve.go +++ b/test/chan/sieve.go @@ -43,7 +43,7 @@ func Sieve(primes chan<- int) { func main() { primes := make(chan int); go Sieve(primes); - a := []int(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97); + a := []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97}; for i := 0; i < len(a); i++ { if <-primes != a[i] { panic(a[i])} } diff --git a/test/closure.go b/test/closure.go index 1bd0ef202e..97361a1dfd 100644 --- a/test/closure.go +++ b/test/closure.go @@ -76,13 +76,13 @@ func h() { func main() { go f(); - check([]int(1,4,5,4)); + check([]int{1,4,5,4}); a := accum(0); b := accum(1); go g(a, b); - check([]int(2,4,6,9)); + check([]int{2,4,6,9}); go h(); - check([]int(100,200,101,201,500,101,201,500)); + check([]int{100,200,101,201,500,101,201,500}); } diff --git a/test/cmp1.go b/test/cmp1.go index d1a1c7a0b3..67bde32779 100644 --- a/test/cmp1.go +++ b/test/cmp1.go @@ -11,7 +11,7 @@ import "unsafe" func use(bool) { } func stringptr(s string) uintptr { - return *(&s).(unsafe.Pointer).(*uintptr); + return *(*uintptr)(unsafe.Pointer(&s)); } func isfalse(b bool) { diff --git a/test/complit.go b/test/complit.go index f2dc91d108..d9b9488519 100644 --- a/test/complit.go +++ b/test/complit.go @@ -24,45 +24,45 @@ func eq(a []*R) { type P struct { a, b int }; func NewP(a, b int) *P { - return &P(a, b) + return &P{a, b} } func main() { var t T; - t = T(0, 7.2, "hi", &t); + t = T{0, 7.2, "hi", &t}; var tp *T; - tp = &T(0, 7.2, "hi", &t); + tp = &T{0, 7.2, "hi", &t}; - a1 := []int(1,2,3); + a1 := []int{1,2,3}; if len(a1) != 3 { panic("a1") } - a2 := [10]int(1,2,3); + a2 := [10]int{1,2,3}; if len(a2) != 10 || cap(a2) != 10 { panic("a2") } - a3 := [10]int(1,2,3,); + a3 := [10]int{1,2,3,}; if len(a3) != 10 || a2[3] != 0 { panic("a3") } var oai []int; - oai = []int(1,2,3); + oai = []int{1,2,3}; if len(oai) != 3 { panic("oai") } - at := [...]*T(&t, &t, &t); + at := [...]*T{&t, &t, &t}; if len(at) != 3 { panic("at") } c := make(chan int); - ac := []chan int(c, c, c); + ac := []chan int{c, c, c}; if len(ac) != 3 { panic("ac") } - aat := [][len(at)]*T(at, at); + aat := [][len(at)]*T{at, at}; if len(aat) != 2 || len(aat[1]) != 3 { panic("aat") } - s := string([]byte('h', 'e', 'l', 'l', 'o')); + s := string([]byte{'h', 'e', 'l', 'l', 'o'}); if s != "hello" { panic("s") } - m := map[string]float("one":1.0, "two":2.0, "pi":22./7.); + m := map[string]float{"one":1.0, "two":2.0, "pi":22./7.}; if len(m) != 3 { panic("m") } - eq([]*R(itor(0), itor(1), itor(2), itor(3), itor(4), itor(5))); + eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)}); p1 := NewP(1, 2); p2 := NewP(1, 2); diff --git a/test/convlit1.go b/test/convlit1.go index 19f98efbd7..94d28969b7 100644 --- a/test/convlit1.go +++ b/test/convlit1.go @@ -6,7 +6,8 @@ package main -var a = []int ( "a" ); // ERROR "conver|incompatible" +var a = []int { "a" }; // ERROR "conver|incompatible" +var b = int { 1 }; // ERROR "compos" func f() int diff --git a/test/fixedbugs/bug047.go b/test/fixedbugs/bug047.go index 61b4255b0c..805647b3d9 100644 --- a/test/fixedbugs/bug047.go +++ b/test/fixedbugs/bug047.go @@ -14,8 +14,8 @@ func main() { }; var s string = "hello"; var f float = 0.2; - t := T(s, f); + t := T{s, f}; type M map[int] int; - m0 := M(7:8); + m0 := M{7:8}; } diff --git a/test/fixedbugs/bug048.go b/test/fixedbugs/bug048.go index 30a015cc26..fbfc120131 100644 --- a/test/fixedbugs/bug048.go +++ b/test/fixedbugs/bug048.go @@ -8,5 +8,5 @@ package main func main() { type M map[int] int; - m1 := M(7 : 8); + m1 := M{7 : 8}; } diff --git a/test/fixedbugs/bug096.go b/test/fixedbugs/bug096.go index 34673f7230..81d6c4aada 100644 --- a/test/fixedbugs/bug096.go +++ b/test/fixedbugs/bug096.go @@ -9,8 +9,8 @@ package main type A []int; func main() { - a := &A(0); - b := &A(0, 1); + a := &A{0}; + b := &A{0, 1}; } /* diff --git a/test/fixedbugs/bug097.go b/test/fixedbugs/bug097.go index 9286b06738..70bd6e2b47 100644 --- a/test/fixedbugs/bug097.go +++ b/test/fixedbugs/bug097.go @@ -11,7 +11,7 @@ type A []int; func main() { var a [3]A; for i := 0; i < 3; i++ { - a[i] = A(i); + a[i] = A{i}; } if a[0][0] != 0 { panic(); } if a[1][0] != 1 { panic(); } diff --git a/test/fixedbugs/bug098.go b/test/fixedbugs/bug098.go index 09daf3f890..8e790a709a 100644 --- a/test/fixedbugs/bug098.go +++ b/test/fixedbugs/bug098.go @@ -10,8 +10,8 @@ type A []int; type M map[int] int; func main() { - var a *A = &A(0); - var m *M = &M(0 : 0); // should be legal to use & here for consistency with other composite constructors (prev. line) + var a *A = &A{0}; + var m *M = &M{0 : 0}; // should be legal to use & here for consistency with other composite constructors (prev. line) } /* diff --git a/test/fixedbugs/bug101.go b/test/fixedbugs/bug101.go index a87eea1990..92487deaac 100644 --- a/test/fixedbugs/bug101.go +++ b/test/fixedbugs/bug101.go @@ -6,7 +6,7 @@ package main -var a = []int ( 1, 2, 3 ) +var a = []int { 1, 2, 3 } func main() { if len(a) != 3 { panic("array len") } diff --git a/test/fixedbugs/bug102.go b/test/fixedbugs/bug102.go index 87ec65ee3c..58480974ba 100644 --- a/test/fixedbugs/bug102.go +++ b/test/fixedbugs/bug102.go @@ -12,7 +12,7 @@ func main() { if s != "" { panic("bad convert") } - var b1 = [5]byte('h', 'e', 'l', 'l', 'o'); + var b1 = [5]byte{'h', 'e', 'l', 'l', 'o'}; if string(b1) != "hello" { panic("bad convert 1") } diff --git a/test/fixedbugs/bug112.go b/test/fixedbugs/bug112.go index 61f4d00cc2..3c932843c7 100644 --- a/test/fixedbugs/bug112.go +++ b/test/fixedbugs/bug112.go @@ -7,7 +7,7 @@ package main type T struct { s string } -var t = T("hi") +var t = T{"hi"} func main() {} diff --git a/test/fixedbugs/bug119.go b/test/fixedbugs/bug119.go index c74d8bb77e..8e51ef2cec 100644 --- a/test/fixedbugs/bug119.go +++ b/test/fixedbugs/bug119.go @@ -11,7 +11,7 @@ func foo(a []int) int { } func main() { - a := &[]int(12); + a := &[]int{12}; if x := a[0] ; x != 12 { panicln(1) } if x := (*a)[0]; x != 12 { panicln(2) } if x := foo(*a) ; x != 12 { panicln(3) } // fails (x is incorrect) @@ -28,5 +28,5 @@ panic on line 83 PC=0x14d6 0x52bb?zi mainstart(1, 0, 1606416432, ...) mainstart(0x1, 0x7fff5fbff830, 0x0, ...) -uetli:~/Source/go1/test/bugs gri$ +uetli:~/Source/go1/test/bugs gri$ */ diff --git a/test/fixedbugs/bug120.go b/test/fixedbugs/bug120.go index e633024f07..10e28034dc 100644 --- a/test/fixedbugs/bug120.go +++ b/test/fixedbugs/bug120.go @@ -14,12 +14,12 @@ type Test struct { out string; } -var tests = []Test ( - Test( 123.5, "123.5", "123.5" ), - Test( 456.7, "456.7", "456.7" ), - Test( 1e23+8.5e6, "1e23+8.5e6", "1.0000000000000001e+23" ), - Test( 100000000000000008388608, "100000000000000008388608", "1.0000000000000001e+23" ), - Test( 1e23+8388609, "1e23+8388609", "1.0000000000000001e+23" ), +var tests = []Test { + Test{ 123.5, "123.5", "123.5" }, + Test{ 456.7, "456.7", "456.7" }, + Test{ 1e23+8.5e6, "1e23+8.5e6", "1.0000000000000001e+23" }, + Test{ 100000000000000008388608, "100000000000000008388608", "1.0000000000000001e+23" }, + Test{ 1e23+8388609, "1e23+8388609", "1.0000000000000001e+23" }, // "x" = the floating point value from converting the string x. // These are exactly representable in 64-bit floating point: @@ -32,9 +32,9 @@ var tests = []Test ( // The correct answer, of course, would be "1e23+8388608" = 1e23+8388608. // This is not going to be correct until 6g has multiprecision floating point. // A simpler case is "1e23+1", which should also round to 1e23+8388608. - Test( 1e23+8.388608e6, "1e23+8.388608e6", "1.0000000000000001e+23" ), - Test( 1e23+1, "1e23+1", "1.0000000000000001e+23" ), -) + Test{ 1e23+8.388608e6, "1e23+8.388608e6", "1.0000000000000001e+23" }, + Test{ 1e23+1, "1e23+1", "1.0000000000000001e+23" }, +} func main() { ok := true; diff --git a/test/fixedbugs/bug130.go b/test/fixedbugs/bug130.go index fc18b7e966..aa3f0dd70e 100644 --- a/test/fixedbugs/bug130.go +++ b/test/fixedbugs/bug130.go @@ -12,7 +12,7 @@ type S struct { v int } func (p *S) send(c chan <- int) { c <- p.v } func main() { - s := S(0); + s := S{0}; var i I = &s; c := make(chan int); go i.send(c); diff --git a/test/indirect.go b/test/indirect.go index 4bf50ded3a..4200d382ae 100644 --- a/test/indirect.go +++ b/test/indirect.go @@ -9,7 +9,7 @@ package main var m0 map[string]int var m1 *map[string]int var m2 *map[string]int = &m0 -var m3 map[string]int = map[string]int("a": 1) +var m3 map[string]int = map[string]int{"a": 1} var m4 *map[string]int = &m3 var s0 string @@ -25,7 +25,7 @@ var a2 *[10]int = &a0 var b0 []int var b1 *[]int var b2 *[]int = &b0 -var b3 []int = []int(1, 2, 3) +var b3 []int = []int{1, 2, 3} var b4 *[]int = &b3 func crash() diff --git a/test/initcomma.go b/test/initcomma.go index f28c4a60fc..44053f1459 100644 --- a/test/initcomma.go +++ b/test/initcomma.go @@ -6,10 +6,10 @@ package main -var a = []int ( 1,2, ) -var b = [5]int ( 1,2,3 ) -var c = []int ( 1 ) -var d = [...]int ( 1,2,3 ) +var a = []int { 1,2, } +var b = [5]int { 1,2,3 } +var c = []int { 1 } +var d = [...]int { 1,2,3 } func main() { if len(a) != 2 { panicln("len a", len(a)) } diff --git a/test/interface4.go b/test/interface4.go index 3e8a41b099..a55936df84 100644 --- a/test/interface4.go +++ b/test/interface4.go @@ -31,8 +31,8 @@ func test(name string, i I) { } func ptrs() { - var bigptr BigPtr = BigPtr( 10000, 2000, 300, 45 ); - var smallptr SmallPtr = SmallPtr( 12345 ); + var bigptr BigPtr = BigPtr{ 10000, 2000, 300, 45 }; + var smallptr SmallPtr = SmallPtr{ 12345 }; var intptr IntPtr = 12345; test("bigptr", bigptr); @@ -53,8 +53,8 @@ type Int int32 func (z Int) M() int64 { return int64(z) } func nonptrs() { - var big Big = Big( 10000, 2000, 300, 45 ); - var small Small = Small( 12345 ); + var big Big = Big{ 10000, 2000, 300, 45 }; + var small Small = Small{ 12345 }; var int Int = 12345; test("big", big); diff --git a/test/interface6.go b/test/interface6.go index 0af6247d1b..6053e51d64 100644 --- a/test/interface6.go +++ b/test/interface6.go @@ -22,7 +22,7 @@ func (p S1) Get() int { return p.i } func (p S1) Put(i int) { p.i = i } func f1() { - s := S1(1); + s := S1{1}; var i I1 = s; i.Put(2); check(i.Get() == 1, "f1 i"); @@ -30,7 +30,7 @@ func f1() { } func f2() { - s := S1(1); + s := S1{1}; var i I1 = &s; i.Put(2); check(i.Get() == 1, "f2 i"); @@ -38,7 +38,7 @@ func f2() { } func f3() { - s := &S1(1); + s := &S1{1}; var i I1 = s; i.Put(2); check(i.Get() == 1, "f3 i"); @@ -50,7 +50,7 @@ func (p *S2) Get() int { return p.i } func (p *S2) Put(i int) { p.i = i } func f4() { - s := S2(1); + s := S2{1}; var i I1 = s; i.Put(2); check(i.Get() == 2, "f4 i"); @@ -58,7 +58,7 @@ func f4() { } func f5() { - s := S2(1); + s := S2{1}; var i I1 = &s; i.Put(2); check(i.Get() == 2, "f5 i"); @@ -66,7 +66,7 @@ func f5() { } func f6() { - s := &S2(1); + s := &S2{1}; var i I1 = s; i.Put(2); check(i.Get() == 2, "f6 i"); @@ -80,7 +80,7 @@ func (p S3) Get() int64 { return p.l } func (p S3) Put(i int64) { p.l = i } func f7() { - s := S3(1, 2, 3, 4); + s := S3{1, 2, 3, 4}; var i I2 = s; i.Put(5); check(i.Get() == 4, "f7 i"); @@ -88,7 +88,7 @@ func f7() { } func f8() { - s := S3(1, 2, 3, 4); + s := S3{1, 2, 3, 4}; var i I2 = &s; i.Put(5); check(i.Get() == 4, "f8 i"); @@ -96,7 +96,7 @@ func f8() { } func f9() { - s := &S3(1, 2, 3, 4); + s := &S3{1, 2, 3, 4}; var i I2 = s; i.Put(5); check(i.Get() == 4, "f9 i"); @@ -108,7 +108,7 @@ func (p *S4) Get() int64 { return p.l } func (p *S4) Put(i int64) { p.l = i } func f10() { - s := S4(1, 2, 3, 4); + s := S4{1, 2, 3, 4}; var i I2 = s; i.Put(5); check(i.Get() == 5, "f10 i"); @@ -116,7 +116,7 @@ func f10() { } func f11() { - s := S4(1, 2, 3, 4); + s := S4{1, 2, 3, 4}; var i I2 = &s; i.Put(5); check(i.Get() == 5, "f11 i"); @@ -124,7 +124,7 @@ func f11() { } func f12() { - s := &S4(1, 2, 3, 4); + s := &S4{1, 2, 3, 4}; var i I2 = s; i.Put(5); check(i.Get() == 5, "f12 i"); diff --git a/test/mallocrand.go b/test/mallocrand.go index 5fdeced4d9..b933f6be45 100644 --- a/test/mallocrand.go +++ b/test/mallocrand.go @@ -48,7 +48,7 @@ func prime() { func memset(b *byte, c byte, n uint64) { np := uintptr(n); for i := uintptr(0); i < np; i++ { - *(b.(unsafe.Pointer).(uintptr)+i).(unsafe.Pointer).(*byte) = c; + *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b))+i)) = c; } } diff --git a/test/map.go b/test/map.go index f0b7b9b00b..085502bf52 100644 --- a/test/map.go +++ b/test/map.go @@ -27,9 +27,9 @@ func P(a []string) string { func main() { // Test a map literal. - mlit := map[string] int ( "0":0, "1":1, "2":2, "3":3, "4":4 ); + mlit := map[string] int { "0":0, "1":1, "2":2, "3":3, "4":4 }; for i := 0; i < len(mlit); i++ { - s := string([]byte(byte(i)+'0')); + s := string([]byte{byte(i)+'0'}); if mlit[s] != i { fmt.Printf("mlit[%s] = %d\n", s, mlit[s]) } @@ -64,14 +64,14 @@ func main() { s := strconv.Itoa(i); s10 := strconv.Itoa(i*10); f := float(i); - t := T(int64(i),f); + t := T{int64(i),f}; apT[i] = new(T); apT[i].i = int64(i); apT[i].f = f; apT[2*i] = new(T); // need twice as many entries as we use, for the nonexistence check apT[2*i].i = int64(i); apT[2*i].f = f; - m := M(i: i+1); + m := M{i: i+1}; mib[i] = (i != 0); mii[i] = 10*i; mfi[float(i)] = 10*i; @@ -140,7 +140,7 @@ func main() { s := strconv.Itoa(i); s10 := strconv.Itoa(i*10); f := float(i); - t := T(int64(i), f); + t := T{int64(i), f}; // BUG m := M(i, i+1); if mib[i] != (i != 0) { fmt.Printf("mib[%d] = %t\n", i, mib[i]); @@ -193,7 +193,7 @@ func main() { for i := 0; i < count; i++ { s := strconv.Itoa(i); f := float(i); - t := T(int64(i), f); + t := T{int64(i), f}; { a, b := mib[i]; if !b { @@ -331,7 +331,7 @@ func main() { for i := count; i < 2*count; i++ { s := strconv.Itoa(i); f := float(i); - t := T(int64(i),f); + t := T{int64(i),f}; { a, b := mib[i]; if b { diff --git a/test/method3.go b/test/method3.go index 5191c7f1cb..491bcdad33 100644 --- a/test/method3.go +++ b/test/method3.go @@ -16,7 +16,7 @@ type I interface { } func main() { - var t T = T(0,1,2,3,4); + var t T = T{0,1,2,3,4}; var i I; i = t; if i.Len() != 5 { diff --git a/test/parentype.go b/test/parentype.go index f163f55d61..e534cb4070 100644 --- a/test/parentype.go +++ b/test/parentype.go @@ -9,9 +9,9 @@ package main func f(interface{}) func g() {} func main() { - f(map[string]string("a":"b","c":"d")); - f((map[string]string)("a":"b","c":"d")); - f((map[string]func())("a":g,"c":g)); + f(map[string]string{"a":"b","c":"d"}); + f((map[string]string){"a":"b","c":"d"}); + f((map[string]func()){"a":g,"c":g}); f(make(chan(<-chan int))); f(make(chan<-(chan int))); } diff --git a/usr/gri/pretty/parser.go b/usr/gri/pretty/parser.go index 2183243545..27bf4b3cb6 100644 --- a/usr/gri/pretty/parser.go +++ b/usr/gri/pretty/parser.go @@ -248,13 +248,13 @@ func (P *Parser) parseIdent(scope *SymbolTable.Scope) *AST.Ident { } else { assert(obj.Kind != SymbolTable.NONE); } - x := &AST.Ident(P.pos, obj); + x := &AST.Ident{P.pos, obj}; P.next(); return x; } P.expect(Scanner.IDENT); // use expect() error handling - return &AST.Ident(P.pos, nil); + return &AST.Ident{P.pos, nil}; } @@ -272,10 +272,10 @@ func (P *Parser) parseIdentList(x AST.Expr) AST.Expr { P.next(); y := P.parseIdent(nil); if last == nil { - last = &AST.BinaryExpr(pos, Scanner.COMMA, x, y); + last = &AST.BinaryExpr{pos, Scanner.COMMA, x, y}; x = last; } else { - last.Y = &AST.BinaryExpr(pos, Scanner.COMMA, last.Y, y); + last.Y = &AST.BinaryExpr{pos, Scanner.COMMA, last.Y, y}; last = last.Y.(*AST.BinaryExpr); } } @@ -319,7 +319,7 @@ func (P *Parser) parseType() AST.Expr { t := P.tryType(); if t == nil { P.error(P.pos, "type expected"); - t = &AST.BadExpr(P.pos); + t = &AST.BadExpr{P.pos}; } return t; @@ -345,7 +345,7 @@ func (P *Parser) parseQualifiedIdent() AST.Expr { pos := P.pos; P.next(); y := P.parseIdent(nil); - x = &AST.Selector(pos, x, y); + x = &AST.Selector{pos, x, y}; } return x; @@ -370,7 +370,7 @@ func (P *Parser) parseArrayType() *AST.ArrayType { P.expect(Scanner.LBRACK); var len AST.Expr; if P.tok == Scanner.ELLIPSIS { - len = &AST.Ellipsis(P.pos); + len = &AST.Ellipsis{P.pos}; P.next(); } else if P.tok != Scanner.RBRACK { len = P.parseExpression(1); @@ -378,7 +378,7 @@ func (P *Parser) parseArrayType() *AST.ArrayType { P.expect(Scanner.RBRACK); elt := P.parseType(); - return &AST.ArrayType(pos, len, elt); + return &AST.ArrayType{pos, len, elt}; } @@ -402,7 +402,7 @@ func (P *Parser) parseChannelType() *AST.ChannelType { } val := P.parseVarType(); - return &AST.ChannelType(pos, mode, val); + return &AST.ChannelType{pos, mode, val}; } @@ -410,7 +410,7 @@ func (P *Parser) tryParameterType() AST.Expr { if P.tok == Scanner.ELLIPSIS { pos := P.tok; P.next(); - return &AST.Ellipsis(pos); + return &AST.Ellipsis{pos}; } return P.tryType(); } @@ -420,7 +420,7 @@ func (P *Parser) parseParameterType() AST.Expr { typ := P.tryParameterType(); if typ == nil { P.error(P.tok, "type expected"); - typ = &AST.BadExpr(P.pos); + typ = &AST.BadExpr{P.pos}; } return typ; } @@ -464,20 +464,20 @@ func (P *Parser) parseParameterList(ellipsis_ok bool) []*AST.Field { idents[i] = list.At(i).(*AST.Ident); } list.Init(0); - list.Push(&AST.Field(idents, typ, nil)); + list.Push(&AST.Field{idents, typ, nil}); for P.tok == Scanner.COMMA { P.next(); idents := P.parseIdentList2(nil); typ := P.parseParameterType(); - list.Push(&AST.Field(idents, typ, nil)); + list.Push(&AST.Field{idents, typ, nil}); } } else { // Type { "," Type } // convert list of types into list of *Param for i := 0; i < list.Len(); i++ { - list.Set(i, &AST.Field(nil, list.At(i).(AST.Expr), nil)); + list.Set(i, &AST.Field{nil, list.At(i).(AST.Expr), nil}); } } @@ -520,7 +520,7 @@ func (P *Parser) parseResult() []*AST.Field { typ := P.tryType(); if typ != nil { result = make([]*AST.Field, 1); - result[0] = &AST.Field(nil, typ, nil); + result[0] = &AST.Field{nil, typ, nil}; } } @@ -550,7 +550,7 @@ func (P *Parser) parseSignature() *AST.Signature { //P.scope_lev--; //P.closeScope(); - return &AST.Signature(params, result); + return &AST.Signature{params, result}; } @@ -563,7 +563,7 @@ func (P *Parser) parseFunctionType() *AST.FunctionType { P.expect(Scanner.FUNC); sig := P.parseSignature(); - return &AST.FunctionType(pos, sig); + return &AST.FunctionType{pos, sig}; } @@ -578,13 +578,13 @@ func (P *Parser) parseMethodSpec() *AST.Field { if tmp, is_ident := x.(*AST.Ident); is_ident && (P.tok == Scanner.COMMA || P.tok == Scanner.LPAREN) { // method(s) idents = P.parseIdentList2(x); - typ = &AST.FunctionType(0, P.parseSignature()); + typ = &AST.FunctionType{0, P.parseSignature()}; } else { // embedded interface typ = x; } - return &AST.Field(idents, typ, nil); + return &AST.Field{idents, typ, nil}; } @@ -625,7 +625,7 @@ func (P *Parser) parseInterfaceType() *AST.InterfaceType { } } - return &AST.InterfaceType(pos, methods, end); + return &AST.InterfaceType{pos, methods, end}; } @@ -641,7 +641,7 @@ func (P *Parser) parseMapType() *AST.MapType { P.expect(Scanner.RBRACK); val := P.parseVarType(); - return &AST.MapType(pos, key, val); + return &AST.MapType{pos, key, val}; } @@ -697,7 +697,7 @@ func (P *Parser) parseFieldDecl() *AST.Field { } } - return &AST.Field(idents, typ, tag); + return &AST.Field{idents, typ, tag}; } @@ -736,7 +736,7 @@ func (P *Parser) parseStructType() AST.Expr { } } - return AST.StructType(pos, fields, end); + return AST.StructType{pos, fields, end}; } @@ -749,7 +749,7 @@ func (P *Parser) parsePointerType() AST.Expr { P.expect(Scanner.MUL); base := P.parseType(); - return &AST.PointerType(pos, base); + return &AST.PointerType{pos, base}; } @@ -772,7 +772,7 @@ func (P *Parser) tryType() AST.Expr { P.next(); t := P.parseType(); P.expect(Scanner.RPAREN); - return &AST.Group(pos, t); + return &AST.Group{pos, t}; } // no type found @@ -862,10 +862,10 @@ func (P *Parser) parseExpressionList() AST.Expr { P.next(); y := P.parseExpression(1); if first { - x = &AST.BinaryExpr(pos, Scanner.COMMA, x, y); + x = &AST.BinaryExpr{pos, Scanner.COMMA, x, y}; first = false; } else { - x.(*AST.BinaryExpr).Y = &AST.BinaryExpr(pos, Scanner.COMMA, x.(*AST.BinaryExpr).Y, y); + x.(*AST.BinaryExpr).Y = &AST.BinaryExpr{pos, Scanner.COMMA, x.(*AST.BinaryExpr).Y, y}; } } @@ -885,7 +885,7 @@ func (P *Parser) parseFunctionLit() AST.Expr { body := P.parseBlock(Scanner.LBRACE); P.scope_lev--; - return &AST.FunctionLit(pos, typ, body); + return &AST.FunctionLit{pos, typ, body}; } @@ -903,10 +903,10 @@ func (P *Parser) parseOperand() AST.Expr { P.next(); x := P.parseExpression(1); P.expect(Scanner.RPAREN); - return &AST.Group(pos, x); + return &AST.Group{pos, x}; case Scanner.INT, Scanner.FLOAT, Scanner.STRING: - x := &AST.BasicLit(P.pos, P.tok, P.val); + x := &AST.BasicLit{P.pos, P.tok, P.val}; P.next(); if x.Tok == Scanner.STRING { // TODO should remember the list instead of @@ -930,7 +930,7 @@ func (P *Parser) parseOperand() AST.Expr { } } - return &AST.BadExpr(P.pos); + return &AST.BadExpr{P.pos}; } @@ -943,11 +943,11 @@ func (P *Parser) parseSelectorOrTypeGuard(x AST.Expr) AST.Expr { P.expect(Scanner.PERIOD); if P.tok == Scanner.IDENT { - x = &AST.Selector(pos, x, P.parseIdent(nil)); + x = &AST.Selector{pos, x, P.parseIdent(nil)}; } else { P.expect(Scanner.LPAREN); - x = &AST.TypeGuard(pos, x, P.parseType()); + x = &AST.TypeGuard{pos, x, P.parseType()}; P.expect(Scanner.RPAREN); } @@ -965,7 +965,7 @@ func (P *Parser) parseIndex(x AST.Expr) AST.Expr { i := P.parseExpression(0); P.expect(Scanner.RBRACK); - return &AST.Index(pos, x, i); + return &AST.Index{pos, x, i}; } @@ -998,10 +998,10 @@ func (P *Parser) parseCompositeElements() AST.Expr { } if last == nil { - last = &AST.BinaryExpr(pos, Scanner.COMMA, x, y); + last = &AST.BinaryExpr{pos, Scanner.COMMA, x, y}; x = last; } else { - last.Y = &AST.BinaryExpr(pos, Scanner.COMMA, last.Y, y); + last.Y = &AST.BinaryExpr{pos, Scanner.COMMA, last.Y, y}; last = last.Y.(*AST.BinaryExpr); } @@ -1031,7 +1031,7 @@ func (P *Parser) parseCallOrCompositeLit(f AST.Expr) AST.Expr { } P.expect(Scanner.RPAREN); - return &AST.Call(pos, f, args); + return &AST.Call{pos, f, args}; } @@ -1066,15 +1066,15 @@ func (P *Parser) parseUnaryExpr() AST.Expr { pos, tok := P.pos, P.tok; P.next(); y := P.parseUnaryExpr(); - return &AST.UnaryExpr(pos, tok, y); + return &AST.UnaryExpr{pos, tok, y}; /* if lit, ok := y.(*AST.TypeLit); ok && tok == Scanner.MUL { // pointer type t := AST.NewType(pos, AST.POINTER); t.Elt = lit.Typ; - return &AST.TypeLit(t); + return &AST.TypeLit{t}; } else { - return &AST.UnaryExpr(pos, tok, y); + return &AST.UnaryExpr{pos, tok, y}; } */ } @@ -1094,7 +1094,7 @@ func (P *Parser) parseBinaryExpr(prec1 int) AST.Expr { pos, tok := P.pos, P.tok; P.next(); y := P.parseBinaryExpr(prec + 1); - x = &AST.BinaryExpr(pos, tok, x, y); + x = &AST.BinaryExpr{pos, tok, x, y}; } } @@ -1133,7 +1133,7 @@ func (P *Parser) parseSimpleStat(range_ok bool) AST.Stat { P.opt_semi = true; if AST.ExprLen(x) == 1 { if label, is_ident := x.(*AST.Ident); is_ident { - return &AST.LabelDecl(pos, label); + return &AST.LabelDecl{pos, label}; } } P.error(x.Pos(), "illegal label declaration"); @@ -1151,7 +1151,7 @@ func (P *Parser) parseSimpleStat(range_ok bool) AST.Stat { if range_ok && P.tok == Scanner.RANGE { range_pos := P.pos; P.next(); - y = &AST.UnaryExpr(range_pos, Scanner.RANGE, P.parseExpression(1)); + y = &AST.UnaryExpr{range_pos, Scanner.RANGE, P.parseExpression(1)}; if tok != Scanner.DEFINE && tok != Scanner.ASSIGN { P.error(pos, "expected '=' or ':=', found '" + Scanner.TokenString(tok) + "'"); } @@ -1162,7 +1162,7 @@ func (P *Parser) parseSimpleStat(range_ok bool) AST.Stat { } } // TODO changed ILLEGAL -> NONE - return &AST.ExpressionStat(x.Pos(), Scanner.ILLEGAL, &AST.BinaryExpr(pos, tok, x, y)); + return &AST.ExpressionStat{x.Pos(), Scanner.ILLEGAL, &AST.BinaryExpr{pos, tok, x, y}}; default: if AST.ExprLen(x) != 1 { @@ -1170,13 +1170,13 @@ func (P *Parser) parseSimpleStat(range_ok bool) AST.Stat { } if P.tok == Scanner.INC || P.tok == Scanner.DEC { - s := &AST.ExpressionStat(P.pos, P.tok, x); + s := &AST.ExpressionStat{P.pos, P.tok, x}; P.next(); // consume "++" or "--" return s; } // TODO changed ILLEGAL -> NONE - return &AST.ExpressionStat(x.Pos(), Scanner.ILLEGAL, x); + return &AST.ExpressionStat{x.Pos(), Scanner.ILLEGAL, x}; } unreachable(); @@ -1191,7 +1191,7 @@ func (P *Parser) parseInvocationStat(keyword int) *AST.ExpressionStat { pos := P.pos; P.expect(keyword); - return &AST.ExpressionStat(pos, keyword, P.parseExpression(1)); + return &AST.ExpressionStat{pos, keyword, P.parseExpression(1)}; } @@ -1207,7 +1207,7 @@ func (P *Parser) parseReturnStat() *AST.ExpressionStat { x = P.parseExpressionList(); } - return &AST.ExpressionStat(pos, Scanner.RETURN, x); + return &AST.ExpressionStat{pos, Scanner.RETURN, x}; } @@ -1216,7 +1216,7 @@ func (P *Parser) parseControlFlowStat(tok int) *AST.ControlFlowStat { defer un(trace(P, "ControlFlowStat")); } - s := &AST.ControlFlowStat(P.pos, tok, nil); + s := &AST.ControlFlowStat{P.pos, tok, nil}; P.expect(tok); if tok != Scanner.FALLTHROUGH && P.tok == Scanner.IDENT { s.Label = P.parseIdent(P.top_scope); @@ -1281,7 +1281,7 @@ func (P *Parser) parseIfStat() *AST.IfStat { // wrap in a block since we don't have one body := AST.NewBlock(0, Scanner.LBRACE); body.List.Push(else_); - else_ = &AST.CompositeStat(body); + else_ = &AST.CompositeStat{body}; } } else { P.error(P.pos, "'if' or '{' expected - illegal 'else' branch"); @@ -1289,7 +1289,7 @@ func (P *Parser) parseIfStat() *AST.IfStat { } P.closeScope(); - return &AST.IfStat(pos, init, cond, body, else_); + return &AST.IfStat{pos, init, cond, body, else_}; } @@ -1305,7 +1305,7 @@ func (P *Parser) parseForStat() *AST.ForStat { body := P.parseBlock(Scanner.LBRACE); P.closeScope(); - return &AST.ForStat(pos, init, cond, post, body); + return &AST.ForStat{pos, init, cond, post, body}; } @@ -1324,7 +1324,7 @@ func (P *Parser) parseCaseClause() *AST.CaseClause { P.expect(Scanner.DEFAULT); } - return &AST.CaseClause(pos, expr, P.parseBlock(Scanner.COLON)); + return &AST.CaseClause{pos, expr, P.parseBlock(Scanner.COLON)}; } @@ -1347,7 +1347,7 @@ func (P *Parser) parseSwitchStat() *AST.SwitchStat { P.opt_semi = true; P.closeScope(); - return &AST.SwitchStat(pos, init, tag, body); + return &AST.SwitchStat{pos, init, tag, body}; } @@ -1367,7 +1367,7 @@ func (P *Parser) parseCommClause() *AST.CaseClause { P.next(); if P.tok == Scanner.ARROW { y := P.parseExpression(1); - x = &AST.BinaryExpr(pos, tok, x, y); + x = &AST.BinaryExpr{pos, tok, x, y}; } else { P.expect(Scanner.ARROW); // use expect() error handling } @@ -1377,7 +1377,7 @@ func (P *Parser) parseCommClause() *AST.CaseClause { P.expect(Scanner.DEFAULT); } - return &AST.CaseClause(pos, expr, P.parseBlock(Scanner.COLON)); + return &AST.CaseClause{pos, expr, P.parseBlock(Scanner.COLON)}; } @@ -1399,7 +1399,7 @@ func (P *Parser) parseSelectStat() *AST.SelectStat { P.opt_semi = true; P.closeScope(); - return &AST.SelectStat(pos, body); + return &AST.SelectStat{pos, body}; } @@ -1410,7 +1410,7 @@ func (P *Parser) parseStatement() AST.Stat { switch P.tok { case Scanner.CONST, Scanner.TYPE, Scanner.VAR: - return &AST.DeclarationStat(P.parseDeclaration()); + return &AST.DeclarationStat{P.parseDeclaration()}; case Scanner.FUNC: // for now we do not allow local function declarations, // instead we assume this starts a function literal @@ -1428,7 +1428,7 @@ func (P *Parser) parseStatement() AST.Stat { case Scanner.BREAK, Scanner.CONTINUE, Scanner.GOTO, Scanner.FALLTHROUGH: return P.parseControlFlowStat(P.tok); case Scanner.LBRACE: - return &AST.CompositeStat(P.parseBlock(Scanner.LBRACE)); + return &AST.CompositeStat{P.parseBlock(Scanner.LBRACE)}; case Scanner.IF: return P.parseIfStat(); case Scanner.FOR: @@ -1439,12 +1439,12 @@ func (P *Parser) parseStatement() AST.Stat { return P.parseSelectStat(); case Scanner.SEMICOLON: // don't consume the ";", it is the separator following the empty statement - return &AST.EmptyStat(P.pos); + return &AST.EmptyStat{P.pos}; } // no statement found P.error(P.pos, "statement expected"); - return &AST.BadStat(P.pos); + return &AST.BadStat{P.pos}; } @@ -1467,13 +1467,13 @@ func (P *Parser) parseImportSpec(pos int) *AST.ImportDecl { var path AST.Expr; if P.tok == Scanner.STRING { // TODO eventually the scanner should strip the quotes - path = &AST.BasicLit(P.pos, Scanner.STRING, P.val); + path = &AST.BasicLit{P.pos, Scanner.STRING, P.val}; P.next(); } else { P.expect(Scanner.STRING); // use expect() error handling } - return &AST.ImportDecl(pos, ident, path); + return &AST.ImportDecl{pos, ident, path}; } @@ -1490,7 +1490,7 @@ func (P *Parser) parseConstSpec(pos int) *AST.ConstDecl { vals = P.parseExpressionList(); } - return &AST.ConstDecl(pos, idents, typ, vals); + return &AST.ConstDecl{pos, idents, typ, vals}; } @@ -1502,7 +1502,7 @@ func (P *Parser) parseTypeSpec(pos int) *AST.TypeDecl { ident := P.parseIdent(nil); typ := P.parseType(); - return &AST.TypeDecl(pos, ident, typ); + return &AST.TypeDecl{pos, ident, typ}; } @@ -1525,7 +1525,7 @@ func (P *Parser) parseVarSpec(pos int) *AST.VarDecl { } } - return &AST.VarDecl(pos, idents, typ, vals); + return &AST.VarDecl{pos, idents, typ, vals}; } @@ -1601,7 +1601,7 @@ func (P *Parser) parseDecl(keyword int) AST.Decl { decls[i] = list.At(i).(AST.Decl); } - return &AST.DeclList(pos, keyword, decls, end); + return &AST.DeclList{pos, keyword, decls, end}; } return P.parseSpec(pos, keyword); @@ -1644,7 +1644,7 @@ func (P *Parser) parseFunctionDecl() *AST.FuncDecl { body = P.parseBlock(Scanner.LBRACE); } - return &AST.FuncDecl(pos, recv, ident, sig, body); + return &AST.FuncDecl{pos, recv, ident, sig, body}; } @@ -1663,7 +1663,7 @@ func (P *Parser) parseDeclaration() AST.Decl { pos := P.pos; P.error(pos, "declaration expected"); P.next(); // make progress - return &AST.BadDecl(pos); + return &AST.BadDecl{pos}; } diff --git a/usr/gri/pretty/selftest2.go b/usr/gri/pretty/selftest2.go index 3fc3bacc17..8fa907462d 100644 --- a/usr/gri/pretty/selftest2.go +++ b/usr/gri/pretty/selftest2.go @@ -46,9 +46,9 @@ var ( aa = 5; u, v, w int = 0, 0, 0; foo = "foo"; - fixed_array0 = [10]int(); - fixed_array1 = [10]int(0, 1, 2); - fixed_array2 = [...]string("foo", "bar"); + fixed_array0 = [10]int{}; + fixed_array1 = [10]int{0, 1, 2}; + fixed_array2 = [...]string{"foo", "bar"}; ) @@ -136,7 +136,7 @@ func main() { println(i + 1000); // the index + 1000 println(); } - f3(&[]int(2, 3, 5, 7), map[string]int("two":2, "three":3, "five":5, "seven":7)); + f3(&[]int{2, 3, 5, 7}, map[string]int{"two":2, "three":3, "five":5, "seven":7}); // the epilogue println("foo"); // foo println("foobar"); // foobar -- 2.48.1