summaryrefslogtreecommitdiffstats
path: root/test/ken
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-16 19:19:13 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-16 19:19:13 +0000
commitccd992355df7192993c666236047820244914598 (patch)
treef00fea65147227b7743083c6148396f74cd66935 /test/ken
parentInitial commit. (diff)
downloadgolang-1.21-ccd992355df7192993c666236047820244914598.tar.xz
golang-1.21-ccd992355df7192993c666236047820244914598.zip
Adding upstream version 1.21.8.upstream/1.21.8
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'test/ken')
-rw-r--r--test/ken/array.go138
-rw-r--r--test/ken/chan.go331
-rw-r--r--test/ken/chan1.go55
-rw-r--r--test/ken/complit.go172
-rw-r--r--test/ken/convert.go432
-rw-r--r--test/ken/cplx0.go30
-rw-r--r--test/ken/cplx0.out4
-rw-r--r--test/ken/cplx1.go99
-rw-r--r--test/ken/cplx2.go122
-rw-r--r--test/ken/cplx3.go54
-rw-r--r--test/ken/cplx4.go61
-rw-r--r--test/ken/cplx5.go72
-rw-r--r--test/ken/divconst.go634
-rw-r--r--test/ken/divmod.go249
-rw-r--r--test/ken/embed.go319
-rw-r--r--test/ken/for.go19
-rw-r--r--test/ken/interbasic.go184
-rw-r--r--test/ken/interfun.go59
-rw-r--r--test/ken/intervar.go69
-rw-r--r--test/ken/label.go34
-rw-r--r--test/ken/litfun.go23
-rw-r--r--test/ken/mfunc.go22
-rw-r--r--test/ken/modconst.go634
-rw-r--r--test/ken/ptrfun.go45
-rw-r--r--test/ken/ptrvar.go54
-rw-r--r--test/ken/range.go121
-rw-r--r--test/ken/rob1.go72
-rw-r--r--test/ken/rob2.go280
-rw-r--r--test/ken/robfor.go58
-rw-r--r--test/ken/robfunc.go96
-rw-r--r--test/ken/shift.go121
-rw-r--r--test/ken/simparray.go50
-rw-r--r--test/ken/simpbool.go107
-rw-r--r--test/ken/simpconv.go30
-rw-r--r--test/ken/simpfun.go26
-rw-r--r--test/ken/simpswitch.go28
-rw-r--r--test/ken/simpvar.go27
-rw-r--r--test/ken/slicearray.go212
-rw-r--r--test/ken/sliceslice.go205
-rw-r--r--test/ken/string.go114
-rw-r--r--test/ken/string.out1
-rw-r--r--test/ken/strvar.go79
42 files changed, 5542 insertions, 0 deletions
diff --git a/test/ken/array.go b/test/ken/array.go
new file mode 100644
index 0000000..9412e35
--- /dev/null
+++ b/test/ken/array.go
@@ -0,0 +1,138 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test arrays and slices.
+
+package main
+
+func setpd(a []int) {
+ // print("setpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
+ for i := 0; i < len(a); i++ {
+ a[i] = i
+ }
+}
+
+func sumpd(a []int) int {
+ // print("sumpd a=", a, " len=", len(a), " cap=", cap(a), "\n");
+ t := 0
+ for i := 0; i < len(a); i++ {
+ t += a[i]
+ }
+ // print("sumpd t=", t, "\n");
+ return t
+}
+
+func setpf(a *[20]int) {
+ // print("setpf a=", a, " len=", len(a), " cap=", cap(a), "\n");
+ for i := 0; i < len(a); i++ {
+ a[i] = i
+ }
+}
+
+func sumpf(a *[20]int) int {
+ // print("sumpf a=", a, " len=", len(a), " cap=", cap(a), "\n");
+ t := 0
+ for i := 0; i < len(a); i++ {
+ t += a[i]
+ }
+ // print("sumpf t=", t, "\n");
+ return t
+}
+
+func res(t int, lb, hb int) {
+ sb := (hb - lb) * (hb + lb - 1) / 2
+ if t != sb {
+ print("lb=", lb,
+ "; hb=", hb,
+ "; t=", t,
+ "; sb=", sb,
+ "\n")
+ panic("res")
+ }
+}
+
+// call ptr dynamic with ptr dynamic
+func testpdpd() {
+ a := make([]int, 10, 100)
+ if len(a) != 10 && cap(a) != 100 {
+ print("len and cap from new: ", len(a), " ", cap(a), "\n")
+ panic("fail")
+ }
+
+ a = a[0:100]
+ setpd(a)
+
+ a = a[0:10]
+ res(sumpd(a), 0, 10)
+
+ a = a[5:25]
+ res(sumpd(a), 5, 25)
+
+ a = a[30:95]
+ res(sumpd(a), 35, 100)
+}
+
+// call ptr fixed with ptr fixed
+func testpfpf() {
+ var a [20]int
+
+ setpf(&a)
+ res(sumpf(&a), 0, 20)
+}
+
+// call ptr dynamic with ptr fixed from new
+func testpdpf1() {
+ a := new([40]int)
+ setpd(a[0:])
+ res(sumpd(a[0:]), 0, 40)
+
+ b := (*a)[5:30]
+ res(sumpd(b), 5, 30)
+}
+
+// call ptr dynamic with ptr fixed from var
+func testpdpf2() {
+ var a [80]int
+
+ setpd(a[0:])
+ res(sumpd(a[0:]), 0, 80)
+}
+
+// generate bounds error with ptr dynamic
+func testpdfault() {
+ a := make([]int, 100)
+
+ print("good\n")
+ for i := 0; i < 100; i++ {
+ a[i] = 0
+ }
+ print("should fault\n")
+ a[100] = 0
+ print("bad\n")
+}
+
+// generate bounds error with ptr fixed
+func testfdfault() {
+ var a [80]int
+
+ print("good\n")
+ for i := 0; i < 80; i++ {
+ a[i] = 0
+ }
+ print("should fault\n")
+ x := 80
+ a[x] = 0
+ print("bad\n")
+}
+
+func main() {
+ testpdpd()
+ testpfpf()
+ testpdpf1()
+ testpdpf2()
+ // print("testpdfault\n"); testpdfault();
+ // print("testfdfault\n"); testfdfault();
+}
diff --git a/test/ken/chan.go b/test/ken/chan.go
new file mode 100644
index 0000000..36b18f8
--- /dev/null
+++ b/test/ken/chan.go
@@ -0,0 +1,331 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test communication operations including select.
+
+package main
+
+import "os"
+import "runtime"
+import "sync"
+
+var randx int
+
+func nrand(n int) int {
+ randx += 10007
+ if randx >= 1000000 {
+ randx -= 1000000
+ }
+ return randx % n
+}
+
+type Chan struct {
+ sc, rc chan int // send and recv chan
+ sv, rv int // send and recv seq
+}
+
+var (
+ nproc int
+ nprocLock sync.Mutex
+ cval int
+ end int = 10000
+ totr, tots int
+ totLock sync.Mutex
+ nc *Chan
+)
+
+func init() {
+ nc = new(Chan)
+}
+
+func changeNproc(adjust int) int {
+ nprocLock.Lock()
+ nproc += adjust
+ ret := nproc
+ nprocLock.Unlock()
+ return ret
+}
+
+func mkchan(c, n int) []*Chan {
+ ca := make([]*Chan, n)
+ for i := 0; i < n; i++ {
+ cval = cval + 100
+ ch := new(Chan)
+ ch.sc = make(chan int, c)
+ ch.rc = ch.sc
+ ch.sv = cval
+ ch.rv = cval
+ ca[i] = ch
+ }
+ return ca
+}
+
+func expect(v, v0 int) (newv int) {
+ if v == v0 {
+ if v%100 == 75 {
+ return end
+ }
+ return v + 1
+ }
+ print("got ", v, " expected ", v0+1, "\n")
+ panic("fail")
+}
+
+func (c *Chan) send() bool {
+ // print("send ", c.sv, "\n");
+ totLock.Lock()
+ tots++
+ totLock.Unlock()
+ c.sv = expect(c.sv, c.sv)
+ if c.sv == end {
+ c.sc = nil
+ return true
+ }
+ return false
+}
+
+func send(c *Chan) {
+ for {
+ for r := nrand(10); r >= 0; r-- {
+ runtime.Gosched()
+ }
+ c.sc <- c.sv
+ if c.send() {
+ break
+ }
+ }
+ changeNproc(-1)
+}
+
+func (c *Chan) recv(v int) bool {
+ // print("recv ", v, "\n");
+ totLock.Lock()
+ totr++
+ totLock.Unlock()
+ c.rv = expect(c.rv, v)
+ if c.rv == end {
+ c.rc = nil
+ return true
+ }
+ return false
+}
+
+func recv(c *Chan) {
+ var v int
+
+ for {
+ for r := nrand(10); r >= 0; r-- {
+ runtime.Gosched()
+ }
+ v = <-c.rc
+ if c.recv(v) {
+ break
+ }
+ }
+ changeNproc(-1)
+}
+
+func sel(r0, r1, r2, r3, s0, s1, s2, s3 *Chan) {
+ var v int
+
+ a := 0 // local chans running
+
+ if r0.rc != nil {
+ a++
+ }
+ if r1.rc != nil {
+ a++
+ }
+ if r2.rc != nil {
+ a++
+ }
+ if r3.rc != nil {
+ a++
+ }
+ if s0.sc != nil {
+ a++
+ }
+ if s1.sc != nil {
+ a++
+ }
+ if s2.sc != nil {
+ a++
+ }
+ if s3.sc != nil {
+ a++
+ }
+
+ for {
+ for r := nrand(5); r >= 0; r-- {
+ runtime.Gosched()
+ }
+
+ select {
+ case v = <-r0.rc:
+ if r0.recv(v) {
+ a--
+ }
+ case v = <-r1.rc:
+ if r1.recv(v) {
+ a--
+ }
+ case v = <-r2.rc:
+ if r2.recv(v) {
+ a--
+ }
+ case v = <-r3.rc:
+ if r3.recv(v) {
+ a--
+ }
+ case s0.sc <- s0.sv:
+ if s0.send() {
+ a--
+ }
+ case s1.sc <- s1.sv:
+ if s1.send() {
+ a--
+ }
+ case s2.sc <- s2.sv:
+ if s2.send() {
+ a--
+ }
+ case s3.sc <- s3.sv:
+ if s3.send() {
+ a--
+ }
+ }
+ if a == 0 {
+ break
+ }
+ }
+ changeNproc(-1)
+}
+
+// direct send to direct recv
+func test1(c *Chan) {
+ changeNproc(2)
+ go send(c)
+ go recv(c)
+}
+
+// direct send to select recv
+func test2(c int) {
+ ca := mkchan(c, 4)
+
+ changeNproc(4)
+ go send(ca[0])
+ go send(ca[1])
+ go send(ca[2])
+ go send(ca[3])
+
+ changeNproc(1)
+ go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc)
+}
+
+// select send to direct recv
+func test3(c int) {
+ ca := mkchan(c, 4)
+
+ changeNproc(4)
+ go recv(ca[0])
+ go recv(ca[1])
+ go recv(ca[2])
+ go recv(ca[3])
+
+ changeNproc(1)
+ go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3])
+}
+
+// select send to select recv
+func test4(c int) {
+ ca := mkchan(c, 4)
+
+ changeNproc(2)
+ go sel(nc, nc, nc, nc, ca[0], ca[1], ca[2], ca[3])
+ go sel(ca[0], ca[1], ca[2], ca[3], nc, nc, nc, nc)
+}
+
+func test5(c int) {
+ ca := mkchan(c, 8)
+
+ changeNproc(2)
+ go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3])
+ go sel(ca[0], ca[1], ca[2], ca[3], ca[4], ca[5], ca[6], ca[7])
+}
+
+func test6(c int) {
+ ca := mkchan(c, 12)
+
+ changeNproc(4)
+ go send(ca[4])
+ go send(ca[5])
+ go send(ca[6])
+ go send(ca[7])
+
+ changeNproc(4)
+ go recv(ca[8])
+ go recv(ca[9])
+ go recv(ca[10])
+ go recv(ca[11])
+
+ changeNproc(2)
+ go sel(ca[4], ca[5], ca[6], ca[7], ca[0], ca[1], ca[2], ca[3])
+ go sel(ca[0], ca[1], ca[2], ca[3], ca[8], ca[9], ca[10], ca[11])
+}
+
+// wait for outstanding tests to finish
+func wait() {
+ runtime.Gosched()
+ for changeNproc(0) != 0 {
+ runtime.Gosched()
+ }
+}
+
+// run all tests with specified buffer size
+func tests(c int) {
+ ca := mkchan(c, 4)
+ test1(ca[0])
+ test1(ca[1])
+ test1(ca[2])
+ test1(ca[3])
+ wait()
+
+ test2(c)
+ wait()
+
+ test3(c)
+ wait()
+
+ test4(c)
+ wait()
+
+ test5(c)
+ wait()
+
+ test6(c)
+ wait()
+}
+
+// run all test with 4 buffser sizes
+func main() {
+
+ tests(0)
+ tests(1)
+ tests(10)
+ tests(100)
+
+ t := 4 * // buffer sizes
+ (4*4 + // tests 1,2,3,4 channels
+ 8 + // test 5 channels
+ 12) * // test 6 channels
+ 76 // sends/recvs on a channel
+
+ if tots != t || totr != t {
+ print("tots=", tots, " totr=", totr, " sb=", t, "\n")
+ os.Exit(1)
+ }
+ os.Exit(0)
+}
diff --git a/test/ken/chan1.go b/test/ken/chan1.go
new file mode 100644
index 0000000..cbd21a3
--- /dev/null
+++ b/test/ken/chan1.go
@@ -0,0 +1,55 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test communication with multiple simultaneous goroutines.
+
+package main
+
+import "runtime"
+
+const N = 1000 // sent messages
+const M = 10 // receiving goroutines
+const W = 2 // channel buffering
+var h [N]int // marking of send/recv
+
+func r(c chan int, m int) {
+ for {
+ select {
+ case r := <-c:
+ if h[r] != 1 {
+ println("r",
+ "m=", m,
+ "r=", r,
+ "h=", h[r])
+ panic("fail")
+ }
+ h[r] = 2
+ }
+ }
+}
+
+func s(c chan int) {
+ for n := 0; n < N; n++ {
+ r := n
+ if h[r] != 0 {
+ println("s")
+ panic("fail")
+ }
+ h[r] = 1
+ c <- r
+ }
+}
+
+func main() {
+ c := make(chan int, W)
+ for m := 0; m < M; m++ {
+ go r(c, m)
+ runtime.Gosched()
+ }
+ runtime.Gosched()
+ runtime.Gosched()
+ s(c)
+}
diff --git a/test/ken/complit.go b/test/ken/complit.go
new file mode 100644
index 0000000..bc50bbe
--- /dev/null
+++ b/test/ken/complit.go
@@ -0,0 +1,172 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test composite literals.
+
+package main
+
+type M map[int]int
+type S struct{ a,b,c int };
+type SS struct{ aa,bb,cc S };
+type SA struct{ a,b,c [3]int };
+type SC struct{ a,b,c []int };
+type SM struct{ a,b,c M };
+
+func
+main() {
+ test("s.a", s.a);
+ test("s.b", s.b);
+ test("s.c", s.c);
+
+ test("ss.aa.a", ss.aa.a);
+ test("ss.aa.b", ss.aa.b);
+ test("ss.aa.c", ss.aa.c);
+
+ test("ss.bb.a", ss.bb.a);
+ test("ss.bb.b", ss.bb.b);
+ test("ss.bb.c", ss.bb.c);
+
+ test("ss.cc.a", ss.cc.a);
+ test("ss.cc.b", ss.cc.b);
+ test("ss.cc.c", ss.cc.c);
+
+ for i:=0; i<3; i++ {
+ test("a[i]", a[i]);
+ test("c[i]", c[i]);
+ test("m[i]", m[i]);
+
+ test("as[i].a", as[i].a);
+ test("as[i].b", as[i].b);
+ test("as[i].c", as[i].c);
+
+ test("cs[i].a", cs[i].a);
+ test("cs[i].b", cs[i].b);
+ test("cs[i].c", cs[i].c);
+
+ test("ms[i].a", ms[i].a);
+ test("ms[i].b", ms[i].b);
+ test("ms[i].c", ms[i].c);
+
+ test("sa.a[i]", sa.a[i]);
+ test("sa.b[i]", sa.b[i]);
+ test("sa.c[i]", sa.c[i]);
+
+ test("sc.a[i]", sc.a[i]);
+ test("sc.b[i]", sc.b[i]);
+ test("sc.c[i]", sc.c[i]);
+
+ test("sm.a[i]", sm.a[i]);
+ test("sm.b[i]", sm.b[i]);
+ test("sm.c[i]", sm.c[i]);
+
+ for j:=0; j<3; j++ {
+ test("aa[i][j]", aa[i][j]);
+ test("ac[i][j]", ac[i][j]);
+ test("am[i][j]", am[i][j]);
+ test("ca[i][j]", ca[i][j]);
+ test("cc[i][j]", cc[i][j]);
+ test("cm[i][j]", cm[i][j]);
+ test("ma[i][j]", ma[i][j]);
+ test("mc[i][j]", mc[i][j]);
+ test("mm[i][j]", mm[i][j]);
+ }
+ }
+
+}
+
+var ref = 0;
+
+func
+test(xs string, x int) {
+
+ if ref >= len(answers) {
+ println(xs, x);
+ return;
+ }
+
+ if x != answers[ref] {
+ println(xs, "is", x, "should be", answers[ref])
+ }
+ ref++;
+}
+
+
+var a = [3]int{1001, 1002, 1003}
+var s = S{1101, 1102, 1103}
+var c = []int{1201, 1202, 1203}
+var m = M{0:1301, 1:1302, 2:1303}
+
+var aa = [3][3]int{[3]int{2001,2002,2003}, [3]int{2004,2005,2006}, [3]int{2007,2008,2009}}
+var as = [3]S{S{2101,2102,2103},S{2104,2105,2106},S{2107,2108,2109}}
+var ac = [3][]int{[]int{2201,2202,2203}, []int{2204,2205,2206}, []int{2207,2208,2209}}
+var am = [3]M{M{0:2301,1:2302,2:2303}, M{0:2304,1:2305,2:2306}, M{0:2307,1:2308,2:2309}}
+
+var sa = SA{[3]int{3001,3002,3003},[3]int{3004,3005,3006},[3]int{3007,3008,3009}}
+var ss = SS{S{3101,3102,3103},S{3104,3105,3106},S{3107,3108,3109}}
+var sc = SC{[]int{3201,3202,3203},[]int{3204,3205,3206},[]int{3207,3208,3209}}
+var sm = SM{M{0:3301,1:3302,2:3303}, M{0:3304,1:3305,2:3306}, M{0:3307,1:3308,2:3309}}
+
+var ca = [][3]int{[3]int{4001,4002,4003}, [3]int{4004,4005,4006}, [3]int{4007,4008,4009}}
+var cs = []S{S{4101,4102,4103},S{4104,4105,4106},S{4107,4108,4109}}
+var cc = [][]int{[]int{4201,4202,4203}, []int{4204,4205,4206}, []int{4207,4208,4209}}
+var cm = []M{M{0:4301,1:4302,2:4303}, M{0:4304,1:4305,2:4306}, M{0:4307,1:4308,2:4309}}
+
+var ma = map[int][3]int{0:[3]int{5001,5002,5003}, 1:[3]int{5004,5005,5006}, 2:[3]int{5007,5008,5009}}
+var ms = map[int]S{0:S{5101,5102,5103},1:S{5104,5105,5106},2:S{5107,5108,5109}}
+var mc = map[int][]int{0:[]int{5201,5202,5203}, 1:[]int{5204,5205,5206}, 2:[]int{5207,5208,5209}}
+var mm = map[int]M{0:M{0:5301,1:5302,2:5303}, 1:M{0:5304,1:5305,2:5306}, 2:M{0:5307,1:5308,2:5309}}
+
+var answers = [...]int {
+ // s
+ 1101, 1102, 1103,
+
+ // ss
+ 3101, 3102, 3103,
+ 3104, 3105, 3106,
+ 3107, 3108, 3109,
+
+ // [0]
+ 1001, 1201, 1301,
+ 2101, 2102, 2103,
+ 4101, 4102, 4103,
+ 5101, 5102, 5103,
+ 3001, 3004, 3007,
+ 3201, 3204, 3207,
+ 3301, 3304, 3307,
+
+ // [0][j]
+ 2001, 2201, 2301, 4001, 4201, 4301, 5001, 5201, 5301,
+ 2002, 2202, 2302, 4002, 4202, 4302, 5002, 5202, 5302,
+ 2003, 2203, 2303, 4003, 4203, 4303, 5003, 5203, 5303,
+
+ // [1]
+ 1002, 1202, 1302,
+ 2104, 2105, 2106,
+ 4104, 4105, 4106,
+ 5104, 5105, 5106,
+ 3002, 3005, 3008,
+ 3202, 3205, 3208,
+ 3302, 3305, 3308,
+
+ // [1][j]
+ 2004, 2204, 2304, 4004, 4204, 4304, 5004, 5204, 5304,
+ 2005, 2205, 2305, 4005, 4205, 4305, 5005, 5205, 5305,
+ 2006, 2206, 2306, 4006, 4206, 4306, 5006, 5206, 5306,
+
+ // [2]
+ 1003, 1203, 1303,
+ 2107, 2108, 2109,
+ 4107, 4108, 4109,
+ 5107, 5108, 5109,
+ 3003, 3006, 3009,
+ 3203, 3206, 3209,
+ 3303, 3306, 3309,
+
+ // [2][j]
+ 2007, 2207, 2307, 4007, 4207, 4307, 5007, 5207, 5307,
+ 2008, 2208, 2308, 4008, 4208, 4308, 5008, 5208, 5308,
+ 2009, 2209, 2309, 4009, 4209, 4309, 5009, 5209, 5309,
+}
diff --git a/test/ken/convert.go b/test/ken/convert.go
new file mode 100644
index 0000000..33acbd8
--- /dev/null
+++ b/test/ken/convert.go
@@ -0,0 +1,432 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test, near-exhaustive, of converting numbers between types.
+// No complex numbers though.
+
+package main
+
+var i8 int8;
+var u8 uint8;
+var i16 int16;
+var u16 uint16;
+var i32 int32;
+var u32 uint32;
+var i64 int64;
+var u64 uint64;
+var f32 float32;
+var f64 float64;
+
+type big float64
+
+type t struct {
+ from, to int
+ val big
+}
+
+const (
+ ti8 = iota+1
+ tu8
+ ti16
+ tu16
+ ti32
+ tu32
+ ti64
+ tu64
+ tf32
+ tf64
+)
+
+var x = []t{
+
+ /* value good in all types (10) */
+ { ti8, ti8, 10 }, { ti8, tu8, 10 }, { ti8, ti16, 10 }, { ti8, tu16, 10 },
+ { ti8, ti32, 10 }, { ti8, tu32, 10 }, { ti8, ti64, 10 }, { ti8, tu64, 10 },
+ { ti8, tf32, 10 }, { ti8, tf64, 10 },
+
+ { tu8, ti8, 10 }, { tu8, tu8, 10 }, { tu8, ti16, 10 }, { tu8, tu16, 10 },
+ { tu8, ti32, 10 }, { tu8, tu32, 10 }, { tu8, ti64, 10 }, { tu8, tu64, 10 },
+ { tu8, tf32, 10 }, { tu8, tf64, 10 },
+
+ { ti16, ti8, 10 }, { ti16, tu8, 10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
+ { ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
+ { ti16, tf32, 10 }, { ti16, tf64, 10 },
+
+ { tu16, ti8, 10 }, { tu16, tu8, 10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
+ { tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
+ { tu16, tf32, 10 }, { tu16, tf64, 10 },
+
+ { ti32, ti8, 10 }, { ti32, tu8, 10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
+ { ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
+ { ti32, tf32, 10 }, { ti32, tf64, 10 },
+
+ { tu32, ti8, 10 }, { tu32, tu8, 10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
+ { tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
+ { tu32, tf32, 10 }, { tu32, tf64, 10 },
+
+ { ti64, ti8, 10 }, { ti64, tu8, 10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
+ { ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
+ { ti64, tf32, 10 }, { ti64, tf64, 10 },
+
+ { tu64, ti8, 10 }, { tu64, tu8, 10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
+ { tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
+ { tu64, tf32, 10 }, { tu64, tf64, 10 },
+
+ { tf32, ti8, 10 }, { tf32, tu8, 10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
+ { tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
+ { tf32, tf32, 10 }, { tf32, tf64, 10 },
+
+ { tf64, ti8, 10 }, { tf64, tu8, 10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
+ { tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
+ { tf64, tf32, 10 }, { tf64, tf64, 10 },
+
+ /* value good in all signed types (-4) */
+ { ti8, ti8, -4 }, { ti8, ti16, -4 },
+ { ti8, ti32, -4 }, { ti8, ti64, -4 },
+ { ti8, tf32, -4 }, { ti8, tf64, -4 },
+
+ { ti16, ti8, -4 }, { ti16, ti16, -4 },
+ { ti16, ti32, -4 }, { ti16, ti64, -4 },
+ { ti16, tf32, -4 },
+
+ { ti32, ti8, -4 }, { ti32, ti16, -4 },
+ { ti32, ti32, -4 }, { ti32, ti64, -4 },
+ { ti32, tf32, -4 }, { ti32, tf64, -4 },
+
+ { ti64, ti8, -4 }, { ti64, ti16, -4 },
+ { ti64, ti32, -4 }, { ti64, ti64, -4 },
+ { ti64, tf32, -4 },
+
+ { tf32, ti8, -4 }, { tf32, ti16, -4 },
+ { tf32, ti32, -4 }, { tf32, ti64, -4 },
+ { tf32, tf32, -4 },
+
+ { tf64, ti8, -4 }, { tf64, ti16, -4 },
+ { tf64, ti32, -4 }, { tf64, ti64, -4 },
+ { tf64, tf32, -4 }, { tf64, tf64, -4 },
+
+ /* value good in u8 and up (175) */
+ { tu8, tu8, 175 }, { tu8, ti16, 175 }, { tu8, tu16, 175 },
+ { tu8, ti32, 175 }, { tu8, tu32, 175 }, { tu8, ti64, 175 }, { tu8, tu64, 175 },
+ { tu8, tf32, 175 }, { tu8, tf64, 175 },
+
+ { ti16, tu8, 175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
+ { ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
+ { ti16, tf32, 175 }, { ti16, tf64, 175 },
+
+ { tu16, tu8, 175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
+ { tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
+ { tu16, tf32, 175 }, { tu16, tf64, 175 },
+
+ { ti32, tu8, 175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
+ { ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
+ { ti32, tf32, 175 }, { ti32, tf64, 175 },
+
+ { tu32, tu8, 175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
+ { tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
+ { tu32, tf32, 175 }, { tu32, tf64, 175 },
+
+ { ti64, tu8, 175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
+ { ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
+ { ti64, tf32, 175 }, { ti64, tf64, 175 },
+
+ { tu64, tu8, 175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
+ { tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
+ { tu64, tf32, 175 }, { tu64, tf64, 175 },
+
+ { tf32, tu8, 175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
+ { tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
+ { tf32, tf32, 175 }, { tf32, tf64, 175 },
+
+ { tf64, tu8, 175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
+ { tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
+ { tf64, tf32, 175 }, { tf64, tf64, 175 },
+
+ /* value good in u16 and up (41259) */
+ { tu16, tu16, 41259 },
+ { tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
+ { tu16, tf32, 41259 }, { tu16, tf64, 41259 },
+
+ { ti32, tu16, 41259 },
+ { ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
+ { ti32, tf32, 41259 }, { ti32, tf64, 41259 },
+
+ { tu32, tu16, 41259 },
+ { tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
+ { tu32, tf32, 41259 }, { tu32, tf64, 41259 },
+
+ { ti64, tu16, 41259 },
+ { ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
+ { ti64, tf32, 41259 }, { ti64, tf64, 41259 },
+
+ { tu64, tu16, 41259 },
+ { tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
+ { tu64, tf32, 41259 }, { tu64, tf64, 41259 },
+
+ { tf32, tu16, 41259 },
+ { tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
+ { tf32, tf32, 41259 }, { tf32, tf64, 41259 },
+
+ { tf64, tu16, 41259 },
+ { tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
+ { tf64, tf32, 41259 }, { tf64, tf64, 41259 },
+
+ /* value good in u32 and up (3758096384) */
+ { tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
+ { tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
+
+ { ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
+ { ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
+
+ { tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
+ { tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
+
+ { tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
+ { tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
+
+ { tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
+ { tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
+
+ /* value good in u64 and up (16717361816799281152) */
+ { tu64, tu64, 16717361816799281152 },
+ { tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
+
+ { tf32, tu64, 16717361816799281152 },
+ { tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
+
+ { tf64, tu64, 16717361816799281152 },
+ { tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
+}
+
+func main() {
+ for i:=0; i<len(x); i++ {
+ v := x[i].val // input value
+ w := big(0) // output value
+ f := x[i].from // input type
+ t := x[i].to // output type
+
+ i8 = 0; u8 = 0; i16 = 0; u16 = 0
+ i32 = 0; u32 = 0; i64 = 0; u64 = 0
+ f32 = 0; f64 = 0
+
+ switch f*100 + t {
+ default:
+ println("missing case", i, v, f, t)
+ w = v
+
+ case ti8*100 + ti8:
+ i8 = int8(v); i8 = int8(i8); w = big(i8)
+ case ti8*100 + tu8:
+ i8 = int8(v); u8 = uint8(i8); w = big(u8)
+ case ti8*100 + ti16:
+ i8 = int8(v); i16 = int16(i8); w = big(i16)
+ case ti8*100 + tu16:
+ i8 = int8(v); u16 = uint16(i8); w = big(u16)
+ case ti8*100 + ti32:
+ i8 = int8(v); i32 = int32(i8); w = big(i32)
+ case ti8*100 + tu32:
+ i8 = int8(v); u32 = uint32(i8); w = big(u32)
+ case ti8*100 + ti64:
+ i8 = int8(v); i64 = int64(i8); w = big(i64)
+ case ti8*100 + tu64:
+ i8 = int8(v); u64 = uint64(i8); w = big(u64)
+ case ti8*100 + tf32:
+ i8 = int8(v); f32 = float32(i8); w = big(f32)
+ case ti8*100 + tf64:
+ i8 = int8(v); f64 = float64(i8); w = big(f64)
+
+ case tu8*100 + ti8:
+ u8 = uint8(v); i8 = int8(u8); w = big(i8)
+ case tu8*100 + tu8:
+ u8 = uint8(v); u8 = uint8(u8); w = big(u8)
+ case tu8*100 + ti16:
+ u8 = uint8(v); i16 = int16(u8); w = big(i16)
+ case tu8*100 + tu16:
+ u8 = uint8(v); u16 = uint16(u8); w = big(u16)
+ case tu8*100 + ti32:
+ u8 = uint8(v); i32 = int32(u8); w = big(i32)
+ case tu8*100 + tu32:
+ u8 = uint8(v); u32 = uint32(u8); w = big(u32)
+ case tu8*100 + ti64:
+ u8 = uint8(v); i64 = int64(u8); w = big(i64)
+ case tu8*100 + tu64:
+ u8 = uint8(v); u64 = uint64(u8); w = big(u64)
+ case tu8*100 + tf32:
+ u8 = uint8(v); f32 = float32(u8); w = big(f32)
+ case tu8*100 + tf64:
+ u8 = uint8(v); f64 = float64(u8); w = big(f64)
+
+ case ti16*100 + ti8:
+ i16 = int16(v); i8 = int8(i16); w = big(i8)
+ case ti16*100 + tu8:
+ i16 = int16(v); u8 = uint8(i16); w = big(u8)
+ case ti16*100 + ti16:
+ i16 = int16(v); i16 = int16(i16); w = big(i16)
+ case ti16*100 + tu16:
+ i16 = int16(v); u16 = uint16(i16); w = big(u16)
+ case ti16*100 + ti32:
+ i16 = int16(v); i32 = int32(i16); w = big(i32)
+ case ti16*100 + tu32:
+ i16 = int16(v); u32 = uint32(i16); w = big(u32)
+ case ti16*100 + ti64:
+ i16 = int16(v); i64 = int64(i16); w = big(i64)
+ case ti16*100 + tu64:
+ i16 = int16(v); u64 = uint64(i16); w = big(u64)
+ case ti16*100 + tf32:
+ i16 = int16(v); f32 = float32(i16); w = big(f32)
+ case ti16*100 + tf64:
+ i16 = int16(v); f64 = float64(i16); w = big(f64)
+
+ case tu16*100 + ti8:
+ u16 = uint16(v); i8 = int8(u16); w = big(i8)
+ case tu16*100 + tu8:
+ u16 = uint16(v); u8 = uint8(u16); w = big(u8)
+ case tu16*100 + ti16:
+ u16 = uint16(v); i16 = int16(u16); w = big(i16)
+ case tu16*100 + tu16:
+ u16 = uint16(v); u16 = uint16(u16); w = big(u16)
+ case tu16*100 + ti32:
+ u16 = uint16(v); i32 = int32(u16); w = big(i32)
+ case tu16*100 + tu32:
+ u16 = uint16(v); u32 = uint32(u16); w = big(u32)
+ case tu16*100 + ti64:
+ u16 = uint16(v); i64 = int64(u16); w = big(i64)
+ case tu16*100 + tu64:
+ u16 = uint16(v); u64 = uint64(u16); w = big(u64)
+ case tu16*100 + tf32:
+ u16 = uint16(v); f32 = float32(u16); w = big(f32)
+ case tu16*100 + tf64:
+ u16 = uint16(v); f64 = float64(u16); w = big(f64)
+
+ case ti32*100 + ti8:
+ i32 = int32(v); i8 = int8(i32); w = big(i8)
+ case ti32*100 + tu8:
+ i32 = int32(v); u8 = uint8(i32); w = big(u8)
+ case ti32*100 + ti16:
+ i32 = int32(v); i16 = int16(i32); w = big(i16)
+ case ti32*100 + tu16:
+ i32 = int32(v); u16 = uint16(i32); w = big(u16)
+ case ti32*100 + ti32:
+ i32 = int32(v); i32 = int32(i32); w = big(i32)
+ case ti32*100 + tu32:
+ i32 = int32(v); u32 = uint32(i32); w = big(u32)
+ case ti32*100 + ti64:
+ i32 = int32(v); i64 = int64(i32); w = big(i64)
+ case ti32*100 + tu64:
+ i32 = int32(v); u64 = uint64(i32); w = big(u64)
+ case ti32*100 + tf32:
+ i32 = int32(v); f32 = float32(i32); w = big(f32)
+ case ti32*100 + tf64:
+ i32 = int32(v); f64 = float64(i32); w = big(f64)
+
+ case tu32*100 + ti8:
+ u32 = uint32(v); i8 = int8(u32); w = big(i8)
+ case tu32*100 + tu8:
+ u32 = uint32(v); u8 = uint8(u32); w = big(u8)
+ case tu32*100 + ti16:
+ u32 = uint32(v); i16 = int16(u32); w = big(i16)
+ case tu32*100 + tu16:
+ u32 = uint32(v); u16 = uint16(u32); w = big(u16)
+ case tu32*100 + ti32:
+ u32 = uint32(v); i32 = int32(u32); w = big(i32)
+ case tu32*100 + tu32:
+ u32 = uint32(v); u32 = uint32(u32); w = big(u32)
+ case tu32*100 + ti64:
+ u32 = uint32(v); i64 = int64(u32); w = big(i64)
+ case tu32*100 + tu64:
+ u32 = uint32(v); u64 = uint64(u32); w = big(u64)
+ case tu32*100 + tf32:
+ u32 = uint32(v); f32 = float32(u32); w = big(f32)
+ case tu32*100 + tf64:
+ u32 = uint32(v); f64 = float64(u32); w = big(f64)
+
+ case ti64*100 + ti8:
+ i64 = int64(v); i8 = int8(i64); w = big(i8)
+ case ti64*100 + tu8:
+ i64 = int64(v); u8 = uint8(i64); w = big(u8)
+ case ti64*100 + ti16:
+ i64 = int64(v); i16 = int16(i64); w = big(i16)
+ case ti64*100 + tu16:
+ i64 = int64(v); u16 = uint16(i64); w = big(u16)
+ case ti64*100 + ti32:
+ i64 = int64(v); i32 = int32(i64); w = big(i32)
+ case ti64*100 + tu32:
+ i64 = int64(v); u32 = uint32(i64); w = big(u32)
+ case ti64*100 + ti64:
+ i64 = int64(v); i64 = int64(i64); w = big(i64)
+ case ti64*100 + tu64:
+ i64 = int64(v); u64 = uint64(i64); w = big(u64)
+ case ti64*100 + tf32:
+ i64 = int64(v); f32 = float32(i64); w = big(f32)
+ case ti64*100 + tf64:
+ i64 = int64(v); f64 = float64(i64); w = big(f64)
+
+ case tu64*100 + ti8:
+ u64 = uint64(v); i8 = int8(u64); w = big(i8)
+ case tu64*100 + tu8:
+ u64 = uint64(v); u8 = uint8(u64); w = big(u8)
+ case tu64*100 + ti16:
+ u64 = uint64(v); i16 = int16(u64); w = big(i16)
+ case tu64*100 + tu16:
+ u64 = uint64(v); u16 = uint16(u64); w = big(u16)
+ case tu64*100 + ti32:
+ u64 = uint64(v); i32 = int32(u64); w = big(i32)
+ case tu64*100 + tu32:
+ u64 = uint64(v); u32 = uint32(u64); w = big(u32)
+ case tu64*100 + ti64:
+ u64 = uint64(v); i64 = int64(u64); w = big(i64)
+ case tu64*100 + tu64:
+ u64 = uint64(v); u64 = uint64(u64); w = big(u64)
+ case tu64*100 + tf32:
+ u64 = uint64(v); f32 = float32(u64); w = big(f32)
+ case tu64*100 + tf64:
+ u64 = uint64(v); f64 = float64(u64); w = big(f64)
+
+ case tf32*100 + ti8:
+ f32 = float32(v); i8 = int8(f32); w = big(i8)
+ case tf32*100 + tu8:
+ f32 = float32(v); u8 = uint8(f32); w = big(u8)
+ case tf32*100 + ti16:
+ f32 = float32(v); i16 = int16(f32); w = big(i16)
+ case tf32*100 + tu16:
+ f32 = float32(v); u16 = uint16(f32); w = big(u16)
+ case tf32*100 + ti32:
+ f32 = float32(v); i32 = int32(f32); w = big(i32)
+ case tf32*100 + tu32:
+ f32 = float32(v); u32 = uint32(f32); w = big(u32)
+ case tf32*100 + ti64:
+ f32 = float32(v); i64 = int64(f32); w = big(i64)
+ case tf32*100 + tu64:
+ f32 = float32(v); u64 = uint64(f32); w = big(u64)
+ case tf32*100 + tf32:
+ f32 = float32(v); f32 = float32(f32); w = big(f32)
+ case tf32*100 + tf64:
+ f32 = float32(v); f64 = float64(f32); w = big(f64)
+
+ case tf64*100 + ti8:
+ f64 = float64(v); i8 = int8(f64); w = big(i8)
+ case tf64*100 + tu8:
+ f64 = float64(v); u8 = uint8(f64); w = big(u8)
+ case tf64*100 + ti16:
+ f64 = float64(v); i16 = int16(f64); w = big(i16)
+ case tf64*100 + tu16:
+ f64 = float64(v); u16 = uint16(f64); w = big(u16)
+ case tf64*100 + ti32:
+ f64 = float64(v); i32 = int32(f64); w = big(i32)
+ case tf64*100 + tu32:
+ f64 = float64(v); u32 = uint32(f64); w = big(u32)
+ case tf64*100 + ti64:
+ f64 = float64(v); i64 = int64(f64); w = big(i64)
+ case tf64*100 + tu64:
+ f64 = float64(v); u64 = uint64(f64); w = big(u64)
+ case tf64*100 + tf32:
+ f64 = float64(v); f32 = float32(f64); w = big(f32)
+ case tf64*100 + tf64:
+ f64 = float64(v); f64 = float64(f64); w = big(f64)
+ }
+ if v != w { println(i, v, w, f, t) }
+ }
+}
diff --git a/test/ken/cplx0.go b/test/ken/cplx0.go
new file mode 100644
index 0000000..5d78dc0
--- /dev/null
+++ b/test/ken/cplx0.go
@@ -0,0 +1,30 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test trivial, bootstrap-level complex numbers, including printing.
+
+package main
+
+const (
+ R = 5
+ I = 6i
+
+ C1 = R + I // ADD(5,6)
+)
+
+func doprint(c complex128) { println(c) }
+
+func main() {
+
+ // constants
+ println(C1)
+ doprint(C1)
+
+ // variables
+ c1 := C1
+ println(c1)
+ doprint(c1)
+}
diff --git a/test/ken/cplx0.out b/test/ken/cplx0.out
new file mode 100644
index 0000000..7627c28
--- /dev/null
+++ b/test/ken/cplx0.out
@@ -0,0 +1,4 @@
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go
new file mode 100644
index 0000000..78240a5
--- /dev/null
+++ b/test/ken/cplx1.go
@@ -0,0 +1,99 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple arithmetic and assignment for complex numbers.
+
+package main
+
+const (
+ R = 5
+ I = 6i
+
+ C1 = R + I // ADD(5,6)
+)
+
+func main() {
+ var b bool
+
+ // constants
+ b = (5 + 6i) == C1
+ if !b {
+ println("const bool 1", b)
+ panic("fail")
+ }
+
+ b = (5 + 6i) != C1
+ if b {
+ println("const bool 2", b)
+ panic("fail")
+ }
+
+ b = C1 == (5 + 6i)
+ if !b {
+ println("const bool 3", b)
+ panic("fail")
+ }
+
+ b = C1 != (5 + 6i)
+ if b {
+ println("const bool 4", b)
+ panic("fail")
+ }
+
+ // vars passed through parameters
+ booltest(5+6i, true)
+ booltest(5+7i, false)
+ booltest(6+6i, false)
+ booltest(6+9i, false)
+}
+
+func booltest(a complex64, r bool) {
+ var b bool
+
+ b = a == C1
+ if b != r {
+ println("param bool 1", a, b, r)
+ panic("fail")
+ }
+
+ b = a != C1
+ if b == r {
+ println("param bool 2", a, b, r)
+ panic("fail")
+ }
+
+ b = C1 == a
+ if b != r {
+ println("param bool 3", a, b, r)
+ panic("fail")
+ }
+
+ b = C1 != a
+ if b == r {
+ println("param bool 4", a, b, r)
+ panic("fail")
+ }
+
+ if r {
+ if a != C1 {
+ println("param bool 5", a, b, r)
+ panic("fail")
+ }
+ if C1 != a {
+ println("param bool 6", a, b, r)
+ panic("fail")
+ }
+ } else {
+ if a == C1 {
+ println("param bool 6", a, b, r)
+ panic("fail")
+ }
+ if C1 == a {
+ println("param bool 7", a, b, r)
+ panic("fail")
+ }
+ }
+}
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
new file mode 100644
index 0000000..eb1da7b
--- /dev/null
+++ b/test/ken/cplx2.go
@@ -0,0 +1,122 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test arithmetic on complex numbers, including multiplication and division.
+
+package main
+
+const (
+ R = 5
+ I = 6i
+
+ C1 = R + I // ADD(5,6)
+ C2 = R - I // SUB(5,-6)
+ C3 = -(R + I) // ADD(5,6) NEG(-5,-6)
+ C4 = -(R - I) // SUB(5,-6) NEG(-5,6)
+
+ C5 = C1 + R // ADD(10,6)
+ C6 = C1 + I // ADD(5,12)
+
+ Ca = C5 + C6 // ADD(15,18)
+ Cb = C5 - C6 // SUB(5,-6)
+
+ Cc = C5 * C6 // MUL(-22,-150)
+ Cd = C5 / C6 // DIV(0.721893,-0.532544)
+ Ce = Cd * C6 // MUL(10,6) sb C5
+)
+
+func main() {
+
+ var r complex64 = 5 + 0i
+ if r != R {
+ println("opcode 1", r, R)
+ panic("fail")
+ }
+
+ var i complex64 = 6i
+ if i != I {
+ println("opcode 2", i, I)
+ panic("fail")
+ }
+
+ c1 := r + i
+ if c1 != C1 {
+ println("opcode x", c1, C1)
+ panic("fail")
+ }
+
+ c2 := r - i
+ if c2 != C2 {
+ println("opcode x", c2, C2)
+ panic("fail")
+ }
+
+ c3 := -(r + i)
+ if c3 != C3 {
+ println("opcode x", c3, C3)
+ panic("fail")
+ }
+
+ c4 := -(r - i)
+ if c4 != C4 {
+ println("opcode x", c4, C4)
+ panic("fail")
+ }
+
+ c5 := c1 + r
+ if c5 != C5 {
+ println("opcode x", c5, C5)
+ panic("fail")
+ }
+
+ c6 := c1 + i
+ if c6 != C6 {
+ println("opcode x", c6, C6)
+ panic("fail")
+ }
+
+ ca := c5 + c6
+ if ca != Ca {
+ println("opcode x", ca, Ca)
+ panic("fail")
+ }
+
+ cb := c5 - c6
+ if cb != Cb {
+ println("opcode x", cb, Cb)
+ panic("fail")
+ }
+
+ cc := c5 * c6
+ if cc != Cc {
+ println("opcode x", cc, Cc)
+ panic("fail")
+ }
+
+ cd := c5 / c6
+ if cd != Cd {
+ println("opcode x", cd, Cd)
+ panic("fail")
+ }
+
+ ce := cd * c6
+ if ce != Ce {
+ println("opcode x", ce, Ce)
+ panic("fail")
+ }
+
+ r32 := real(complex64(ce))
+ if r32 != float32(real(Ce)) {
+ println("real(complex64(ce))", r32, real(Ce))
+ panic("fail")
+ }
+
+ r64 := real(complex128(ce))
+ if r64 != real(Ce) {
+ println("real(complex128(ce))", r64, real(Ce))
+ panic("fail")
+ }
+}
diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go
new file mode 100644
index 0000000..be0b864
--- /dev/null
+++ b/test/ken/cplx3.go
@@ -0,0 +1,54 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test composition, decomposition, and reflection on complex numbers.
+
+package main
+
+import "unsafe"
+import "reflect"
+
+const (
+ R = 5
+ I = 6i
+
+ C1 = R + I // ADD(5,6)
+)
+
+func main() {
+ c0 := C1
+ c0 = (c0 + c0 + c0) / (c0 + c0 + 3i)
+ r, i := real(c0), imag(c0)
+ d := r - 1.292308
+ if d < 0 {
+ d = - d
+ }
+ if d > 1e-6 {
+ println(r, "!= 1.292308")
+ panic(0)
+ }
+ d = i + 0.1384615
+ if d < 0 {
+ d = - d
+ }
+ if d > 1e-6 {
+ println(i, "!= -0.1384615")
+ panic(0)
+ }
+
+ c := *(*complex128)(unsafe.Pointer(&c0))
+ if c != c0 {
+ println(c, "!=", c)
+ panic(0)
+ }
+
+ var a interface{}
+ switch c := reflect.ValueOf(a); c.Kind() {
+ case reflect.Complex64, reflect.Complex128:
+ v := c.Complex()
+ _, _ = complex128(v), true
+ }
+}
diff --git a/test/ken/cplx4.go b/test/ken/cplx4.go
new file mode 100644
index 0000000..97d5d16
--- /dev/null
+++ b/test/ken/cplx4.go
@@ -0,0 +1,61 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test complex numbers,including fmt support.
+// Used to crash.
+
+package main
+
+import "fmt"
+
+const (
+ R = 5
+ I = 6i
+
+ C1 = R + I // ADD(5,6)
+)
+
+func want(s, w string) {
+ if s != w {
+ panic(s + " != " + w)
+ }
+}
+
+func doprint(c complex128, w string) {
+ s := fmt.Sprintf("%f", c)
+ want(s, w)
+}
+
+func main() {
+
+ // constants
+ s := fmt.Sprintf("%f", -C1)
+ want(s, "(-5.000000-6.000000i)")
+ doprint(C1, "(5.000000+6.000000i)")
+
+ // variables
+ c1 := C1
+ s = fmt.Sprintf("%f", c1)
+ want(s, "(5.000000+6.000000i)")
+ doprint(c1, "(5.000000+6.000000i)")
+
+ // 128
+ c2 := complex128(C1)
+ s = fmt.Sprintf("%G", c2)
+ want(s, "(5+6i)")
+
+ // real, imag, complex
+ c3 := complex(real(c2)+3, imag(c2)-5) + c2
+ s = fmt.Sprintf("%G", c3)
+ want(s, "(13+7i)")
+
+ // compiler used to crash on nested divide
+ c4 := complex(real(c3/2), imag(c3/2))
+ if c4 != c3/2 {
+ fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4)
+ panic(0)
+ }
+}
diff --git a/test/ken/cplx5.go b/test/ken/cplx5.go
new file mode 100644
index 0000000..4e8f443
--- /dev/null
+++ b/test/ken/cplx5.go
@@ -0,0 +1,72 @@
+// run
+
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test compound types made of complex numbers.
+
+package main
+
+var a [12]complex128
+var s []complex128
+var c chan complex128
+var f struct {
+ c complex128
+}
+var m map[complex128]complex128
+
+func main() {
+ // array of complex128
+ for i := 0; i < len(a); i++ {
+ a[i] = complex(float64(i), float64(-i))
+ }
+ if a[5] != 5-5i {
+ panic(a[5])
+ }
+
+ // slice of complex128
+ s = make([]complex128, len(a))
+ for i := 0; i < len(s); i++ {
+ s[i] = a[i]
+ }
+ if s[5] != 5-5i {
+ panic(s[5])
+ }
+
+ // chan
+ c = make(chan complex128)
+ go chantest(c)
+ vc := <-c
+ if vc != 5-5i {
+ panic(vc)
+ }
+
+ // pointer of complex128
+ v := a[5]
+ pv := &v
+ if *pv != 5-5i {
+ panic(*pv)
+ }
+
+ // field of complex128
+ f.c = a[5]
+ if f.c != 5-5i {
+ panic(f.c)
+ }
+
+ // map of complex128
+ m = make(map[complex128]complex128)
+ for i := 0; i < len(s); i++ {
+ m[-a[i]] = a[i]
+ }
+ if m[5i-5] != 5-5i {
+ panic(m[5i-5])
+ }
+ vm := m[complex(-5, 5)]
+ if vm != 5-5i {
+ panic(vm)
+ }
+}
+
+func chantest(c chan complex128) { c <- a[5] }
diff --git a/test/ken/divconst.go b/test/ken/divconst.go
new file mode 100644
index 0000000..670e074
--- /dev/null
+++ b/test/ken/divconst.go
@@ -0,0 +1,634 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test integer division by constants.
+
+package main
+
+import "math/rand"
+
+const Count = 1e5
+
+func i64rand() int64 {
+ for {
+ a := int64(rand.Uint32())
+ a = (a << 32) | int64(rand.Uint32())
+ a >>= uint(rand.Intn(64))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i64test(a, b, c int64) {
+ d := a / c
+ if d != b {
+ println("i64", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i64run() {
+ var a, b int64
+
+ for i := 0; i < Count; i++ {
+ a = i64rand()
+
+ b = a / 1
+ i64test(a, b, 1)
+ b = a / 2
+ i64test(a, b, 2)
+ b = a / 3
+ i64test(a, b, 3)
+ b = a / 4
+ i64test(a, b, 4)
+ b = a / 5
+ i64test(a, b, 5)
+ b = a / 6
+ i64test(a, b, 6)
+ b = a / 7
+ i64test(a, b, 7)
+ b = a / 8
+ i64test(a, b, 8)
+ b = a / 10
+ i64test(a, b, 10)
+ b = a / 16
+ i64test(a, b, 16)
+ b = a / 20
+ i64test(a, b, 20)
+ b = a / 32
+ i64test(a, b, 32)
+ b = a / 60
+ i64test(a, b, 60)
+ b = a / 64
+ i64test(a, b, 64)
+ b = a / 128
+ i64test(a, b, 128)
+ b = a / 256
+ i64test(a, b, 256)
+ b = a / 16384
+ i64test(a, b, 16384)
+
+ b = a / -1
+ i64test(a, b, -1)
+ b = a / -2
+ i64test(a, b, -2)
+ b = a / -3
+ i64test(a, b, -3)
+ b = a / -4
+ i64test(a, b, -4)
+ b = a / -5
+ i64test(a, b, -5)
+ b = a / -6
+ i64test(a, b, -6)
+ b = a / -7
+ i64test(a, b, -7)
+ b = a / -8
+ i64test(a, b, -8)
+ b = a / -10
+ i64test(a, b, -10)
+ b = a / -16
+ i64test(a, b, -16)
+ b = a / -20
+ i64test(a, b, -20)
+ b = a / -32
+ i64test(a, b, -32)
+ b = a / -60
+ i64test(a, b, -60)
+ b = a / -64
+ i64test(a, b, -64)
+ b = a / -128
+ i64test(a, b, -128)
+ b = a / -256
+ i64test(a, b, -256)
+ b = a / -16384
+ i64test(a, b, -16384)
+ }
+}
+
+func u64rand() uint64 {
+ a := uint64(rand.Uint32())
+ a = (a << 32) | uint64(rand.Uint32())
+ a >>= uint(rand.Intn(64))
+ return a
+}
+
+func u64test(a, b, c uint64) {
+ d := a / c
+ if d != b {
+ println("u64", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u64run() {
+ var a, b uint64
+
+ for i := 0; i < Count; i++ {
+ a = u64rand()
+
+ b = a / 1
+ u64test(a, b, 1)
+ b = a / 2
+ u64test(a, b, 2)
+ b = a / 3
+ u64test(a, b, 3)
+ b = a / 4
+ u64test(a, b, 4)
+ b = a / 5
+ u64test(a, b, 5)
+ b = a / 6
+ u64test(a, b, 6)
+ b = a / 7
+ u64test(a, b, 7)
+ b = a / 8
+ u64test(a, b, 8)
+ b = a / 10
+ u64test(a, b, 10)
+ b = a / 16
+ u64test(a, b, 16)
+ b = a / 20
+ u64test(a, b, 20)
+ b = a / 32
+ u64test(a, b, 32)
+ b = a / 60
+ u64test(a, b, 60)
+ b = a / 64
+ u64test(a, b, 64)
+ b = a / 128
+ u64test(a, b, 128)
+ b = a / 256
+ u64test(a, b, 256)
+ b = a / 16384
+ u64test(a, b, 16384)
+ }
+}
+
+func i32rand() int32 {
+ for {
+ a := int32(rand.Uint32())
+ a >>= uint(rand.Intn(32))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i32test(a, b, c int32) {
+ d := a / c
+ if d != b {
+ println("i32", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i32run() {
+ var a, b int32
+
+ for i := 0; i < Count; i++ {
+ a = i32rand()
+
+ b = a / 1
+ i32test(a, b, 1)
+ b = a / 2
+ i32test(a, b, 2)
+ b = a / 3
+ i32test(a, b, 3)
+ b = a / 4
+ i32test(a, b, 4)
+ b = a / 5
+ i32test(a, b, 5)
+ b = a / 6
+ i32test(a, b, 6)
+ b = a / 7
+ i32test(a, b, 7)
+ b = a / 8
+ i32test(a, b, 8)
+ b = a / 10
+ i32test(a, b, 10)
+ b = a / 16
+ i32test(a, b, 16)
+ b = a / 20
+ i32test(a, b, 20)
+ b = a / 32
+ i32test(a, b, 32)
+ b = a / 60
+ i32test(a, b, 60)
+ b = a / 64
+ i32test(a, b, 64)
+ b = a / 128
+ i32test(a, b, 128)
+ b = a / 256
+ i32test(a, b, 256)
+ b = a / 16384
+ i32test(a, b, 16384)
+
+ b = a / -1
+ i32test(a, b, -1)
+ b = a / -2
+ i32test(a, b, -2)
+ b = a / -3
+ i32test(a, b, -3)
+ b = a / -4
+ i32test(a, b, -4)
+ b = a / -5
+ i32test(a, b, -5)
+ b = a / -6
+ i32test(a, b, -6)
+ b = a / -7
+ i32test(a, b, -7)
+ b = a / -8
+ i32test(a, b, -8)
+ b = a / -10
+ i32test(a, b, -10)
+ b = a / -16
+ i32test(a, b, -16)
+ b = a / -20
+ i32test(a, b, -20)
+ b = a / -32
+ i32test(a, b, -32)
+ b = a / -60
+ i32test(a, b, -60)
+ b = a / -64
+ i32test(a, b, -64)
+ b = a / -128
+ i32test(a, b, -128)
+ b = a / -256
+ i32test(a, b, -256)
+ }
+}
+
+func u32rand() uint32 {
+ a := uint32(rand.Uint32())
+ a >>= uint(rand.Intn(32))
+ return a
+}
+
+func u32test(a, b, c uint32) {
+ d := a / c
+ if d != b {
+ println("u32", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u32run() {
+ var a, b uint32
+
+ for i := 0; i < Count; i++ {
+ a = u32rand()
+
+ b = a / 1
+ u32test(a, b, 1)
+ b = a / 2
+ u32test(a, b, 2)
+ b = a / 3
+ u32test(a, b, 3)
+ b = a / 4
+ u32test(a, b, 4)
+ b = a / 5
+ u32test(a, b, 5)
+ b = a / 6
+ u32test(a, b, 6)
+ b = a / 7
+ u32test(a, b, 7)
+ b = a / 8
+ u32test(a, b, 8)
+ b = a / 10
+ u32test(a, b, 10)
+ b = a / 16
+ u32test(a, b, 16)
+ b = a / 20
+ u32test(a, b, 20)
+ b = a / 32
+ u32test(a, b, 32)
+ b = a / 60
+ u32test(a, b, 60)
+ b = a / 64
+ u32test(a, b, 64)
+ b = a / 128
+ u32test(a, b, 128)
+ b = a / 256
+ u32test(a, b, 256)
+ b = a / 16384
+ u32test(a, b, 16384)
+ }
+}
+
+func i16rand() int16 {
+ for {
+ a := int16(rand.Uint32())
+ a >>= uint(rand.Intn(16))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i16test(a, b, c int16) {
+ d := a / c
+ if d != b {
+ println("i16", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i16run() {
+ var a, b int16
+
+ for i := 0; i < Count; i++ {
+ a = i16rand()
+
+ b = a / 1
+ i16test(a, b, 1)
+ b = a / 2
+ i16test(a, b, 2)
+ b = a / 3
+ i16test(a, b, 3)
+ b = a / 4
+ i16test(a, b, 4)
+ b = a / 5
+ i16test(a, b, 5)
+ b = a / 6
+ i16test(a, b, 6)
+ b = a / 7
+ i16test(a, b, 7)
+ b = a / 8
+ i16test(a, b, 8)
+ b = a / 10
+ i16test(a, b, 10)
+ b = a / 16
+ i16test(a, b, 16)
+ b = a / 20
+ i16test(a, b, 20)
+ b = a / 32
+ i16test(a, b, 32)
+ b = a / 60
+ i16test(a, b, 60)
+ b = a / 64
+ i16test(a, b, 64)
+ b = a / 128
+ i16test(a, b, 128)
+ b = a / 256
+ i16test(a, b, 256)
+ b = a / 16384
+ i16test(a, b, 16384)
+
+ b = a / -1
+ i16test(a, b, -1)
+ b = a / -2
+ i16test(a, b, -2)
+ b = a / -3
+ i16test(a, b, -3)
+ b = a / -4
+ i16test(a, b, -4)
+ b = a / -5
+ i16test(a, b, -5)
+ b = a / -6
+ i16test(a, b, -6)
+ b = a / -7
+ i16test(a, b, -7)
+ b = a / -8
+ i16test(a, b, -8)
+ b = a / -10
+ i16test(a, b, -10)
+ b = a / -16
+ i16test(a, b, -16)
+ b = a / -20
+ i16test(a, b, -20)
+ b = a / -32
+ i16test(a, b, -32)
+ b = a / -60
+ i16test(a, b, -60)
+ b = a / -64
+ i16test(a, b, -64)
+ b = a / -128
+ i16test(a, b, -128)
+ b = a / -256
+ i16test(a, b, -256)
+ b = a / -16384
+ i16test(a, b, -16384)
+ }
+}
+
+func u16rand() uint16 {
+ a := uint16(rand.Uint32())
+ a >>= uint(rand.Intn(16))
+ return a
+}
+
+func u16test(a, b, c uint16) {
+ d := a / c
+ if d != b {
+ println("u16", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u16run() {
+ var a, b uint16
+
+ for i := 0; i < Count; i++ {
+ a = u16rand()
+
+ b = a / 1
+ u16test(a, b, 1)
+ b = a / 2
+ u16test(a, b, 2)
+ b = a / 3
+ u16test(a, b, 3)
+ b = a / 4
+ u16test(a, b, 4)
+ b = a / 5
+ u16test(a, b, 5)
+ b = a / 6
+ u16test(a, b, 6)
+ b = a / 7
+ u16test(a, b, 7)
+ b = a / 8
+ u16test(a, b, 8)
+ b = a / 10
+ u16test(a, b, 10)
+ b = a / 16
+ u16test(a, b, 16)
+ b = a / 20
+ u16test(a, b, 20)
+ b = a / 32
+ u16test(a, b, 32)
+ b = a / 60
+ u16test(a, b, 60)
+ b = a / 64
+ u16test(a, b, 64)
+ b = a / 128
+ u16test(a, b, 128)
+ b = a / 256
+ u16test(a, b, 256)
+ b = a / 16384
+ u16test(a, b, 16384)
+ }
+}
+
+func i8rand() int8 {
+ for {
+ a := int8(rand.Uint32())
+ a >>= uint(rand.Intn(8))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i8test(a, b, c int8) {
+ d := a / c
+ if d != b {
+ println("i8", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i8run() {
+ var a, b int8
+
+ for i := 0; i < Count; i++ {
+ a = i8rand()
+
+ b = a / 1
+ i8test(a, b, 1)
+ b = a / 2
+ i8test(a, b, 2)
+ b = a / 3
+ i8test(a, b, 3)
+ b = a / 4
+ i8test(a, b, 4)
+ b = a / 5
+ i8test(a, b, 5)
+ b = a / 6
+ i8test(a, b, 6)
+ b = a / 7
+ i8test(a, b, 7)
+ b = a / 8
+ i8test(a, b, 8)
+ b = a / 10
+ i8test(a, b, 10)
+ b = a / 8
+ i8test(a, b, 8)
+ b = a / 20
+ i8test(a, b, 20)
+ b = a / 32
+ i8test(a, b, 32)
+ b = a / 60
+ i8test(a, b, 60)
+ b = a / 64
+ i8test(a, b, 64)
+ b = a / 127
+ i8test(a, b, 127)
+
+ b = a / -1
+ i8test(a, b, -1)
+ b = a / -2
+ i8test(a, b, -2)
+ b = a / -3
+ i8test(a, b, -3)
+ b = a / -4
+ i8test(a, b, -4)
+ b = a / -5
+ i8test(a, b, -5)
+ b = a / -6
+ i8test(a, b, -6)
+ b = a / -7
+ i8test(a, b, -7)
+ b = a / -8
+ i8test(a, b, -8)
+ b = a / -10
+ i8test(a, b, -10)
+ b = a / -8
+ i8test(a, b, -8)
+ b = a / -20
+ i8test(a, b, -20)
+ b = a / -32
+ i8test(a, b, -32)
+ b = a / -60
+ i8test(a, b, -60)
+ b = a / -64
+ i8test(a, b, -64)
+ b = a / -128
+ i8test(a, b, -128)
+ }
+}
+
+func u8rand() uint8 {
+ a := uint8(rand.Uint32())
+ a >>= uint(rand.Intn(8))
+ return a
+}
+
+func u8test(a, b, c uint8) {
+ d := a / c
+ if d != b {
+ println("u8", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u8run() {
+ var a, b uint8
+
+ for i := 0; i < Count; i++ {
+ a = u8rand()
+
+ b = a / 1
+ u8test(a, b, 1)
+ b = a / 2
+ u8test(a, b, 2)
+ b = a / 3
+ u8test(a, b, 3)
+ b = a / 4
+ u8test(a, b, 4)
+ b = a / 5
+ u8test(a, b, 5)
+ b = a / 6
+ u8test(a, b, 6)
+ b = a / 7
+ u8test(a, b, 7)
+ b = a / 8
+ u8test(a, b, 8)
+ b = a / 10
+ u8test(a, b, 10)
+ b = a / 8
+ u8test(a, b, 8)
+ b = a / 20
+ u8test(a, b, 20)
+ b = a / 32
+ u8test(a, b, 32)
+ b = a / 60
+ u8test(a, b, 60)
+ b = a / 64
+ u8test(a, b, 64)
+ b = a / 128
+ u8test(a, b, 128)
+ b = a / 184
+ u8test(a, b, 184)
+ }
+}
+
+func main() {
+ xtest()
+ i64run()
+ u64run()
+ i32run()
+ u32run()
+ i16run()
+ u16run()
+ i8run()
+ u8run()
+}
+
+func xtest() {
+}
diff --git a/test/ken/divmod.go b/test/ken/divmod.go
new file mode 100644
index 0000000..f1bd56e
--- /dev/null
+++ b/test/ken/divmod.go
@@ -0,0 +1,249 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test integer division and modulus.
+
+package main
+
+const (
+ // example from the spec
+ n1 = +5
+ n2 = -5
+ d1 = +3
+ d2 = -3
+
+ q1 = +1
+ q2 = -1
+ q3 = -1
+ q4 = +1
+
+ r1 = +2
+ r2 = -2
+ r3 = +2
+ r4 = -2
+)
+
+func main() {
+ /* ideals */
+ if n1/d1 != q1 || n1%d1 != r1 {
+ println("ideal-1", n1, d1, n1/d1, n1%d1)
+ panic("fail")
+ }
+ if n2/d1 != q2 || n2%d1 != r2 {
+ println("ideal-2", n2, d1, n2/d1, n2%d1)
+ panic("fail")
+ }
+ if n1/d2 != q3 || n1%d2 != r3 {
+ println("ideal-3", n1, d2, n1/d2, n1%d2)
+ panic("fail")
+ }
+ if n2/d2 != q4 || n2%d2 != r4 {
+ println("ideal-4", n2, d2, n2/d2, n2%d2)
+ panic("fail")
+ }
+
+ /* int */
+ var in1 int = +5
+ var in2 int = -5
+ var id1 int = +3
+ var id2 int = -3
+
+ if in1/id1 != q1 || in1%id1 != r1 {
+ println("int-1", in1, id1, in1/id1, in1%id1)
+ panic("fail")
+ }
+ if in2/id1 != q2 || in2%id1 != r2 {
+ println("int-2", in2, id1, in2/id1, in2%id1)
+ panic("fail")
+ }
+ if in1/id2 != q3 || in1%id2 != r3 {
+ println("int-3", in1, id2, in1/id2, in1%id2)
+ panic("fail")
+ }
+ if in2/id2 != q4 || in2%id2 != r4 {
+ println("int-4", in2, id2, in2/id2, in2%id2)
+ panic("fail")
+ }
+
+ /* int8 */
+ var bn1 int8 = +5
+ var bn2 int8 = -5
+ var bd1 int8 = +3
+ var bd2 int8 = -3
+
+ if bn1/bd1 != q1 || bn1%bd1 != r1 {
+ println("int8-1", bn1, bd1, bn1/bd1, bn1%bd1)
+ panic("fail")
+ }
+ if bn2/bd1 != q2 || bn2%bd1 != r2 {
+ println("int8-2", bn2, bd1, bn2/bd1, bn2%bd1)
+ panic("fail")
+ }
+ if bn1/bd2 != q3 || bn1%bd2 != r3 {
+ println("int8-3", bn1, bd2, bn1/bd2, bn1%bd2)
+ panic("fail")
+ }
+ if bn2/bd2 != q4 || bn2%bd2 != r4 {
+ println("int8-4", bn2, bd2, bn2/bd2, bn2%bd2)
+ panic("fail")
+ }
+
+ /* int16 */
+ var sn1 int16 = +5
+ var sn2 int16 = -5
+ var sd1 int16 = +3
+ var sd2 int16 = -3
+
+ if sn1/sd1 != q1 || sn1%sd1 != r1 {
+ println("int16-1", sn1, sd1, sn1/sd1, sn1%sd1)
+ panic("fail")
+ }
+ if sn2/sd1 != q2 || sn2%sd1 != r2 {
+ println("int16-2", sn2, sd1, sn2/sd1, sn2%sd1)
+ panic("fail")
+ }
+ if sn1/sd2 != q3 || sn1%sd2 != r3 {
+ println("int16-3", sn1, sd2, sn1/sd2, sn1%sd2)
+ panic("fail")
+ }
+ if sn2/sd2 != q4 || sn2%sd2 != r4 {
+ println("int16-4", sn2, sd2, sn2/sd2, sn2%sd2)
+ panic("fail")
+ }
+
+ /* int32 */
+ var ln1 int32 = +5
+ var ln2 int32 = -5
+ var ld1 int32 = +3
+ var ld2 int32 = -3
+
+ if ln1/ld1 != q1 || ln1%ld1 != r1 {
+ println("int32-1", ln1, ld1, ln1/ld1, ln1%ld1)
+ panic("fail")
+ }
+ if ln2/ld1 != q2 || ln2%ld1 != r2 {
+ println("int32-2", ln2, ld1, ln2/ld1, ln2%ld1)
+ panic("fail")
+ }
+ if ln1/ld2 != q3 || ln1%ld2 != r3 {
+ println("int32-3", ln1, ld2, ln1/ld2, ln1%ld2)
+ panic("fail")
+ }
+ if ln2/ld2 != q4 || ln2%ld2 != r4 {
+ println("int32-4", ln2, ld2, ln2/ld2, ln2%ld2)
+ panic("fail")
+ }
+
+ /* int64 */
+ var qn1 int64 = +5
+ var qn2 int64 = -5
+ var qd1 int64 = +3
+ var qd2 int64 = -3
+
+ if qn1/qd1 != q1 || qn1%qd1 != r1 {
+ println("int64-1", qn1, qd1, qn1/qd1, qn1%qd1)
+ panic("fail")
+ }
+ if qn2/qd1 != q2 || qn2%qd1 != r2 {
+ println("int64-2", qn2, qd1, qn2/qd1, qn2%qd1)
+ panic("fail")
+ }
+ if qn1/qd2 != q3 || qn1%qd2 != r3 {
+ println("int64-3", qn1, qd2, qn1/qd2, qn1%qd2)
+ panic("fail")
+ }
+ if qn2/qd2 != q4 || qn2%qd2 != r4 {
+ println("int64-4", qn2, qd2, qn2/qd2, qn2%qd2)
+ panic("fail")
+ }
+
+ if n1/qd1 != q1 || n1%qd1 != r1 {
+ println("mixed int64-1", n1, qd1, n1/qd1, n1%qd1)
+ panic("fail")
+ }
+ if n2/qd1 != q2 || n2%qd1 != r2 {
+ println("mixed int64-2", n2, qd1, n2/qd1, n2%qd1)
+ panic("fail")
+ }
+ if n1/qd2 != q3 || n1%qd2 != r3 {
+ println("mixed int64-3", n1, qd2, n1/qd2, n1%qd2)
+ panic("fail")
+ }
+ if n2/qd2 != q4 || n2%qd2 != r4 {
+ println("mixed int64-4", n2, qd2, n2/qd2, n2%qd2)
+ panic("fail")
+ }
+
+ if qn1/d1 != q1 || qn1%d1 != r1 {
+ println("mixed int64-5", qn1, d1, qn1/d1, qn1%d1)
+ panic("fail")
+ }
+ if qn2/d1 != q2 || qn2%d1 != r2 {
+ println("mixed int64-6", qn2, d1, qn2/d1, qn2%d1)
+ panic("fail")
+ }
+ if qn1/d2 != q3 || qn1%d2 != r3 {
+ println("mixed int64-7", qn1, d2, qn1/d2, qn1%d2)
+ panic("fail")
+ }
+ if qn2/d2 != q4 || qn2%d2 != r4 {
+ println("mixed int64-8", qn2, d2, qn2/d2, qn2%d2)
+ panic("fail")
+ }
+
+ /* uint */
+ var uin1 uint = +5
+ var uid1 uint = +3
+
+ if uin1/uid1 != q1 || uin1%uid1 != r1 {
+ println("uint", uin1, uid1, uin1/uid1, uin1%uid1)
+ panic("fail")
+ }
+
+ /* uint8 */
+ var ubn1 uint8 = +5
+ var ubd1 uint8 = +3
+
+ if ubn1/ubd1 != q1 || ubn1%ubd1 != r1 {
+ println("uint8", ubn1, ubd1, ubn1/ubd1, ubn1%ubd1)
+ panic("fail")
+ }
+
+ /* uint16 */
+ var usn1 uint16 = +5
+ var usd1 uint16 = +3
+
+ if usn1/usd1 != q1 || usn1%usd1 != r1 {
+ println("uint16", usn1, usd1, usn1/usd1, usn1%usd1)
+ panic("fail")
+ }
+
+ /* uint32 */
+ var uln1 uint32 = +5
+ var uld1 uint32 = +3
+
+ if uln1/uld1 != q1 || uln1%uld1 != r1 {
+ println("uint32", uln1, uld1, uln1/uld1, uln1%uld1)
+ panic("fail")
+ }
+
+ /* uint64 */
+ var uqn1 uint64 = +5
+ var uqd1 uint64 = +3
+
+ if uqn1/uqd1 != q1 || uqn1%uqd1 != r1 {
+ println("uint64", uqn1, uqd1, uqn1/uqd1, uqn1%uqd1)
+ panic("fail")
+ }
+ if n1/uqd1 != q1 || n1%uqd1 != r1 {
+ println("mixed uint64-1", n1, uqd1, n1/uqd1, n1%uqd1)
+ panic("fail")
+ }
+ if uqn1/d1 != q1 || uqn1%d1 != r1 {
+ println("mixed uint64-2", uqn1, d1, uqn1/d1, uqn1%d1)
+ panic("fail")
+ }
+}
diff --git a/test/ken/embed.go b/test/ken/embed.go
new file mode 100644
index 0000000..f7ca066
--- /dev/null
+++ b/test/ken/embed.go
@@ -0,0 +1,319 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test embedded fields of structs, including methods.
+
+package main
+
+
+type I interface {
+ test1() int
+ test2() int
+ test3() int
+ test4() int
+ test5() int
+ test6() int
+ test7() int
+}
+
+/******
+ ******
+ ******/
+
+type SubpSubp struct {
+ a7 int
+ a int
+}
+
+func (p *SubpSubp) test7() int {
+ if p.a != p.a7 {
+ println("SubpSubp", p, p.a7)
+ panic("fail")
+ }
+ return p.a
+}
+func (p *SubpSubp) testx() { println("SubpSubp", p, p.a7) }
+
+/******
+ ******
+ ******/
+
+type SubpSub struct {
+ a6 int
+ SubpSubp
+ a int
+}
+
+func (p *SubpSub) test6() int {
+ if p.a != p.a6 {
+ println("SubpSub", p, p.a6)
+ panic("fail")
+ }
+ return p.a
+}
+func (p *SubpSub) testx() { println("SubpSub", p, p.a6) }
+
+/******
+ ******
+ ******/
+
+type SubSubp struct {
+ a5 int
+ a int
+}
+
+func (p *SubSubp) test5() int {
+ if p.a != p.a5 {
+ println("SubpSub", p, p.a5)
+ panic("fail")
+ }
+ return p.a
+}
+
+/******
+ ******
+ ******/
+
+type SubSub struct {
+ a4 int
+ a int
+}
+
+func (p *SubSub) test4() int {
+ if p.a != p.a4 {
+ println("SubpSub", p, p.a4)
+ panic("fail")
+ }
+ return p.a
+}
+
+/******
+ ******
+ ******/
+
+type Subp struct {
+ a3 int
+ *SubpSubp
+ SubpSub
+ a int
+}
+
+func (p *Subp) test3() int {
+ if p.a != p.a3 {
+ println("SubpSub", p, p.a3)
+ panic("fail")
+ }
+ return p.a
+}
+
+/******
+ ******
+ ******/
+
+type Sub struct {
+ a2 int
+ *SubSubp
+ SubSub
+ a int
+}
+
+func (p *Sub) test2() int {
+ if p.a != p.a2 {
+ println("SubpSub", p, p.a2)
+ panic("fail")
+ }
+ return p.a
+}
+
+/******
+ ******
+ ******/
+
+type S struct {
+ a1 int
+ Sub
+ *Subp
+ a int
+}
+
+func (p *S) test1() int {
+ if p.a != p.a1 {
+ println("SubpSub", p, p.a1)
+ panic("fail")
+ }
+ return p.a
+}
+
+/******
+ ******
+ ******/
+
+func main() {
+ var i I
+ var s *S
+
+ // allocate
+ s = new(S)
+ s.Subp = new(Subp)
+ s.Sub.SubSubp = new(SubSubp)
+ s.Subp.SubpSubp = new(SubpSubp)
+
+ // explicit assignment
+ s.a = 1
+ s.Sub.a = 2
+ s.Subp.a = 3
+ s.Sub.SubSub.a = 4
+ s.Sub.SubSubp.a = 5
+ s.Subp.SubpSub.a = 6
+ s.Subp.SubpSubp.a = 7
+
+ // embedded (unique) assignment
+ s.a1 = 1
+ s.a2 = 2
+ s.a3 = 3
+ s.a4 = 4
+ s.a5 = 5
+ s.a6 = 6
+ s.a7 = 7
+
+ // unique calls with explicit &
+ if s.test1() != 1 {
+ println("t1", 1)
+ panic("fail")
+ }
+ if (&s.Sub).test2() != 2 {
+ println("t1", 2)
+ panic("fail")
+ }
+ if s.Subp.test3() != 3 {
+ println("t1", 3)
+ panic("fail")
+ }
+ if (&s.Sub.SubSub).test4() != 4 {
+ println("t1", 4)
+ panic("fail")
+ }
+ if s.Sub.SubSubp.test5() != 5 {
+ println("t1", 5)
+ panic("fail")
+ }
+ if (&s.Subp.SubpSub).test6() != 6 {
+ println("t1", 6)
+ panic("fail")
+ }
+ if s.Subp.SubpSubp.test7() != 7 {
+ println("t1", 7)
+ panic("fail")
+ }
+
+ // automatic &
+ if s.Sub.test2() != 2 {
+ println("t2", 2)
+ panic("fail")
+ }
+ if s.Sub.SubSub.test4() != 4 {
+ println("t2", 4)
+ panic("fail")
+ }
+ if s.Subp.SubpSub.test6() != 6 {
+ println("t2", 6)
+ panic("fail")
+ }
+
+ // embedded calls
+ if s.test1() != s.a1 {
+ println("t3", 1)
+ panic("fail")
+ }
+ if s.test2() != s.a2 {
+ println("t3", 2)
+ panic("fail")
+ }
+ if s.test3() != s.a3 {
+ println("t3", 3)
+ panic("fail")
+ }
+ if s.test4() != s.a4 {
+ println("t3", 4)
+ panic("fail")
+ }
+ if s.test5() != s.a5 {
+ println("t3", 5)
+ panic("fail")
+ }
+ if s.test6() != s.a6 {
+ println("t3", 6)
+ panic("fail")
+ }
+ if s.test7() != s.a7 {
+ println("t3", 7)
+ panic("fail")
+ }
+
+ // run it through an interface
+ i = s
+ s = i.(*S)
+
+ // same as t3
+ if s.test1() != s.a1 {
+ println("t4", 1)
+ panic("fail")
+ }
+ if s.test2() != s.a2 {
+ println("t4", 2)
+ panic("fail")
+ }
+ if s.test3() != s.a3 {
+ println("t4", 3)
+ panic("fail")
+ }
+ if s.test4() != s.a4 {
+ println("t4", 4)
+ panic("fail")
+ }
+ if s.test5() != s.a5 {
+ println("t4", 5)
+ panic("fail")
+ }
+ if s.test6() != s.a6 {
+ println("t4", 6)
+ panic("fail")
+ }
+ if s.test7() != s.a7 {
+ println("t4", 7)
+ panic("fail")
+ }
+
+ // call interface
+ if i.test1() != s.test1() {
+ println("t5", 1)
+ panic("fail")
+ }
+ if i.test2() != s.test2() {
+ println("t5", 2)
+ panic("fail")
+ }
+ if i.test3() != s.test3() {
+ println("t5", 3)
+ panic("fail")
+ }
+ if i.test4() != s.test4() {
+ println("t5", 4)
+ panic("fail")
+ }
+ if i.test5() != s.test5() {
+ println("t5", 5)
+ panic("fail")
+ }
+ if i.test6() != s.test6() {
+ println("t5", 6)
+ panic("fail")
+ }
+ if i.test7() != s.test7() {
+ println("t5", 7)
+ panic("fail")
+ }
+}
diff --git a/test/ken/for.go b/test/ken/for.go
new file mode 100644
index 0000000..db35548
--- /dev/null
+++ b/test/ken/for.go
@@ -0,0 +1,19 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple for loop.
+
+package main
+
+func
+main() {
+ var t,i int;
+
+ for i=0; i<100; i=i+1 {
+ t = t+i;
+ }
+ if t != 50*99 { panic(t); }
+}
diff --git a/test/ken/interbasic.go b/test/ken/interbasic.go
new file mode 100644
index 0000000..d8fbb95
--- /dev/null
+++ b/test/ken/interbasic.go
@@ -0,0 +1,184 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test interfaces on basic types.
+
+package main
+
+type myint int
+type mystring string
+type I0 interface{}
+
+func f() {
+ var ia, ib I0
+ var i myint
+ var s mystring
+
+ if ia != ib {
+ panic("1")
+ }
+
+ i = 1
+ ia = i
+ ib = i
+ if ia != ib {
+ panic("2")
+ }
+ if ia == nil {
+ panic("3")
+ }
+
+ i = 2
+ ia = i
+ if ia == ib {
+ panic("4")
+ }
+
+ ia = nil
+ if ia == ib {
+ panic("5")
+ }
+
+ ib = nil
+ if ia != ib {
+ panic("6")
+ }
+
+ if ia != nil {
+ panic("7")
+ }
+
+ s = "abc"
+ ia = s
+ ib = nil
+ if ia == ib {
+ panic("8")
+ }
+
+ s = "def"
+ ib = s
+ if ia == ib {
+ panic("9")
+ }
+
+ s = "abc"
+ ib = s
+ if ia != ib {
+ panic("a")
+ }
+}
+
+func main() {
+ var ia [20]I0
+ var b bool
+ var s string
+ var i8 int8
+ var i16 int16
+ var i32 int32
+ var i64 int64
+ var u8 uint8
+ var u16 uint16
+ var u32 uint32
+ var u64 uint64
+
+ f()
+
+ ia[0] = "xxx"
+ ia[1] = 12345
+ ia[2] = true
+
+ s = "now is"
+ ia[3] = s
+ b = false
+ ia[4] = b
+
+ i8 = 29
+ ia[5] = i8
+ i16 = 994
+ ia[6] = i16
+ i32 = 3434
+ ia[7] = i32
+ i64 = 1234567
+ ia[8] = i64
+
+ u8 = 12
+ ia[9] = u8
+ u16 = 799
+ ia[10] = u16
+ u32 = 4455
+ ia[11] = u32
+ u64 = 765432
+ ia[12] = u64
+
+ s = ia[0].(string)
+ if s != "xxx" {
+ println(0, s)
+ panic("fail")
+ }
+ i32 = int32(ia[1].(int))
+ if i32 != 12345 {
+ println(1, i32)
+ panic("fail")
+ }
+ b = ia[2].(bool)
+ if b != true {
+ println(2, b)
+ panic("fail")
+ }
+
+ s = ia[3].(string)
+ if s != "now is" {
+ println(3, s)
+ panic("fail")
+ }
+ b = ia[4].(bool)
+ if b != false {
+ println(4, b)
+ panic("fail")
+ }
+
+ i8 = ia[5].(int8)
+ if i8 != 29 {
+ println(5, i8)
+ panic("fail")
+ }
+ i16 = ia[6].(int16)
+ if i16 != 994 {
+ println(6, i16)
+ panic("fail")
+ }
+ i32 = ia[7].(int32)
+ if i32 != 3434 {
+ println(7, i32)
+ panic("fail")
+ }
+ i64 = ia[8].(int64)
+ if i64 != 1234567 {
+ println(8, i64)
+ panic("fail")
+ }
+
+ u8 = ia[9].(uint8)
+ if u8 != 12 {
+ println(5, u8)
+ panic("fail")
+ }
+ u16 = ia[10].(uint16)
+ if u16 != 799 {
+ println(6, u16)
+ panic("fail")
+ }
+ u32 = ia[11].(uint32)
+ if u32 != 4455 {
+ println(7, u32)
+ panic("fail")
+ }
+ u64 = ia[12].(uint64)
+ if u64 != 765432 {
+ println(8, u64)
+ panic("fail")
+ }
+}
diff --git a/test/ken/interfun.go b/test/ken/interfun.go
new file mode 100644
index 0000000..9432181
--- /dev/null
+++ b/test/ken/interfun.go
@@ -0,0 +1,59 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test interfaces and methods.
+
+package main
+
+type S struct {
+ a,b int;
+}
+
+type I1 interface {
+ f ()int;
+}
+
+type I2 interface {
+ g() int;
+ f() int;
+}
+
+func (this *S) f()int {
+ return this.a;
+}
+
+func (this *S) g()int {
+ return this.b;
+}
+
+func
+main() {
+ var i1 I1;
+ var i2 I2;
+ var g *S;
+
+ s := new(S);
+ s.a = 5;
+ s.b = 6;
+
+ // call structure
+ if s.f() != 5 { panic(11); }
+ if s.g() != 6 { panic(12); }
+
+ i1 = s; // convert S to I1
+ i2 = i1.(I2); // convert I1 to I2
+
+ // call interface
+ if i1.f() != 5 { panic(21); }
+ if i2.f() != 5 { panic(22); }
+ if i2.g() != 6 { panic(23); }
+
+ g = i1.(*S); // convert I1 to S
+ if g != s { panic(31); }
+
+ g = i2.(*S); // convert I2 to S
+ if g != s { panic(32); }
+}
diff --git a/test/ken/intervar.go b/test/ken/intervar.go
new file mode 100644
index 0000000..8a2fca0
--- /dev/null
+++ b/test/ken/intervar.go
@@ -0,0 +1,69 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test interface assignment.
+
+package main
+
+type Iputs interface {
+ puts (s string) string;
+}
+
+// ---------
+
+type Print struct {
+ whoami int;
+ put Iputs;
+}
+
+func (p *Print) dop() string {
+ r := " print " + string(p.whoami + '0')
+ return r + p.put.puts("abc");
+}
+
+// ---------
+
+type Bio struct {
+ whoami int;
+ put Iputs;
+}
+
+func (b *Bio) puts(s string) string {
+ r := " bio " + string(b.whoami + '0')
+ return r + b.put.puts(s);
+}
+
+// ---------
+
+type File struct {
+ whoami int;
+ put Iputs;
+}
+
+func (f *File) puts(s string) string {
+ return " file " + string(f.whoami + '0') + " -- " + s
+}
+
+func
+main() {
+ p := new(Print);
+ b := new(Bio);
+ f := new(File);
+
+ p.whoami = 1;
+ p.put = b;
+
+ b.whoami = 2;
+ b.put = f;
+
+ f.whoami = 3;
+
+ r := p.dop();
+ expected := " print 1 bio 2 file 3 -- abc"
+ if r != expected {
+ panic(r + " != " + expected)
+ }
+}
diff --git a/test/ken/label.go b/test/ken/label.go
new file mode 100644
index 0000000..fcb3e61
--- /dev/null
+++ b/test/ken/label.go
@@ -0,0 +1,34 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test goto and labels.
+
+package main
+
+func main() {
+ i := 0
+ if false {
+ goto gogoloop
+ }
+ if false {
+ goto gogoloop
+ }
+ if false {
+ goto gogoloop
+ }
+ goto gogoloop
+
+ // backward declared
+loop:
+ i = i + 1
+ if i < 100 {
+ goto loop
+ }
+ return
+
+gogoloop:
+ goto loop
+}
diff --git a/test/ken/litfun.go b/test/ken/litfun.go
new file mode 100644
index 0000000..e241d4e
--- /dev/null
+++ b/test/ken/litfun.go
@@ -0,0 +1,23 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple function literals.
+
+package main
+
+func
+main() {
+ x := func(a int)int {
+ x := func(a int)int {
+ x := func(a int)int {
+ return a+5;
+ };
+ return x(a)+7;
+ };
+ return x(a)+11;
+ };
+ if x(3) != 3+5+7+11 { panic(x(3)); }
+}
diff --git a/test/ken/mfunc.go b/test/ken/mfunc.go
new file mode 100644
index 0000000..ef24991
--- /dev/null
+++ b/test/ken/mfunc.go
@@ -0,0 +1,22 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple multi-argument multi-valued function.
+
+package main
+
+func
+main() {
+ var x,y int;
+
+ x,y = simple(10,20,30);
+ if x+y != 65 { panic(x+y); }
+}
+
+func
+simple(ia,ib,ic int) (oa,ob int) {
+ return ia+5, ib+ic;
+}
diff --git a/test/ken/modconst.go b/test/ken/modconst.go
new file mode 100644
index 0000000..c27bf64
--- /dev/null
+++ b/test/ken/modconst.go
@@ -0,0 +1,634 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test integer modulus by constants.
+
+package main
+
+import "math/rand"
+
+const Count = 1e5
+
+func i64rand() int64 {
+ for {
+ a := int64(rand.Uint32())
+ a = (a << 32) | int64(rand.Uint32())
+ a >>= uint(rand.Intn(64))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i64test(a, b, c int64) {
+ d := a % c
+ if d != b {
+ println("i64", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i64run() {
+ var a, b int64
+
+ for i := 0; i < Count; i++ {
+ a = i64rand()
+
+ b = a % 1
+ i64test(a, b, 1)
+ b = a % 2
+ i64test(a, b, 2)
+ b = a % 3
+ i64test(a, b, 3)
+ b = a % 4
+ i64test(a, b, 4)
+ b = a % 5
+ i64test(a, b, 5)
+ b = a % 6
+ i64test(a, b, 6)
+ b = a % 7
+ i64test(a, b, 7)
+ b = a % 8
+ i64test(a, b, 8)
+ b = a % 10
+ i64test(a, b, 10)
+ b = a % 16
+ i64test(a, b, 16)
+ b = a % 20
+ i64test(a, b, 20)
+ b = a % 32
+ i64test(a, b, 32)
+ b = a % 60
+ i64test(a, b, 60)
+ b = a % 64
+ i64test(a, b, 64)
+ b = a % 128
+ i64test(a, b, 128)
+ b = a % 256
+ i64test(a, b, 256)
+ b = a % 16384
+ i64test(a, b, 16384)
+
+ b = a % -1
+ i64test(a, b, -1)
+ b = a % -2
+ i64test(a, b, -2)
+ b = a % -3
+ i64test(a, b, -3)
+ b = a % -4
+ i64test(a, b, -4)
+ b = a % -5
+ i64test(a, b, -5)
+ b = a % -6
+ i64test(a, b, -6)
+ b = a % -7
+ i64test(a, b, -7)
+ b = a % -8
+ i64test(a, b, -8)
+ b = a % -10
+ i64test(a, b, -10)
+ b = a % -16
+ i64test(a, b, -16)
+ b = a % -20
+ i64test(a, b, -20)
+ b = a % -32
+ i64test(a, b, -32)
+ b = a % -60
+ i64test(a, b, -60)
+ b = a % -64
+ i64test(a, b, -64)
+ b = a % -128
+ i64test(a, b, -128)
+ b = a % -256
+ i64test(a, b, -256)
+ b = a % -16384
+ i64test(a, b, -16384)
+ }
+}
+
+func u64rand() uint64 {
+ a := uint64(rand.Uint32())
+ a = (a << 32) | uint64(rand.Uint32())
+ a >>= uint(rand.Intn(64))
+ return a
+}
+
+func u64test(a, b, c uint64) {
+ d := a % c
+ if d != b {
+ println("u64", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u64run() {
+ var a, b uint64
+
+ for i := 0; i < Count; i++ {
+ a = u64rand()
+
+ b = a % 1
+ u64test(a, b, 1)
+ b = a % 2
+ u64test(a, b, 2)
+ b = a % 3
+ u64test(a, b, 3)
+ b = a % 4
+ u64test(a, b, 4)
+ b = a % 5
+ u64test(a, b, 5)
+ b = a % 6
+ u64test(a, b, 6)
+ b = a % 7
+ u64test(a, b, 7)
+ b = a % 8
+ u64test(a, b, 8)
+ b = a % 10
+ u64test(a, b, 10)
+ b = a % 16
+ u64test(a, b, 16)
+ b = a % 20
+ u64test(a, b, 20)
+ b = a % 32
+ u64test(a, b, 32)
+ b = a % 60
+ u64test(a, b, 60)
+ b = a % 64
+ u64test(a, b, 64)
+ b = a % 128
+ u64test(a, b, 128)
+ b = a % 256
+ u64test(a, b, 256)
+ b = a % 16384
+ u64test(a, b, 16384)
+ }
+}
+
+func i32rand() int32 {
+ for {
+ a := int32(rand.Uint32())
+ a >>= uint(rand.Intn(32))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i32test(a, b, c int32) {
+ d := a % c
+ if d != b {
+ println("i32", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i32run() {
+ var a, b int32
+
+ for i := 0; i < Count; i++ {
+ a = i32rand()
+
+ b = a % 1
+ i32test(a, b, 1)
+ b = a % 2
+ i32test(a, b, 2)
+ b = a % 3
+ i32test(a, b, 3)
+ b = a % 4
+ i32test(a, b, 4)
+ b = a % 5
+ i32test(a, b, 5)
+ b = a % 6
+ i32test(a, b, 6)
+ b = a % 7
+ i32test(a, b, 7)
+ b = a % 8
+ i32test(a, b, 8)
+ b = a % 10
+ i32test(a, b, 10)
+ b = a % 16
+ i32test(a, b, 16)
+ b = a % 20
+ i32test(a, b, 20)
+ b = a % 32
+ i32test(a, b, 32)
+ b = a % 60
+ i32test(a, b, 60)
+ b = a % 64
+ i32test(a, b, 64)
+ b = a % 128
+ i32test(a, b, 128)
+ b = a % 256
+ i32test(a, b, 256)
+ b = a % 16384
+ i32test(a, b, 16384)
+
+ b = a % -1
+ i32test(a, b, -1)
+ b = a % -2
+ i32test(a, b, -2)
+ b = a % -3
+ i32test(a, b, -3)
+ b = a % -4
+ i32test(a, b, -4)
+ b = a % -5
+ i32test(a, b, -5)
+ b = a % -6
+ i32test(a, b, -6)
+ b = a % -7
+ i32test(a, b, -7)
+ b = a % -8
+ i32test(a, b, -8)
+ b = a % -10
+ i32test(a, b, -10)
+ b = a % -16
+ i32test(a, b, -16)
+ b = a % -20
+ i32test(a, b, -20)
+ b = a % -32
+ i32test(a, b, -32)
+ b = a % -60
+ i32test(a, b, -60)
+ b = a % -64
+ i32test(a, b, -64)
+ b = a % -128
+ i32test(a, b, -128)
+ b = a % -256
+ i32test(a, b, -256)
+ }
+}
+
+func u32rand() uint32 {
+ a := uint32(rand.Uint32())
+ a >>= uint(rand.Intn(32))
+ return a
+}
+
+func u32test(a, b, c uint32) {
+ d := a % c
+ if d != b {
+ println("u32", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u32run() {
+ var a, b uint32
+
+ for i := 0; i < Count; i++ {
+ a = u32rand()
+
+ b = a % 1
+ u32test(a, b, 1)
+ b = a % 2
+ u32test(a, b, 2)
+ b = a % 3
+ u32test(a, b, 3)
+ b = a % 4
+ u32test(a, b, 4)
+ b = a % 5
+ u32test(a, b, 5)
+ b = a % 6
+ u32test(a, b, 6)
+ b = a % 7
+ u32test(a, b, 7)
+ b = a % 8
+ u32test(a, b, 8)
+ b = a % 10
+ u32test(a, b, 10)
+ b = a % 16
+ u32test(a, b, 16)
+ b = a % 20
+ u32test(a, b, 20)
+ b = a % 32
+ u32test(a, b, 32)
+ b = a % 60
+ u32test(a, b, 60)
+ b = a % 64
+ u32test(a, b, 64)
+ b = a % 128
+ u32test(a, b, 128)
+ b = a % 256
+ u32test(a, b, 256)
+ b = a % 16384
+ u32test(a, b, 16384)
+ }
+}
+
+func i16rand() int16 {
+ for {
+ a := int16(rand.Uint32())
+ a >>= uint(rand.Intn(16))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i16test(a, b, c int16) {
+ d := a % c
+ if d != b {
+ println("i16", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i16run() {
+ var a, b int16
+
+ for i := 0; i < Count; i++ {
+ a = i16rand()
+
+ b = a % 1
+ i16test(a, b, 1)
+ b = a % 2
+ i16test(a, b, 2)
+ b = a % 3
+ i16test(a, b, 3)
+ b = a % 4
+ i16test(a, b, 4)
+ b = a % 5
+ i16test(a, b, 5)
+ b = a % 6
+ i16test(a, b, 6)
+ b = a % 7
+ i16test(a, b, 7)
+ b = a % 8
+ i16test(a, b, 8)
+ b = a % 10
+ i16test(a, b, 10)
+ b = a % 16
+ i16test(a, b, 16)
+ b = a % 20
+ i16test(a, b, 20)
+ b = a % 32
+ i16test(a, b, 32)
+ b = a % 60
+ i16test(a, b, 60)
+ b = a % 64
+ i16test(a, b, 64)
+ b = a % 128
+ i16test(a, b, 128)
+ b = a % 256
+ i16test(a, b, 256)
+ b = a % 16384
+ i16test(a, b, 16384)
+
+ b = a % -1
+ i16test(a, b, -1)
+ b = a % -2
+ i16test(a, b, -2)
+ b = a % -3
+ i16test(a, b, -3)
+ b = a % -4
+ i16test(a, b, -4)
+ b = a % -5
+ i16test(a, b, -5)
+ b = a % -6
+ i16test(a, b, -6)
+ b = a % -7
+ i16test(a, b, -7)
+ b = a % -8
+ i16test(a, b, -8)
+ b = a % -10
+ i16test(a, b, -10)
+ b = a % -16
+ i16test(a, b, -16)
+ b = a % -20
+ i16test(a, b, -20)
+ b = a % -32
+ i16test(a, b, -32)
+ b = a % -60
+ i16test(a, b, -60)
+ b = a % -64
+ i16test(a, b, -64)
+ b = a % -128
+ i16test(a, b, -128)
+ b = a % -256
+ i16test(a, b, -256)
+ b = a % -16384
+ i16test(a, b, -16384)
+ }
+}
+
+func u16rand() uint16 {
+ a := uint16(rand.Uint32())
+ a >>= uint(rand.Intn(16))
+ return a
+}
+
+func u16test(a, b, c uint16) {
+ d := a % c
+ if d != b {
+ println("u16", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u16run() {
+ var a, b uint16
+
+ for i := 0; i < Count; i++ {
+ a = u16rand()
+
+ b = a % 1
+ u16test(a, b, 1)
+ b = a % 2
+ u16test(a, b, 2)
+ b = a % 3
+ u16test(a, b, 3)
+ b = a % 4
+ u16test(a, b, 4)
+ b = a % 5
+ u16test(a, b, 5)
+ b = a % 6
+ u16test(a, b, 6)
+ b = a % 7
+ u16test(a, b, 7)
+ b = a % 8
+ u16test(a, b, 8)
+ b = a % 10
+ u16test(a, b, 10)
+ b = a % 16
+ u16test(a, b, 16)
+ b = a % 20
+ u16test(a, b, 20)
+ b = a % 32
+ u16test(a, b, 32)
+ b = a % 60
+ u16test(a, b, 60)
+ b = a % 64
+ u16test(a, b, 64)
+ b = a % 128
+ u16test(a, b, 128)
+ b = a % 256
+ u16test(a, b, 256)
+ b = a % 16384
+ u16test(a, b, 16384)
+ }
+}
+
+func i8rand() int8 {
+ for {
+ a := int8(rand.Uint32())
+ a >>= uint(rand.Intn(8))
+ if -a != a {
+ return a
+ }
+ }
+ return 0 // impossible
+}
+
+func i8test(a, b, c int8) {
+ d := a % c
+ if d != b {
+ println("i8", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func i8run() {
+ var a, b int8
+
+ for i := 0; i < Count; i++ {
+ a = i8rand()
+
+ b = a % 1
+ i8test(a, b, 1)
+ b = a % 2
+ i8test(a, b, 2)
+ b = a % 3
+ i8test(a, b, 3)
+ b = a % 4
+ i8test(a, b, 4)
+ b = a % 5
+ i8test(a, b, 5)
+ b = a % 6
+ i8test(a, b, 6)
+ b = a % 7
+ i8test(a, b, 7)
+ b = a % 8
+ i8test(a, b, 8)
+ b = a % 10
+ i8test(a, b, 10)
+ b = a % 8
+ i8test(a, b, 8)
+ b = a % 20
+ i8test(a, b, 20)
+ b = a % 32
+ i8test(a, b, 32)
+ b = a % 60
+ i8test(a, b, 60)
+ b = a % 64
+ i8test(a, b, 64)
+ b = a % 127
+ i8test(a, b, 127)
+
+ b = a % -1
+ i8test(a, b, -1)
+ b = a % -2
+ i8test(a, b, -2)
+ b = a % -3
+ i8test(a, b, -3)
+ b = a % -4
+ i8test(a, b, -4)
+ b = a % -5
+ i8test(a, b, -5)
+ b = a % -6
+ i8test(a, b, -6)
+ b = a % -7
+ i8test(a, b, -7)
+ b = a % -8
+ i8test(a, b, -8)
+ b = a % -10
+ i8test(a, b, -10)
+ b = a % -8
+ i8test(a, b, -8)
+ b = a % -20
+ i8test(a, b, -20)
+ b = a % -32
+ i8test(a, b, -32)
+ b = a % -60
+ i8test(a, b, -60)
+ b = a % -64
+ i8test(a, b, -64)
+ b = a % -128
+ i8test(a, b, -128)
+ b = a % -101
+ i8test(a, b, -101)
+ }
+}
+
+func u8rand() uint8 {
+ a := uint8(rand.Uint32())
+ a >>= uint(rand.Intn(8))
+ return a
+}
+
+func u8test(a, b, c uint8) {
+ d := a % c
+ if d != b {
+ println("u8", a, b, c, d)
+ panic("fail")
+ }
+}
+
+func u8run() {
+ var a, b uint8
+
+ for i := 0; i < Count; i++ {
+ a = u8rand()
+
+ b = a % 1
+ u8test(a, b, 1)
+ b = a % 2
+ u8test(a, b, 2)
+ b = a % 3
+ u8test(a, b, 3)
+ b = a % 4
+ u8test(a, b, 4)
+ b = a % 5
+ u8test(a, b, 5)
+ b = a % 6
+ u8test(a, b, 6)
+ b = a % 7
+ u8test(a, b, 7)
+ b = a % 8
+ u8test(a, b, 8)
+ b = a % 10
+ u8test(a, b, 10)
+ b = a % 8
+ u8test(a, b, 8)
+ b = a % 20
+ u8test(a, b, 20)
+ b = a % 32
+ u8test(a, b, 32)
+ b = a % 60
+ u8test(a, b, 60)
+ b = a % 64
+ u8test(a, b, 64)
+ b = a % 127
+ u8test(a, b, 127)
+ }
+}
+
+func main() {
+ xtest()
+ i64run()
+ u64run()
+ i32run()
+ u32run()
+ i16run()
+ u16run()
+ i8run()
+ u8run()
+}
+
+func xtest() {
+}
diff --git a/test/ken/ptrfun.go b/test/ken/ptrfun.go
new file mode 100644
index 0000000..af806cf
--- /dev/null
+++ b/test/ken/ptrfun.go
@@ -0,0 +1,45 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test method invocation with pointer receivers and function-valued fields.
+
+package main
+
+type C struct {
+ a int;
+ x func(p *C)int;
+}
+
+func (this *C) f()int {
+ return this.a;
+}
+
+func
+main() {
+ var v int;
+ var c *C;
+
+ c = new(C);
+ c.a = 6;
+ c.x = g;
+
+ v = g(c);
+ if v != 6 { panic(v); }
+
+ v = c.x(c);
+ if v != 6 { panic(v); }
+
+ v = c.f();
+ if v != 6 { panic(v); }
+}
+
+func g(p *C)int {
+ var v int;
+
+ v = p.a;
+ if v != 6 { panic(v); }
+ return p.a;
+}
diff --git a/test/ken/ptrvar.go b/test/ken/ptrvar.go
new file mode 100644
index 0000000..d78170c
--- /dev/null
+++ b/test/ken/ptrvar.go
@@ -0,0 +1,54 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test pointers and the . (selector) operator on structs.
+
+package main
+
+type x2 struct { a,b,c int; d int; };
+var g1 x2;
+var g2 struct { a,b,c int; d x2; };
+
+func
+main() {
+ var x int;
+ var s1 *x2;
+ var s2 *struct { a,b,c int; d x2; };
+
+ s1 = &g1;
+ s2 = &g2;
+
+ s1.a = 1;
+ s1.b = 2;
+ s1.c = 3;
+ s1.d = 5;
+
+ s2.a = 7;
+ s2.b = 11;
+ s2.c = 13;
+ s2.d.a = 17;
+ s2.d.b = 19;
+ s2.d.c = 23;
+ s2.d.d = 20;
+
+ if(s2.d.c != 23) { panic(1); }
+ if(g2.d.c != 23) { panic(2); }
+
+ x = s1.a +
+ s1.b +
+ s1.c +
+ s1.d +
+
+ s2.a +
+ s2.b +
+ s2.c +
+ s2.d.a +
+ s2.d.b +
+ s2.d.c +
+ s2.d.d;
+
+ if(x != 121) { panic(x); }
+}
diff --git a/test/ken/range.go b/test/ken/range.go
new file mode 100644
index 0000000..89c14e5
--- /dev/null
+++ b/test/ken/range.go
@@ -0,0 +1,121 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test 'for range' on arrays, slices, and maps.
+
+package main
+
+const size = 16
+
+var a [size]byte
+var p []byte
+var m map[int]byte
+
+func f(k int) byte {
+ return byte(k * 10007 % size)
+}
+
+func init() {
+ p = make([]byte, size)
+ m = make(map[int]byte)
+ for k := 0; k < size; k++ {
+ v := f(k)
+ a[k] = v
+ p[k] = v
+ m[k] = v
+ }
+}
+
+func main() {
+ var i int
+
+ /*
+ * key only
+ */
+ i = 0
+ for k := range a {
+ v := a[k]
+ if v != f(k) {
+ println("key array range", k, v, a[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key array size", i)
+ panic("fail")
+ }
+
+ i = 0
+ for k := range p {
+ v := p[k]
+ if v != f(k) {
+ println("key pointer range", k, v, p[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key pointer size", i)
+ panic("fail")
+ }
+
+ i = 0
+ for k := range m {
+ v := m[k]
+ if v != f(k) {
+ println("key map range", k, v, m[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key map size", i)
+ panic("fail")
+ }
+
+ /*
+ * key,value
+ */
+ i = 0
+ for k, v := range a {
+ if v != f(k) {
+ println("key:value array range", k, v, a[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key:value array size", i)
+ panic("fail")
+ }
+
+ i = 0
+ for k, v := range p {
+ if v != f(k) {
+ println("key:value pointer range", k, v, p[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key:value pointer size", i)
+ panic("fail")
+ }
+
+ i = 0
+ for k, v := range m {
+ if v != f(k) {
+ println("key:value map range", k, v, m[k])
+ panic("fail")
+ }
+ i++
+ }
+ if i != size {
+ println("key:value map size", i)
+ panic("fail")
+ }
+}
diff --git a/test/ken/rob1.go b/test/ken/rob1.go
new file mode 100644
index 0000000..3042a67
--- /dev/null
+++ b/test/ken/rob1.go
@@ -0,0 +1,72 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test general operation using a list implementation.
+
+package main
+
+type Item interface {
+ Print() string
+}
+
+type ListItem struct {
+ item Item
+ next *ListItem
+}
+
+type List struct {
+ head *ListItem
+}
+
+func (list *List) Init() {
+ list.head = nil
+}
+
+func (list *List) Insert(i Item) {
+ item := new(ListItem)
+ item.item = i
+ item.next = list.head
+ list.head = item
+}
+
+func (list *List) Print() string {
+ r := ""
+ i := list.head
+ for i != nil {
+ r += i.item.Print()
+ i = i.next
+ }
+ return r
+}
+
+// Something to put in a list
+type Integer struct {
+ val int
+}
+
+func (this *Integer) Init(i int) *Integer {
+ this.val = i
+ return this
+}
+
+func (this *Integer) Print() string {
+ return string(this.val + '0')
+}
+
+func main() {
+ list := new(List)
+ list.Init()
+ for i := 0; i < 10; i = i + 1 {
+ integer := new(Integer)
+ integer.Init(i)
+ list.Insert(integer)
+ }
+
+ r := list.Print()
+ if r != "9876543210" {
+ panic(r)
+ }
+}
diff --git a/test/ken/rob2.go b/test/ken/rob2.go
new file mode 100644
index 0000000..4b4410e
--- /dev/null
+++ b/test/ken/rob2.go
@@ -0,0 +1,280 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test general operation using s-list.
+// First Go program ever run (although not in this exact form).
+
+package main
+
+import "fmt"
+
+const nilchar = 0
+
+type Atom struct {
+ str string
+ integer int
+ next *Slist /* in hash bucket */
+}
+
+type List struct {
+ car *Slist
+ cdr *Slist
+}
+
+type Slist struct {
+ isatom bool
+ isstring bool
+ //union {
+ atom Atom
+ list List
+ //} u;
+
+}
+
+func (this *Slist) Car() *Slist {
+ return this.list.car
+}
+
+func (this *Slist) Cdr() *Slist {
+ return this.list.cdr
+}
+
+func (this *Slist) String() string {
+ return this.atom.str
+}
+
+func (this *Slist) Integer() int {
+ return this.atom.integer
+}
+
+func (slist *Slist) Free() {
+ if slist == nil {
+ return
+ }
+ if slist.isatom {
+ // free(slist.String());
+ } else {
+ slist.Car().Free()
+ slist.Cdr().Free()
+ }
+ // free(slist);
+}
+
+//Slist* atom(byte *s, int i);
+
+var token int
+var peekc int = -1
+var lineno int32 = 1
+
+var input string
+var inputindex int = 0
+var tokenbuf [100]byte
+var tokenlen int = 0
+
+const EOF int = -1
+
+func main() {
+ var list *Slist
+
+ OpenFile()
+ for {
+ list = Parse()
+ if list == nil {
+ break
+ }
+ r := list.Print()
+ list.Free()
+ if r != "(defn foo (add 12 34))" {
+ panic(r)
+ }
+ break
+ }
+}
+
+func (slist *Slist) PrintOne(doparen bool) string {
+ if slist == nil {
+ return ""
+ }
+ var r string
+ if slist.isatom {
+ if slist.isstring {
+ r = slist.String()
+ } else {
+ r = fmt.Sprintf("%v", slist.Integer())
+ }
+ } else {
+ if doparen {
+ r += "("
+ }
+ r += slist.Car().PrintOne(true)
+ if slist.Cdr() != nil {
+ r += " "
+ r += slist.Cdr().PrintOne(false)
+ }
+ if doparen {
+ r += ")"
+ }
+ }
+ return r
+}
+
+func (slist *Slist) Print() string {
+ return slist.PrintOne(true)
+}
+
+func Get() int {
+ var c int
+
+ if peekc >= 0 {
+ c = peekc
+ peekc = -1
+ } else {
+ c = int(input[inputindex])
+ inputindex++
+ if c == '\n' {
+ lineno = lineno + 1
+ }
+ if c == nilchar {
+ inputindex = inputindex - 1
+ c = EOF
+ }
+ }
+ return c
+}
+
+func WhiteSpace(c int) bool {
+ return c == ' ' || c == '\t' || c == '\r' || c == '\n'
+}
+
+func NextToken() {
+ var i, c int
+
+ tokenbuf[0] = nilchar // clear previous token
+ c = Get()
+ for WhiteSpace(c) {
+ c = Get()
+ }
+ switch c {
+ case EOF:
+ token = EOF
+ case '(', ')':
+ token = c
+ break
+ default:
+ for i = 0; i < 100-1; { // sizeof tokenbuf - 1
+ tokenbuf[i] = byte(c)
+ i = i + 1
+ c = Get()
+ if c == EOF {
+ break
+ }
+ if WhiteSpace(c) || c == ')' {
+ peekc = c
+ break
+ }
+ }
+ if i >= 100-1 { // sizeof tokenbuf - 1
+ panic("atom too long\n")
+ }
+ tokenlen = i
+ tokenbuf[i] = nilchar
+ if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' {
+ token = '0'
+ } else {
+ token = 'A'
+ }
+ }
+}
+
+func Expect(c int) {
+ if token != c {
+ print("parse error: expected ", c, "\n")
+ panic("parse")
+ }
+ NextToken()
+}
+
+// Parse a non-parenthesized list up to a closing paren or EOF
+func ParseList() *Slist {
+ var slist, retval *Slist
+
+ slist = new(Slist)
+ slist.list.car = nil
+ slist.list.cdr = nil
+ slist.isatom = false
+ slist.isstring = false
+
+ retval = slist
+ for {
+ slist.list.car = Parse()
+ if token == ')' || token == EOF { // empty cdr
+ break
+ }
+ slist.list.cdr = new(Slist)
+ slist = slist.list.cdr
+ }
+ return retval
+}
+
+func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)
+ var slist *Slist
+
+ slist = new(Slist)
+ if token == '0' {
+ slist.atom.integer = i
+ slist.isstring = false
+ } else {
+ slist.atom.str = string(tokenbuf[0:tokenlen])
+ slist.isstring = true
+ }
+ slist.isatom = true
+ return slist
+}
+
+func atoi() int { // BUG: uses tokenbuf; should take argument)
+ var v int = 0
+ for i := 0; i < tokenlen && '0' <= tokenbuf[i] && tokenbuf[i] <= '9'; i = i + 1 {
+ v = 10*v + int(tokenbuf[i]-'0')
+ }
+ return v
+}
+
+func Parse() *Slist {
+ var slist *Slist
+
+ if token == EOF || token == ')' {
+ return nil
+ }
+ if token == '(' {
+ NextToken()
+ slist = ParseList()
+ Expect(')')
+ return slist
+ } else {
+ // Atom
+ switch token {
+ case EOF:
+ return nil
+ case '0':
+ slist = atom(atoi())
+ case '"', 'A':
+ slist = atom(0)
+ default:
+ slist = nil
+ print("unknown token: ", token, "\n")
+ }
+ NextToken()
+ return slist
+ }
+ return nil
+}
+
+func OpenFile() {
+ input = "(defn foo (add 12 34))\n\x00"
+ inputindex = 0
+ peekc = -1 // BUG
+ NextToken()
+}
diff --git a/test/ken/robfor.go b/test/ken/robfor.go
new file mode 100644
index 0000000..c6a420b
--- /dev/null
+++ b/test/ken/robfor.go
@@ -0,0 +1,58 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test for loops of many forms.
+
+package main
+
+func assertequal(is, shouldbe int, msg string) {
+ if is != shouldbe {
+ print("assertion fail" + msg + "\n");
+ panic(1);
+ }
+}
+
+func main() {
+ var i, sum int;
+
+ i = 0;
+ for {
+ i = i + 1;
+ if i > 5 {
+ break;
+ }
+ }
+ assertequal(i, 6, "break");
+
+ sum = 0;
+ for i := 0; i <= 10; i++ {
+ sum = sum + i;
+ }
+ assertequal(sum, 55, "all three");
+
+ sum = 0;
+ for i := 0; i <= 10; {
+ sum = sum + i;
+ i++;
+ }
+ assertequal(sum, 55, "only two");
+
+ sum = 0;
+ for sum < 100 {
+ sum = sum + 9;
+ }
+ assertequal(sum, 99 + 9, "only one");
+
+ sum = 0;
+ for i := 0; i <= 10; i++ {
+ if i % 2 == 0 {
+ continue;
+ }
+ sum = sum + i;
+ }
+ assertequal(sum, 1+3+5+7+9, "continue");
+
+}
diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go
new file mode 100644
index 0000000..885267e
--- /dev/null
+++ b/test/ken/robfunc.go
@@ -0,0 +1,96 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test functions of many signatures.
+
+package main
+
+func assertequal(is, shouldbe int, msg string) {
+ if is != shouldbe {
+ print("assertion fail" + msg + "\n")
+ panic(1)
+ }
+}
+
+func f1() {
+}
+
+func f2(a int) {
+}
+
+func f3(a, b int) int {
+ return a + b
+}
+
+func f4(a, b int, c float64) int {
+ return (a+b)/2 + int(c)
+}
+
+func f5(a int) int {
+ return 5
+}
+
+func f6(a int) (r int) {
+ return 6
+}
+
+func f7(a int) (x int, y float64) {
+ return 7, 7.0
+}
+
+
+func f8(a int) (x int, y float64) {
+ return 8, 8.0
+}
+
+type T struct {
+ x, y int
+}
+
+func (t *T) m10(a int, b float64) int {
+ return (t.x + a) * (t.y + int(b))
+}
+
+
+func f9(a int) (in int, fl float64) {
+ i := 9
+ f := float64(9)
+ return i, f
+}
+
+
+func main() {
+ f1()
+ f2(1)
+ r3 := f3(1, 2)
+ assertequal(r3, 3, "3")
+ r4 := f4(0, 2, 3.0)
+ assertequal(r4, 4, "4")
+ r5 := f5(1)
+ assertequal(r5, 5, "5")
+ r6 := f6(1)
+ assertequal(r6, 6, "6")
+ var r7 int
+ var s7 float64
+ r7, s7 = f7(1)
+ assertequal(r7, 7, "r7")
+ assertequal(int(s7), 7, "s7")
+ var r8 int
+ var s8 float64
+ r8, s8 = f8(1)
+ assertequal(r8, 8, "r8")
+ assertequal(int(s8), 8, "s8")
+ var r9 int
+ var s9 float64
+ r9, s9 = f9(1)
+ assertequal(r9, 9, "r9")
+ assertequal(int(s9), 9, "s9")
+ var t *T = new(T)
+ t.x = 1
+ t.y = 2
+ r10 := t.m10(1, 3.0)
+ assertequal(r10, 10, "10")
+}
diff --git a/test/ken/shift.go b/test/ken/shift.go
new file mode 100644
index 0000000..af87896
--- /dev/null
+++ b/test/ken/shift.go
@@ -0,0 +1,121 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test shift.
+
+package main
+
+var ians [18]int;
+var uans [18]uint;
+var pass string;
+
+func
+testi(i int, t1,t2,t3 int) {
+ n := ((t1*3) + t2)*2 + t3;
+ if i != ians[n] {
+ print("itest ", t1,t2,t3,pass,
+ " is ", i, " sb ", ians[n], "\n");
+ }
+}
+
+func
+index(t1,t2,t3 int) int {
+ return ((t1*3) + t2)*2 + t3;
+}
+
+func
+testu(u uint, t1,t2,t3 int) {
+ n := index(t1,t2,t3);
+ if u != uans[n] {
+ print("utest ", t1,t2,t3,pass,
+ " is ", u, " sb ", uans[n], "\n");
+ }
+}
+
+func
+main() {
+ var i int;
+ var u,c uint;
+
+ /*
+ * test constant evaluations
+ */
+ pass = "con"; // constant part
+
+ testi( int(1234) << 0, 0,0,0);
+ testi( int(1234) >> 0, 0,0,1);
+ testi( int(1234) << 5, 0,1,0);
+ testi( int(1234) >> 5, 0,1,1);
+
+ testi(int(-1234) << 0, 1,0,0);
+ testi(int(-1234) >> 0, 1,0,1);
+ testi(int(-1234) << 5, 1,1,0);
+ testi(int(-1234) >> 5, 1,1,1);
+
+ testu(uint(5678) << 0, 2,0,0);
+ testu(uint(5678) >> 0, 2,0,1);
+ testu(uint(5678) << 5, 2,1,0);
+ testu(uint(5678) >> 5, 2,1,1);
+
+ /*
+ * test variable evaluations
+ */
+ pass = "var"; // variable part
+
+ for t1:=0; t1<3; t1++ { // +int, -int, uint
+ for t2:=0; t2<3; t2++ { // 0, +small, +large
+ for t3:=0; t3<2; t3++ { // <<, >>
+ switch t1 {
+ case 0: i = 1234;
+ case 1: i = -1234;
+ case 2: u = 5678;
+ }
+ switch t2 {
+ case 0: c = 0;
+ case 1: c = 5;
+ case 2: c = 1025;
+ }
+ switch t3 {
+ case 0: i <<= c; u <<= c;
+ case 1: i >>= c; u >>= c;
+ }
+ switch t1 {
+ case 0: testi(i,t1,t2,t3);
+ case 1: testi(i,t1,t2,t3);
+ case 2: testu(u,t1,t2,t3);
+ }
+ }
+ }
+ }
+}
+
+func
+init() {
+ /*
+ * set the 'correct' answer
+ */
+
+ ians[index(0,0,0)] = 1234;
+ ians[index(0,0,1)] = 1234;
+ ians[index(0,1,0)] = 39488;
+ ians[index(0,1,1)] = 38;
+ ians[index(0,2,0)] = 0;
+ ians[index(0,2,1)] = 0;
+
+ ians[index(1,0,0)] = -1234;
+ ians[index(1,0,1)] = -1234;
+ ians[index(1,1,0)] = -39488;
+ ians[index(1,1,1)] = -39;
+ ians[index(1,2,0)] = 0;
+ ians[index(1,2,1)] = -1;
+
+ uans[index(2,0,0)] = 5678;
+ uans[index(2,0,1)] = 5678;
+ uans[index(2,1,0)] = 181696;
+ uans[index(2,1,1)] = 177;
+ uans[index(2,2,0)] = 0;
+ uans[index(2,2,1)] = 0;
+}
diff --git a/test/ken/simparray.go b/test/ken/simparray.go
new file mode 100644
index 0000000..0e81a34
--- /dev/null
+++ b/test/ken/simparray.go
@@ -0,0 +1,50 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple operations on arrays.
+
+package main
+
+var b[10] float32;
+
+func
+main() {
+ var a[10] float32;
+
+ for i:=int16(5); i<10; i=i+1 {
+ a[i] = float32(i);
+ }
+
+ s1 := float32(0);
+ for i:=5; i<10; i=i+1 {
+ s1 = s1 + a[i];
+ }
+
+ if s1 != 35 { panic(s1); }
+
+ for i:=int16(5); i<10; i=i+1 {
+ b[i] = float32(i);
+ }
+
+ s2 := float32(0);
+ for i:=5; i<10; i=i+1 {
+ s2 = s2 + b[i];
+ }
+
+ if s2 != 35 { panic(s2); }
+
+ b := new([100]int);
+ for i:=0; i<100; i=i+1 {
+ b[i] = i;
+ }
+
+ s3 := 0;
+ for i:=0; i<100; i=i+1 {
+ s3 = s3+b[i];
+ }
+
+ if s3 != 4950 { panic(s3); }
+}
diff --git a/test/ken/simpbool.go b/test/ken/simpbool.go
new file mode 100644
index 0000000..ab2ecc2
--- /dev/null
+++ b/test/ken/simpbool.go
@@ -0,0 +1,107 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test basic operations on bool.
+
+package main
+
+type s struct {
+ a bool;
+ b bool;
+}
+
+func
+main() {
+ var a,b bool;
+
+ a = true;
+ b = false;
+
+ if !a { panic(1); }
+ if b { panic(2); }
+ if !!!a { panic(3); }
+ if !!b { panic(4); }
+
+ a = !b;
+ if !a { panic(5); }
+ if !!!a { panic(6); }
+
+ var x *s;
+ x = new(s);
+ x.a = true;
+ x.b = false;
+
+ if !x.a { panic(7); }
+ if x.b { panic(8); }
+ if !!!x.a { panic(9); }
+ if !!x.b { panic(10); }
+
+ x.a = !x.b;
+ if !x.a { panic(11); }
+ if !!!x.a { panic(12); }
+
+ /*
+ * test &&
+ */
+ a = true;
+ b = true;
+ if !(a && b) { panic(21); }
+ if a && !b { panic(22); }
+ if !a && b { panic(23); }
+ if !a && !b { panic(24); }
+
+ a = false;
+ b = true;
+ if !(!a && b) { panic(31); }
+ if !a && !b { panic(32); }
+ if a && b { panic(33); }
+ if a && !b { panic(34); }
+
+ a = true;
+ b = false;
+ if !(a && !b) { panic(41); }
+ if a && b { panic(41); }
+ if !a && !b { panic(41); }
+ if !a && b { panic(44); }
+
+ a = false;
+ b = false;
+ if !(!a && !b) { panic(51); }
+ if !a && b { panic(52); }
+ if a && !b { panic(53); }
+ if a && b { panic(54); }
+
+ /*
+ * test ||
+ */
+ a = true;
+ b = true;
+ if !(a || b) { panic(61); }
+ if !(a || !b) { panic(62); }
+ if !(!a || b) { panic(63); }
+ if !a || !b { panic(64); }
+
+ a = false;
+ b = true;
+ if !(!a || b) { panic(71); }
+ if !(!a || !b) { panic(72); }
+ if !(a || b) { panic(73); }
+ if a || !b { panic(74); }
+
+ a = true;
+ b = false;
+ if !(a || !b) { panic(81); }
+ if !(a || b) { panic(82); }
+ if !(!a || !b) { panic(83); }
+ if !a || b { panic(84); }
+
+ a = false;
+ b = false;
+ if !(!a || !b) { panic(91); }
+ if !(!a || b) { panic(92); }
+ if !(a || !b) { panic(93); }
+ if a || b { panic(94); }
+}
diff --git a/test/ken/simpconv.go b/test/ken/simpconv.go
new file mode 100644
index 0000000..22cad2a
--- /dev/null
+++ b/test/ken/simpconv.go
@@ -0,0 +1,30 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple arithmetic conversion.
+
+package main
+
+type vlong int64
+type short int16
+
+func main() {
+ s1 := vlong(0)
+ for i := short(0); i < 10; i = i + 1 {
+ s1 = s1 + vlong(i)
+ }
+ if s1 != 45 {
+ panic(s1)
+ }
+
+ s2 := float64(0)
+ for i := 0; i < 10; i = i + 1 {
+ s2 = s2 + float64(i)
+ }
+ if s2 != 45 {
+ panic(s2)
+ }
+}
diff --git a/test/ken/simpfun.go b/test/ken/simpfun.go
new file mode 100644
index 0000000..e5dc2b2
--- /dev/null
+++ b/test/ken/simpfun.go
@@ -0,0 +1,26 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple functions.
+
+package main
+
+func
+main() {
+ var x int;
+
+ x = fun(10,20,30);
+ if x != 60 { panic(x); }
+}
+
+func
+fun(ia,ib,ic int)int {
+ var o int;
+
+ o = ia+ib+ic;
+ if o != 60 { panic(o); }
+ return o;
+}
diff --git a/test/ken/simpswitch.go b/test/ken/simpswitch.go
new file mode 100644
index 0000000..b28250b
--- /dev/null
+++ b/test/ken/simpswitch.go
@@ -0,0 +1,28 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test simple switch.
+
+package main
+
+func main() {
+ r := ""
+ a := 3
+ for i := 0; i < 10; i = i + 1 {
+ switch i {
+ case 5:
+ r += "five"
+ case a, 7:
+ r += "a"
+ default:
+ r += string(i + '0')
+ }
+ r += "out" + string(i+'0')
+ }
+ if r != "0out01out12out2aout34out4fiveout56out6aout78out89out9" {
+ panic(r)
+ }
+}
diff --git a/test/ken/simpvar.go b/test/ken/simpvar.go
new file mode 100644
index 0000000..c6eefbb
--- /dev/null
+++ b/test/ken/simpvar.go
@@ -0,0 +1,27 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test scoping of variables.
+
+
+package main
+
+var x,y int;
+
+func
+main() {
+
+ x = 15;
+ y = 20;
+ {
+ var x int;
+ x = 25;
+ y = 25;
+ _ = x;
+ }
+ x = x+y;
+ if(x != 40) { panic(x); }
+}
diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go
new file mode 100644
index 0000000..a431983
--- /dev/null
+++ b/test/ken/slicearray.go
@@ -0,0 +1,212 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test basic operations of slices and arrays.
+
+package main
+
+var bx [10]byte
+var by []byte
+var fx [10]float64
+var fy []float64
+var lb, hb int
+var t int
+
+func main() {
+ lb = 0
+ hb = 10
+ by = bx[0:]
+ tstb()
+
+ lb = 0
+ hb = 10
+ fy = fx[0:]
+ tstf()
+
+ // width 1 (byte)
+ lb = 0
+ hb = 10
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:10]
+ tstb()
+ by = bx[lb:]
+ tstb()
+ by = bx[:hb]
+ tstb()
+ by = bx[0:hb]
+ tstb()
+ by = bx[0:10]
+ tstb()
+ by = bx[0:]
+ tstb()
+ by = bx[:10]
+ tstb()
+ by = bx[:]
+ tstb()
+
+ lb = 2
+ hb = 10
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:10]
+ tstb()
+ by = bx[lb:]
+ tstb()
+ by = bx[2:hb]
+ tstb()
+ by = bx[2:10]
+ tstb()
+ by = bx[2:]
+ tstb()
+
+ lb = 0
+ hb = 8
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:8]
+ tstb()
+ by = bx[0:hb]
+ tstb()
+ by = bx[0:8]
+ tstb()
+ by = bx[:8]
+ tstb()
+ by = bx[:hb]
+ tstb()
+
+ lb = 2
+ hb = 8
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:8]
+ tstb()
+ by = bx[2:hb]
+ tstb()
+ by = bx[2:8]
+ tstb()
+
+ // width 8 (float64)
+ lb = 0
+ hb = 10
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:10]
+ tstf()
+ fy = fx[lb:]
+ tstf()
+ fy = fx[:hb]
+ tstf()
+ fy = fx[0:hb]
+ tstf()
+ fy = fx[0:10]
+ tstf()
+ fy = fx[0:]
+ tstf()
+ fy = fx[:10]
+ tstf()
+ fy = fx[:]
+ tstf()
+
+ lb = 2
+ hb = 10
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:10]
+ tstf()
+ fy = fx[lb:]
+ tstf()
+ fy = fx[2:hb]
+ tstf()
+ fy = fx[2:10]
+ tstf()
+ fy = fx[2:]
+ tstf()
+
+ lb = 0
+ hb = 8
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:8]
+ tstf()
+ fy = fx[:hb]
+ tstf()
+ fy = fx[0:hb]
+ tstf()
+ fy = fx[0:8]
+ tstf()
+ fy = fx[:8]
+ tstf()
+
+ lb = 2
+ hb = 8
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:8]
+ tstf()
+ fy = fx[2:hb]
+ tstf()
+ fy = fx[2:8]
+ tstf()
+}
+
+func tstb() {
+ t++
+ if len(by) != hb-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "len=", len(by), "hb-lb=", hb-lb)
+ panic("fail")
+ }
+ if cap(by) != len(bx)-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "cap=", cap(by), "len(bx)-lb=", len(bx)-lb)
+ panic("fail")
+ }
+ for i := lb; i < hb; i++ {
+ if bx[i] != by[i-lb] {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "bx[", i, "]=", bx[i],
+ "by[", i-lb, "]=", by[i-lb])
+ panic("fail")
+ }
+ }
+ by = nil
+}
+
+func tstf() {
+ t++
+ if len(fy) != hb-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "len=", len(fy), "hb-lb=", hb-lb)
+ panic("fail")
+ }
+ if cap(fy) != len(fx)-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "cap=", cap(fy), "len(fx)-lb=", len(fx)-lb)
+ panic("fail")
+ }
+ for i := lb; i < hb; i++ {
+ if fx[i] != fy[i-lb] {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "fx[", i, "]=", fx[i],
+ "fy[", i-lb, "]=", fy[i-lb])
+ panic("fail")
+ }
+ }
+ fy = nil
+}
+
+func init() {
+ for i := 0; i < len(bx); i++ {
+ bx[i] = byte(i + 20)
+ }
+ by = nil
+
+ for i := 0; i < len(fx); i++ {
+ fx[i] = float64(i + 20)
+ }
+ fy = nil
+}
diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go
new file mode 100644
index 0000000..c07c591
--- /dev/null
+++ b/test/ken/sliceslice.go
@@ -0,0 +1,205 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test slicing and re-slicing.
+
+package main
+
+var bx []byte
+var by []byte
+var fx []float64
+var fy []float64
+var lb, hb int
+var t int
+
+func main() {
+
+ // width 1 (byte)
+ lb = 0
+ hb = 10
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:10]
+ tstb()
+ by = bx[lb:]
+ tstb()
+ by = bx[:hb]
+ tstb()
+ by = bx[0:hb]
+ tstb()
+ by = bx[0:10]
+ tstb()
+ by = bx[0:]
+ tstb()
+ by = bx[:10]
+ tstb()
+ by = bx[:]
+ tstb()
+
+ lb = 2
+ hb = 10
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:10]
+ tstb()
+ by = bx[lb:]
+ tstb()
+ by = bx[2:hb]
+ tstb()
+ by = bx[2:10]
+ tstb()
+ by = bx[2:]
+ tstb()
+
+ lb = 0
+ hb = 8
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:8]
+ tstb()
+ by = bx[0:hb]
+ tstb()
+ by = bx[0:8]
+ tstb()
+ by = bx[:8]
+ tstb()
+ by = bx[:hb]
+ tstb()
+
+ lb = 2
+ hb = 8
+ by = bx[lb:hb]
+ tstb()
+ by = bx[lb:8]
+ tstb()
+ by = bx[2:hb]
+ tstb()
+ by = bx[2:8]
+ tstb()
+
+ // width 4 (float64)
+ lb = 0
+ hb = 10
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:10]
+ tstf()
+ fy = fx[lb:]
+ tstf()
+ fy = fx[:hb]
+ tstf()
+ fy = fx[0:hb]
+ tstf()
+ fy = fx[0:10]
+ tstf()
+ fy = fx[0:]
+ tstf()
+ fy = fx[:10]
+ tstf()
+ fy = fx[:]
+ tstf()
+
+ lb = 2
+ hb = 10
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:10]
+ tstf()
+ fy = fx[lb:]
+ tstf()
+ fy = fx[2:hb]
+ tstf()
+ fy = fx[2:10]
+ tstf()
+ fy = fx[2:]
+ tstf()
+
+ lb = 0
+ hb = 8
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:8]
+ tstf()
+ fy = fx[:hb]
+ tstf()
+ fy = fx[0:hb]
+ tstf()
+ fy = fx[0:8]
+ tstf()
+ fy = fx[:8]
+ tstf()
+
+ lb = 2
+ hb = 8
+ fy = fx[lb:hb]
+ tstf()
+ fy = fx[lb:8]
+ tstf()
+ fy = fx[2:hb]
+ tstf()
+ fy = fx[2:8]
+ tstf()
+}
+
+func tstb() {
+ t++
+ if len(by) != hb-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "len=", len(by), "hb-lb=", hb-lb)
+ panic("fail")
+ }
+ if cap(by) != len(bx)-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "cap=", cap(by), "len(bx)-lb=", len(bx)-lb)
+ panic("fail")
+ }
+ for i := lb; i < hb; i++ {
+ if bx[i] != by[i-lb] {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "bx[", i, "]=", bx[i],
+ "by[", i-lb, "]=", by[i-lb])
+ panic("fail")
+ }
+ }
+ by = nil
+}
+
+func tstf() {
+ t++
+ if len(fy) != hb-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "len=", len(fy), "hb-lb=", hb-lb)
+ panic("fail")
+ }
+ if cap(fy) != len(fx)-lb {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "cap=", cap(fy), "len(fx)-lb=", len(fx)-lb)
+ panic("fail")
+ }
+ for i := lb; i < hb; i++ {
+ if fx[i] != fy[i-lb] {
+ println("t=", t, "lb=", lb, "hb=", hb,
+ "fx[", i, "]=", fx[i],
+ "fy[", i-lb, "]=", fy[i-lb])
+ panic("fail")
+ }
+ }
+ fy = nil
+}
+
+func init() {
+ bx = make([]byte, 10)
+ for i := 0; i < len(bx); i++ {
+ bx[i] = byte(i + 20)
+ }
+ by = nil
+
+ fx = make([]float64, 10)
+ for i := 0; i < len(fx); i++ {
+ fx[i] = float64(i + 20)
+ }
+ fy = nil
+}
diff --git a/test/ken/string.go b/test/ken/string.go
new file mode 100644
index 0000000..7bb3cab
--- /dev/null
+++ b/test/ken/string.go
@@ -0,0 +1,114 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test string operations including printing.
+
+package main
+
+func main() {
+ var c string
+
+ a := `abc`
+ b := `xyz`
+
+ /* print a literal */
+ print(`abc`)
+
+ /* print a variable */
+ print(b, "-")
+
+ /* catenate literals */
+ print(`abc`+`xyz`, "-")
+
+ /* catenate variables */
+ print(a+b, "-")
+
+ /* compare literals */
+ if `abc` == `xyz` || `abc` != "abc" || `abc` > `xyz` {
+ panic("compare literals")
+ }
+
+ /* compare variables */
+ if a == b || a != a || a > b {
+ panic("compare variables")
+ }
+
+ /* cat */
+ c = a + b
+ print(c, "-")
+
+ /* catequal */
+ c = a
+ c += b
+ print(c, "-")
+
+ /* clumsy evaluation */
+ c = b
+ c = a + c
+ print(c, "-")
+
+ /* len */
+ if len(c) != 6 {
+ print("len ", len(c))
+ panic("fail")
+ }
+
+ /* index strings */
+ for i := 0; i < len(c); i = i + 1 {
+ if c[i] != (a + b)[i] {
+ print("index ", i, " ", c[i], " ", (a + b)[i])
+ panic("fail")
+ }
+ }
+
+ /* slice strings */
+ print(c[0:3], c[3:])
+
+ print("\n")
+
+ /* create string with integer constant */
+ c = string('x')
+ if c != "x" {
+ panic("create int " + c)
+ }
+
+ /* create string with integer variable */
+ v := 'x'
+ c = string(v)
+ if c != "x" {
+ panic("create int " + c)
+ }
+
+ /* create string with byte array */
+ var z1 [3]byte
+ z1[0] = 'a'
+ z1[1] = 'b'
+ z1[2] = 'c'
+ c = string(z1[0:])
+ if c != "abc" {
+ panic("create byte array " + c)
+ }
+
+ /* create string with int array */
+ var z2 [3]rune
+ z2[0] = 'a'
+ z2[1] = '\u1234'
+ z2[2] = 'c'
+ c = string(z2[0:])
+ if c != "a\u1234c" {
+ panic("create int array " + c)
+ }
+
+ /* create string with byte array pointer */
+ z3 := new([3]byte)
+ z3[0] = 'a'
+ z3[1] = 'b'
+ z3[2] = 'c'
+ c = string(z3[0:])
+ if c != "abc" {
+ panic("create array pointer " + c)
+ }
+}
diff --git a/test/ken/string.out b/test/ken/string.out
new file mode 100644
index 0000000..8bc36bc
--- /dev/null
+++ b/test/ken/string.out
@@ -0,0 +1 @@
+abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz
diff --git a/test/ken/strvar.go b/test/ken/strvar.go
new file mode 100644
index 0000000..4d511fe
--- /dev/null
+++ b/test/ken/strvar.go
@@ -0,0 +1,79 @@
+// run
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test struct-valued variables (not pointers).
+
+package main
+
+type x2 struct { a,b,c int; d int; };
+var g1 x2;
+var g2 struct { a,b,c int; d x2; };
+
+func
+main() {
+ var x int;
+ var s1 *x2;
+ var s2 *struct { a,b,c int; d x2; };
+ var s3 struct { a,b,c int; d x2; };
+
+ s1 = &g1;
+ s2 = &g2;
+
+ s1.a = 1;
+ s1.b = 2;
+ s1.c = 3;
+ s1.d = 5;
+
+ if(s1.c != 3) { panic(s1.c); }
+ if(g1.c != 3) { panic(g1.c); }
+
+ s2.a = 7;
+ s2.b = 11;
+ s2.c = 13;
+ s2.d.a = 17;
+ s2.d.b = 19;
+ s2.d.c = 23;
+ s2.d.d = 29;
+
+ if(s2.d.c != 23) { panic(s2.d.c); }
+ if(g2.d.c != 23) { panic(g2.d.c); }
+
+ x = s1.a +
+ s1.b +
+ s1.c +
+ s1.d +
+
+ s2.a +
+ s2.b +
+ s2.c +
+ s2.d.a +
+ s2.d.b +
+ s2.d.c +
+ s2.d.d;
+
+ if(x != 130) { panic(x); }
+
+ // test an automatic struct
+ s3.a = 7;
+ s3.b = 11;
+ s3.c = 13;
+ s3.d.a = 17;
+ s3.d.b = 19;
+ s3.d.c = 23;
+ s3.d.d = 29;
+
+ if(s3.d.c != 23) { panic(s3.d.c); }
+
+ x = s3.a +
+ s3.b +
+ s3.c +
+ s3.d.a +
+ s3.d.b +
+ s3.d.c +
+ s3.d.d;
+
+ if(x != 119) { panic(x); }
+}