mirror of https://github.com/k3s-io/k3s
716 lines
12 KiB
Plaintext
716 lines
12 KiB
Plaintext
// 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)
|
|
|
|
// test case for issue 8021
|
|
// want:
|
|
// ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
|
|
_ = ([]bool{})[([]int{})[((1) + (((((1) + (((((((1) * (((((1) + (1))) + (1))))) + (1))) * (1))))) + (1))))]]
|
|
|
|
// 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
|
|
}
|
|
|
|
|
|
// slice expressions with cap
|
|
func _() {
|
|
_ = x[a:b:c]
|
|
_ = x[a:b:c+d]
|
|
_ = x[a:b+d:c]
|
|
_ = x[a:b+d:c+d]
|
|
_ = x[a+d:b:c]
|
|
_ = x[a+d:b:c+d]
|
|
_ = x[a+d:b+d:c]
|
|
_ = x[a+d:b+d:c+d]
|
|
|
|
_ = x[:b:c]
|
|
_ = x[:b:c+d]
|
|
_ = x[:b+d:c]
|
|
_ = x[:b+d:c+d]
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
// Handle multi-line argument lists ending in ... correctly.
|
|
// Was issue 3130.
|
|
func _() {
|
|
_ = append(s, a...)
|
|
_ = append(
|
|
s, a...)
|
|
_ = append(s,
|
|
a...)
|
|
_ = append(
|
|
s,
|
|
a...)
|
|
_ = append(s, a...,
|
|
)
|
|
_ = append(s,
|
|
a...,
|
|
)
|
|
_ = append(
|
|
s,
|
|
a...,
|
|
)
|
|
}
|
|
|
|
// Literal function types in conversions must be parenthesized;
|
|
// for now go/parser accepts the unparenthesized form where it
|
|
// is non-ambiguous.
|
|
func _() {
|
|
// these conversions should be rewritten to look
|
|
// the same as the parenthesized conversions below
|
|
_ = func()()(nil)
|
|
_ = func(x int)(float)(nil)
|
|
_ = func() func() func()()(nil)
|
|
|
|
_ = (func()())(nil)
|
|
_ = (func(x int)(float))(nil)
|
|
_ = (func() func() func()())(nil)
|
|
}
|