mirror of
https://github.com/k3s-io/kubernetes.git
synced 2025-11-03 23:40:03 +00:00
4deda6ea98
* Changes to make vendored packages accept new home. * Fix go2idl to import vendored packages.
687 lines
12 KiB
Plaintext
687 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)
|
|
}
|