Subversion Repositories openrisc

// $G $D/$F.go && $L $F.$A && ./$A.out

// 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.

package main

import "runtime"

var c = make(chan int)

func check(a []int) {

        for i := 0; i < len(a); i++ {

                n := <-c

                if n != a[i] {

                        println("want", a[i], "got", n, "at", i)

                        panic("fail")

                }

        }

}

func f() {

        var i, j int

        i = 1

        j = 2

        f := func() {

                c <- i

                i = 4

                g := func() {

                        c <- i

                        c <- j

                }

                g()

                c <- i

        }

        j = 5

        f()

}

// Accumulator generator

func accum(n int) func(int) int {

        return func(i int) int {

                n += i

                return n

        }

}

func g(a, b func(int) int) {

        c <- a(2)

        c <- b(3)

        c <- a(4)

        c <- b(5)

}

func h() {

        var x8 byte = 100

        var x64 int64 = 200

        c <- int(x8)

        c <- int(x64)

        f := func(z int) {

                g := func() {

                        c <- int(x8)

                        c <- int(x64)

                        c <- z

                }

                g()

                c <- int(x8)

                c <- int(x64)

                c <- int(z)

        }

        x8 = 101

        x64 = 201

        f(500)

}

func newfunc() func(int) int { return func(x int) int { return x } }

func main() {

        var fail bool

        go f()

        check([]int{1, 4, 5, 4})

        a := accum(0)

        b := accum(1)

        go g(a, b)

        check([]int{2, 4, 6, 9})

        go h()

        check([]int{100, 200, 101, 201, 500, 101, 201, 500})

        runtime.UpdateMemStats()

        n0 := runtime.MemStats.Mallocs

        x, y := newfunc(), newfunc()

        if x(1) != 1 || y(2) != 2 {

                println("newfunc returned broken funcs")

                fail = true

        }

        runtime.UpdateMemStats()

        if n0 != runtime.MemStats.Mallocs {

                println("newfunc allocated unexpectedly")

                fail = true

        }

        ff(1)

        if fail {

                panic("fail")

        }

}

func ff(x int) {

        call(func() {

                _ = x

        })

}

func call(func()) {

}