Subversion Repositories openrisc

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

type T struct {
        x, y, z int
}

var (
        a, b, c, d, e int
        under_bar int
        longIdentifier1, longIdentifier2, longIdentifier3 int
        t0, t1, t2 T
        s string
        p *int
)


func _() {
        // no spaces around simple or parenthesized expressions
        _ = (a+0)
        _ = a+b
        _ = a+b+c
        _ = a+b-c
        _ = a-b-c
        _ = a+(b*c)
        _ = a+(b/c)
        _ = a-(b%c)
        _ = 1+a
        _ = a+1
        _ = a+b+1
        _ = s[a]
        _ = s[a:]
        _ = s[:b]
        _ = s[1:2]
        _ = s[a:b]
        _ = s[0:len(s)]
        _ = s[0]<<1
        _ = (s[0]<<1)&0xf
        _ = s[0] << 2 | s[1] >> 4
        _ = "foo"+s
        _ = s+"foo"
        _ = 'a'+'b'
        _ = len(s)/2
        _ = len(t0.x)/a

        // spaces around expressions of different precedence or expressions containing spaces
        _ = a + -b
        _ = a - ^b
        _ = a / *p
        _ = a + b*c
        _ = 1 + b*c
        _ = a + 2*c
        _ = a + c*2
        _ = 1 + 2*3
        _ = s[1 : 2*3]
        _ = s[a : b-c]
        _ = s[0:]
        _ = s[a+b]
        _ = s[: b-c]
        _ = s[a+b :]
        _ = a[a<<b+1]
        _ = a[a<<b+1 :]
        _ = s[a+b : len(s)]
        _ = s[len(s) : -a]
        _ = s[a : len(s)+1]
        _ = s[a : len(s)+1]+s

        // spaces around operators with equal or lower precedence than comparisons
        _ = a == b
        _ = a != b
        _ = a > b
        _ = a >= b
        _ = a < b
        _ = a <= b
        _ = a < b && c > d
        _ = a < b || c > d

        // spaces around "long" operands
        _ = a + longIdentifier1
        _ = longIdentifier1 + a
        _ = longIdentifier1 + longIdentifier2 * longIdentifier3
        _ = s + "a longer string"

        // some selected cases
        _ = a + t0.x
        _ = a + t0.x + t1.x * t2.x
        _ = a + b + c + d + e + 2*3
        _ = a + b + c + 2*3 + d + e
        _ = (a+b+c)*2
        _ = a - b + c - d + (a+b+c) + d&e
        _ = under_bar-1
        _ = Open(dpath + "/file", O_WRONLY | O_CREAT, 0666)
        _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)

        // the parser does not restrict expressions that may appear as statements
        true
        42
        "foo"
        x
        (x)
        a+b
        a+b+c
        a+(b*c)
        a+(b/c)
        1+a
        a+1
        s[a]
        x<<1
        (s[0]<<1)&0xf
        "foo"+s
        x == y
        x < y || z > 42
}


func _() {
        _ = a+b
        _ = a+b+c
        _ = a+b*c
        _ = a+(b*c)
        _ = (a+b)*c
        _ = a+(b*c*d)
        _ = a+(b*c+d)

        _ = 1<<x
        _ = -1<<x
        _ = 1<<x-1
        _ = -1<<x-1

        _ = f(a+b)
        _ = f(a+b+c)
        _ = f(a+b*c)
        _ = f(a+(b*c))
        _ = f(1<<x-1, 1<<x-2)

        _ = 1<<d.logWindowSize-1

        buf = make(x, 2*cap(b.buf) + n)

        dst[i*3+2] = dbuf[0]<<2
        dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4

        b.buf = b.buf[0:b.off+m+n]
        b.buf = b.buf[0:b.off+m*n]
        f(b.buf[0:b.off+m+n])

        signed += ' '*8
        tw.octal(header[148:155], chksum)

        _ = x > 0 && i >= 0

        x1, x0 := x>>w2, x&m2
        z0 = t1<<w2+t0
        z1 = (t1+t0>>w2)>>w2
        q1, r1 := x1/d1, x1%d1
        r1 = r1*b2 | x0>>w2
        x1 = (x1<<z)|(x0>>(uint(w)-z))
        x1 = x1<<z | x0>>(uint(w)-z)

        _ = buf[0:len(buf)+1]
        _ = buf[0:n+1]

        a,b = b,a
        a = b+c
        a = b*c+d
        _ = a*b+c
        _ = a-b-c
        _ = a-(b-c)
        _ = a-b*c
        _ = a-(b*c)
        _ = a*b/c
        _ = a/ *b
        _ = x[a|^b]
        _ = x[a/ *b]
        _ = a& ^b
        _ = a+ +b
        _ = a- -b
        _ = x[a*-b]
        _ = x[a+ +b]
        _ = x^y^z
        _ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
        _ = len(longVariableName)*2

        _ = token(matchType + xlength<<lengthShift + xoffset)
}


func f(x int, args ...int) {
        f(0, args...)
        f(1, args)
        f(2, args[0])

        // make sure syntactically legal code remains syntactically legal
        f(3, 42 ...) // a blank must remain between 42 and ...
        f(4, 42. ...)
        f(5, 42....)
        f(6, 42.0 ...)
        f(7, 42.0...)
        f(8, .42 ...)
        f(9, .42...)
        f(10, 42e0 ...)
        f(11, 42e0...)

        _ = 42 .x // a blank must remain between 42 and .x
        _ = 42. .x
        _ = 42..x
        _ = 42.0 .x
        _ = 42.0.x
        _ = .42 .x
        _ = .42.x
        _ = 42e0 .x
        _ = 42e0.x

        // a blank must remain between the binary operator and the 2nd operand
        _ = x/ *y
        _ = x< -1
        _ = x< <-1
        _ = x+ +1
        _ = x- -1
        _ = x& &x
        _ = x& ^x

        _ = f(x/ *y, x< -1, x< <-1, x+ +1, x- -1, x& &x, x& ^x)
}


func _() {
        _ = T{}
        _ = struct{}{}
        _ = [10]T{}
        _ = [...]T{}
        _ = []T{}
        _ = map[int]T{}
}


// one-line structs/interfaces in composite literals (up to a threshold)
func _() {
        _ = struct{}{}
        _ = struct{ x int }{0}
        _ = struct{ x, y, z int }{0, 1, 2}
        _ = struct{ int }{0}
        _ = struct{ s struct { int } }{struct{ int}{0} }
}


func _() {
        // do not modify literals
        _ = "tab1       tab2    tab3    end"  // string contains 3 tabs
        _ = "tab1 tab2 tab3 end"  // same string with 3 blanks - may be unaligned because editors see tabs in strings
        _ = ""  // this comment should be aligned with the one on the previous line
        _ = ``
        _ = `
`
_ = `foo
                bar`
        _ = `three spaces before the end of the line starting here:   
they must not be removed`
}


func _() {
        // smart handling of indentation for multi-line raw strings
        var _ = ``
        var _ = `foo`
        var _ = `foo
bar`


var _ =
        ``
var _ =
        `foo`
var _ =
        // the next line should remain indented
        `foo
bar`


        var _ = // comment
                ``
        var _ = // comment
                `foo`
        var _ = // comment
                // the next line should remain indented
                `foo
bar`


var _ = /* comment */ ``
var _ = /* comment */ `foo`
var _ = /* comment */ `foo
bar`


        var _ = /* comment */
                ``
        var _ = /* comment */
                `foo`
        var _ = /* comment */
                // the next line should remain indented
                `foo
bar`


var board = []int(
        `...........
...........
....●●●....
....●●●....
..●●●●●●●..
..●●●○●●●..
..●●●●●●●..
....●●●....
....●●●....
...........
...........
`)


        var state = S{
                "foo",
                // the next line should remain indented
                `...........
...........
....●●●....
....●●●....
..●●●●●●●..
..●●●○●●●..
..●●●●●●●..
....●●●....
....●●●....
...........
...........
`,
                "bar",
        }
}


func _() {
        // one-line function literals (body is on a single line)
        _ = func() {}
        _ = func() int { return 0 }
        _ = func(x, y int) bool { m := (x+y)/2; return m < 0 }

        // multi-line function literals (body is not on one line)
        _ = func() {
        }
        _ = func() int {
                return 0
        }
        _ = func(x, y int) bool {
                m := (x+y)/2; return x < y }

        f(func() {
        })
        f(func() int {
                return 0
        })
        f(func(x, y int) bool {
                m := (x+y)/2; return x < y })
}


func _() {
        _ = [][]int {
                []int{1},
                []int{1, 2},
                []int{1, 2, 3},
        }
        _ = [][]int {
                {1},
                []int{1, 2},
                []int{1, 2, 3},
        }
        _ = [][]int {
                {1},
                {1, 2},
                {1, 2, 3},
        }
        _ = [][]int {{1}, {1, 2}, {1, 2, 3}}
}


// various multi-line expressions
func _() {
        // do not add extra indentation to multi-line string lists
        _ = "foo" + "bar"
        _ = "foo" +
        "bar" +
        "bah"
        _ = []string {
                "abc" +
                "def",
                "foo" +
                "bar",
        }
}


const _ = F1 +
        `string = "%s";` +
        `ptr = *;` +
        `datafmt.T2 = s ["-" p "-"];`


const _ =
        `datafmt "datafmt";` +
        `default = "%v";` +
        `array = *;` +
        `datafmt.T3 = s  {" " a a / ","};`


const _ = `datafmt "datafmt";` +
`default = "%v";` +
`array = *;` +
`datafmt.T3 = s  {" " a a / ","};`


func _() {
        _ = F1 +
                `string = "%s";` +
                `ptr = *;` +
                `datafmt.T2 = s ["-" p "-"];`

        _ =
                `datafmt "datafmt";` +
                `default = "%v";` +
                `array = *;` +
                `datafmt.T3 = s  {" " a a / ","};`

        _ = `datafmt "datafmt";` +
        `default = "%v";` +
        `array = *;` +
        `datafmt.T3 = s  {" " a a / ","};`
}


func _() {
        // respect source lines in multi-line expressions
        _ = a+
        b+
        c
        _ = a < b ||
                b < a
        _ = "933262154439441526816992388562667004907159682643816214685929" +
        "638952175999932299156089414639761565182862536979208272237582" +
        "51185210916864000000000000000000000000"  // 100!
        _ = "170141183460469231731687303715884105727"  // prime
}


// Alignment after overlong lines
const (
        _ = "991"
        _ = "2432902008176640000"  // 20!
        _ = "933262154439441526816992388562667004907159682643816214685929" +
        "638952175999932299156089414639761565182862536979208272237582" +
        "51185210916864000000000000000000000000"  // 100!
        _ = "170141183460469231731687303715884105727"  // prime
)


// Correct placement of operators and comments in multi-line expressions
func _() {
        _ = a +  // comment
                b +  // comment
                c
        _ = "a" +
                "b" +   // comment
                "c"
        _ = "ba0408" + "7265717569726564"     // field 71, encoding 2, string "required"
}


// Correct placement of terminating comma/closing parentheses in multi-line calls.
func _() {
        f(1,
                2,
                3)
        f(1,
                2,
                3,
        )
        f(1,
                2,
                3)  // comment
        f(1,
                2,
                3,  // comment
        )
        f(1,
                2,
                3)// comment
        f(1,
                2,
                3,// comment
        )
}


// Align comments in multi-line lists of single-line expressions.
var txpix = [NCOL]draw.Color{
        draw.Yellow, // yellow
        draw.Cyan, // cyan
        draw.Green, // lime green
        draw.GreyBlue, // slate
        draw.Red, /* red */
        draw.GreyGreen, /* olive green */
        draw.Blue, /* blue */
        draw.Color(0xFF55AAFF), /* pink */
        draw.Color(0xFFAAFFFF), /* lavender */
        draw.Color(0xBB005DFF), /* maroon */
}


func same(t, u *Time) bool {
        // respect source lines in multi-line expressions
        return t.Year == u.Year &&
                t.Month == u.Month &&
                t.Day == u.Day &&
                t.Hour == u.Hour &&
                t.Minute == u.Minute &&
                t.Second == u.Second &&
                t.Weekday == u.Weekday &&
                t.ZoneOffset == u.ZoneOffset &&
                t.Zone == u.Zone
}


func (p *parser) charClass() {
        // respect source lines in multi-line expressions
        if cc.negate && len(cc.ranges) == 2 &&
                cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
                nl := new(_NotNl)
                p.re.add(nl)
        }
}


func addState(s []state, inst instr, match []int) {
        // handle comments correctly in multi-line expressions
        for i := 0; i < l; i++ {
                if s[i].inst.index() == index && // same instruction
                   s[i].match[0] < pos {        // earlier match already going; leftmost wins
                        return s
                 }
        }
}

func (self *T) foo(x int) *T { return self }

func _() { module.Func1().Func2() }

func _() {
        _ = new(T).
                foo(1).
                        foo(2).
                foo(3)

        _ = new(T).
        foo(1).
        foo(2). // inline comments
        foo(3)

        _ = new(T).foo(1).foo(2).foo(3)

        // handle multiline argument list correctly
        _ = new(T).
        foo(
                1).
                foo(2)

        _ = new(T).foo(
                1).foo(2)

        _ = Array[3 +
4]

        _ = Method(1, 2,
                3)

        _ = new(T).
   foo().
   bar() . (*Type)

        _ = new(T).
foo().
bar().(*Type).
baz()

        _ = new(T).
        foo().
        bar()["idx"]

        _ = new(T).
        foo().
        bar()["idx"]    .
        baz()

        _ = new(T).
        foo().
        bar()[1:2]

        _ = new(T).
        foo().
        bar()[1:2].
        baz()

        _ = new(T).
                Field.
                Array[3+
                4].
                Table ["foo"].
                Blob. (*Type).
        Slices[1:4].
        Method(1, 2,
        3).
                Thingy

        _ = a.b.c
        _ = a.
        b.
        c
        _ = a.b().c
        _ = a.
        b().
        c
        _ = a.b[0].c
        _ = a.
        b[0].
        c
        _ = a.b[0:].c
        _ = a.
        b[0:].
        c
        _ = a.b.(T).c
        _ = a.
        b.
        (T).
        c
}


// Don't introduce extra newlines in strangely formatted expression lists.
func f() {
        // os.Open parameters should remain on two lines
        if writer, err = os.Open(outfile, s.O_WRONLY|os.O_CREATE|
                os.O_TRUNC, 0666); err != nil {
            log.Fatal(err)
        }
}