Subversion Repositories openrisc

// $G -S $D/$F.go | egrep initdone >/dev/null && echo BUG sinit || true

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

package p

// Should be no init func in the assembly.

// All these initializations should be done at link time.

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 }

var (

        zero                      = 2

        one                       = 1

        pi                        = 3.14

        slice                     = []byte{1, 2, 3}

        sliceInt                  = []int{1, 2, 3}

        hello                     = "hello, world"

        bytes                     = []byte("hello, world")

        four, five                = 4, 5

        x, y                      = 0.1, "hello"

        nilslice   []byte         = nil

        nilmap     map[string]int = nil

        nilfunc    func()         = nil

        nilchan    chan int       = nil

        nilptr     *byte          = nil

)

var a = [3]int{1001, 1002, 1003}

var s = S{1101, 1102, 1103}

var c = []int{1201, 1202, 1203}

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 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 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 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,

}

var (

        copy_zero = zero

        copy_one = one

        copy_pi = pi

        copy_slice = slice

        copy_sliceInt = sliceInt

        copy_hello = hello

        copy_bytes = bytes

        copy_four, copy_five = four, five

        copy_x, copy_y = x, y

        copy_nilslice = nilslice

        copy_nilmap = nilmap

        copy_nilfunc = nilfunc

        copy_nilchan = nilchan

        copy_nilptr = nilptr

)

var copy_a = a

var copy_s = s

var copy_c = c

var copy_aa = aa

var copy_as = as

var copy_ac = ac

var copy_sa = sa

var copy_ss = ss

var copy_sc = sc

var copy_ca = ca

var copy_cs = cs

var copy_cc = cc

var copy_answers = answers

var bx bool

var b0 = false

var b1 = true

var fx float32

var f0 = float32(0)

var f1 = float32(1)

var gx float64

var g0 = float64(0)

var g1 = float64(1)

var ix int

var i0 = 0

var i1 = 1

var jx uint

var j0 = uint(0)

var j1 = uint(1)

var cx complex64

var c0 = complex64(0)

var c1 = complex64(1)

var dx complex128

var d0 = complex128(0)

var d1 = complex128(1)

var sx []int

var s0 = []int{0, 0, 0}

var s1 = []int{1, 2, 3}

func fi() int

var ax [10]int

var a0 = [10]int{0, 0, 0}

var a1 = [10]int{1, 2, 3, 4}

type T struct{ X, Y int }

var tx T

var t0 = T{}

var t0a = T{0, 0}

var t0b = T{X: 0}

var t1 = T{X: 1, Y: 2}

var t1a = T{3, 4}

var psx *[]int

var ps0 = &[]int{0, 0, 0}

var ps1 = &[]int{1, 2, 3}

var pax *[10]int

var pa0 = &[10]int{0, 0, 0}

var pa1 = &[10]int{1, 2, 3}

var ptx *T

var pt0 = &T{}

var pt0a = &T{0, 0}

var pt0b = &T{X: 0}

var pt1 = &T{X: 1, Y: 2}

var pt1a = &T{3, 4}

var copy_bx = bx

var copy_b0 = b0

var copy_b1 = b1

var copy_fx = fx

var copy_f0 = f0

var copy_f1 = f1

var copy_gx = gx

var copy_g0 = g0

var copy_g1 = g1

var copy_ix = ix

var copy_i0 = i0

var copy_i1 = i1

var copy_jx = jx

var copy_j0 = j0

var copy_j1 = j1

var copy_cx = cx

var copy_c0 = c0

var copy_c1 = c1

var copy_dx = dx

var copy_d0 = d0

var copy_d1 = d1

var copy_sx = sx

var copy_s0 = s0

var copy_s1 = s1

var copy_ax = ax

var copy_a0 = a0

var copy_a1 = a1

var copy_tx = tx

var copy_t0 = t0

var copy_t0a = t0a

var copy_t0b = t0b

var copy_t1 = t1

var copy_t1a = t1a

var copy_psx = psx

var copy_ps0 = ps0

var copy_ps1 = ps1

var copy_pax = pax

var copy_pa0 = pa0

var copy_pa1 = pa1

var copy_ptx = ptx

var copy_pt0 = pt0

var copy_pt0a = pt0a

var copy_pt0b = pt0b

var copy_pt1 = pt1

var copy_pt1a = pt1a