// 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 + 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[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[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);
}


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 _() {
	_ = T{};
	_ = struct{}{};
	_ = [10]T{};
	_ = [...]T{};
	_ = []T{};
	_ = map[int]T{};

	_ = (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}};	// compositeLit context not propagated => multiLine result
}


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`;
}


func _() {
	// one-line function literals
	_ = func() {};
	_ = func() int { return 0 };
	_ = func(x, y int) bool { return x < y };

	f(func() {});
	f(func() int { return 0 });
	f(func(x, y int) bool { return x < y });
}


func _() {
	// not 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
)


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