// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

type S struct {
	a []int
}

var s = &S{make([]int, 10)}

func main() {
	s.a[f()] = 1 // 6g used to call f twice here
}

var n int

func f() int {
	if n++; n > 1 {
		println("f twice")
		panic("fail")
	}
	return 0

package main

var digits string;

func putint(buf []byte, i, base, val int, digits string) {
		buf[i] = digits[val];
}

func main() {
}

/*
uetli:~/Source/go1/test gri$ 6g bugs/bug020.go
bugs/bug020.go:7: type of a structure field cannot be an open array
bugs/bug020.go:7: fatal error: width of a dynamic array

// errorcheck

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

func main() {
	// 6g used to compile these as two different
	// hash codes so it missed the duplication
	// and worse, compiled the wrong code
	// for one of them.
	var x interface{};
	switch x.(type) {
	case func(int):

type T struct {
	s string;
}


func main() {
	s := "";
	l1 := len(s);
	var t T;
	l2 := len(t.s);	// BUG: cannot take len() of a string field
	_, _ = l1, l2;
}

/*
uetli:/home/gri/go/test/bugs gri$ 6g bug057.go
bug057.go:14: syntax error

		// unclear why it shouldn't be allowed
	}
	switch tag := 0; tag {
		// empty switch is allowed according to syntax
		// unclear why it shouldn't be allowed
	}
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug127.go 
bug127.go:5: switch statement must have case labels
bug127.go:9: switch statement must have case labels

// compile

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

// Issue 4200: 6g crashes when a type is larger than 4GB.

package main

import "unsafe"

// N=16 on 32-bit arches, 256 on 64-bit arches.
// On 32-bit arches we don't want to test types
// that are over 4GB large.
const N = 1 << unsafe.Sizeof(uintptr(0))

func main() {
	var a *A = &A{0};
	var m *M = &M{0 : 0};  // should be legal to use & here for consistency with other composite constructors (prev. line)
	_, _ = a, m;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug098.go && 6l bug098.6 && 6.out
bug098.go:10: illegal types for operand: AS
	(*MAP[<int32>INT32]<int32>INT32)
	(**MAP[<int32>INT32]<int32>INT32)

// compile

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

// Used to run 6g out of registers.  Issue 2669.

package p

type y struct {
	num int
}

func zzz () {
    k := make([]byte, 10)
	arr := make ([]*y, 0)
    for s := range arr {
        x := make([]byte, 10)
        for i := 0; i < 100 ; i++ {

// license that can be found in the LICENSE file.

package main

type A []int;

func main() {
	a := &A{0};
	b := &A{0, 1};
	_, _ = a, b;
}

/*
uetli:~/Source/go1/test/bugs gri$ 6g bug096.go && 6l bug096.6 && 6.out
Trace/BPT trap
uetli:~/Source/go1/test/bugs gri$
*/

/*
It appears that the first assignment changes the size of A from open
into a fixed array.

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 4156: out of fixed registers when chaining method calls.
// Used to happen with 6g.

package main

type test_i interface {
	Test() test_i
	Result() bool
}

type test_t struct {
}

func newTest() *test_t {
	return &test_t{}
}

type testFn func(string) testFn