OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [go/] [printer/] [testdata/] [expressions.golden] - Blame information for rev 774

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// Copyright 2009 The Go Authors. All rights reserved.
2 
// Use of this source code is governed by a BSD-style
3 
// license that can be found in the LICENSE file.
4 
 
5 
package expressions
6 
 
7 
type T struct {
8 
        x, y, z int
9 
}
10 
 
11 
var (
12 
        a, b, c, d, e                                           int
13 
        under_bar                                               int
14 
        longIdentifier1, longIdentifier2, longIdentifier3       int
15 
        t0, t1, t2                                              T
16 
        s                                                       string
17 
        p                                                       *int
18 
)
19 
 
20 
func _() {
21 
        // no spaces around simple or parenthesized expressions
22 
        _ = (a + 0)
23 
        _ = a + b
24 
        _ = a + b + c
25 
        _ = a + b - c
26 
        _ = a - b - c
27 
        _ = a + (b * c)
28 
        _ = a + (b / c)
29 
        _ = a - (b % c)
30 
        _ = 1 + a
31 
        _ = a + 1
32 
        _ = a + b + 1
33 
        _ = s[a]
34 
        _ = s[a:]
35 
        _ = s[:b]
36 
        _ = s[1:2]
37 
        _ = s[a:b]
38 
        _ = s[0:len(s)]
39 
        _ = s[0] << 1
40 
        _ = (s[0] << 1) & 0xf
41 
        _ = s[0]<<2 | s[1]>>4
42 
        _ = "foo" + s
43 
        _ = s + "foo"
44 
        _ = 'a' + 'b'
45 
        _ = len(s) / 2
46 
        _ = len(t0.x) / a
47 
 
48 
        // spaces around expressions of different precedence or expressions containing spaces
49 
        _ = a + -b
50 
        _ = a - ^b
51 
        _ = a / *p
52 
        _ = a + b*c
53 
        _ = 1 + b*c
54 
        _ = a + 2*c
55 
        _ = a + c*2
56 
        _ = 1 + 2*3
57 
        _ = s[1 : 2*3]
58 
        _ = s[a : b-c]
59 
        _ = s[0:]
60 
        _ = s[a+b]
61 
        _ = s[:b-c]
62 
        _ = s[a+b:]
63 
        _ = a[a<
64 
        _ = a[a<
65 
        _ = s[a+b : len(s)]
66 
        _ = s[len(s):-a]
67 
        _ = s[a : len(s)+1]
68 
        _ = s[a:len(s)+1] + s
69 
 
70 
        // spaces around operators with equal or lower precedence than comparisons
71 
        _ = a == b
72 
        _ = a != b
73 
        _ = a > b
74 
        _ = a >= b
75 
        _ = a < b
76 
        _ = a <= b
77 
        _ = a < b && c > d
78 
        _ = a < b || c > d
79 
 
80 
        // spaces around "long" operands
81 
        _ = a + longIdentifier1
82 
        _ = longIdentifier1 + a
83 
        _ = longIdentifier1 + longIdentifier2*longIdentifier3
84 
        _ = s + "a longer string"
85 
 
86 
        // some selected cases
87 
        _ = a + t0.x
88 
        _ = a + t0.x + t1.x*t2.x
89 
        _ = a + b + c + d + e + 2*3
90 
        _ = a + b + c + 2*3 + d + e
91 
        _ = (a + b + c) * 2
92 
        _ = a - b + c - d + (a + b + c) + d&e
93 
        _ = under_bar - 1
94 
        _ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
95 
        _ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
96 
 
97 
        // the parser does not restrict expressions that may appear as statements
98 
        true
99 
        42
100 
        "foo"
101 
        x
102 
        (x)
103 
        a + b
104 
        a + b + c
105 
        a + (b * c)
106 
        a + (b / c)
107 
        1 + a
108 
        a + 1
109 
        s[a]
110 
        x << 1
111 
        (s[0] << 1) & 0xf
112 
        "foo" + s
113 
        x == y
114 
        x < y || z > 42
115 
}
116 
 
117 
func _() {
118 
        _ = a + b
119 
        _ = a + b + c
120 
        _ = a + b*c
121 
        _ = a + (b * c)
122 
        _ = (a + b) * c
123 
        _ = a + (b * c * d)
124 
        _ = a + (b*c + d)
125 
 
126 
        _ = 1 << x
127 
        _ = -1 << x
128 
        _ = 1<
129 
        _ = -1<
130 
 
131 
        _ = f(a + b)
132 
        _ = f(a + b + c)
133 
        _ = f(a + b*c)
134 
        _ = f(a + (b * c))
135 
        _ = f(1<
136 
 
137 
        _ = 1<
138 
 
139 
        buf = make(x, 2*cap(b.buf)+n)
140 
 
141 
        dst[i*3+2] = dbuf[0] << 2
142 
        dst[i*3+2] = dbuf[0]<<2 | dbuf[1]>>4
143 
 
144 
        b.buf = b.buf[0 : b.off+m+n]
145 
        b.buf = b.buf[0 : b.off+m*n]
146 
        f(b.buf[0 : b.off+m+n])
147 
 
148 
        signed += ' ' * 8
149 
        tw.octal(header[148:155], chksum)
150 
 
151 
        _ = x > 0 && i >= 0
152 
 
153 
        x1, x0 := x>>w2, x&m2
154 
        z0 = t1<
155 
        z1 = (t1 + t0>>w2) >> w2
156 
        q1, r1 := x1/d1, x1%d1
157 
        r1 = r1*b2 | x0>>w2
158 
        x1 = (x1 << z) | (x0 >> (uint(w) - z))
159 
        x1 = x1<>(uint(w)-z)
160 
 
161 
        _ = buf[0 : len(buf)+1]
162 
        _ = buf[0 : n+1]
163 
 
164 
        a, b = b, a
165 
        a = b + c
166 
        a = b*c + d
167 
        _ = a*b + c
168 
        _ = a - b - c
169 
        _ = a - (b - c)
170 
        _ = a - b*c
171 
        _ = a - (b * c)
172 
        _ = a * b / c
173 
        _ = a / *b
174 
        _ = x[a|^b]
175 
        _ = x[a / *b]
176 
        _ = a & ^b
177 
        _ = a + +b
178 
        _ = a - -b
179 
        _ = x[a*-b]
180 
        _ = x[a + +b]
181 
        _ = x ^ y ^ z
182 
        _ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
183 
        _ = len(longVariableName) * 2
184 
 
185 
        _ = token(matchType + xlength<
186 
}
187 
 
188 
func f(x int, args ...int) {
189 
        f(0, args...)
190 
        f(1, args)
191 
        f(2, args[0])
192 
 
193 
        // make sure syntactically legal code remains syntactically legal
194 
        f(3, 42 ...)    // a blank must remain between 42 and ...
195 
        f(4, 42....)
196 
        f(5, 42....)
197 
        f(6, 42.0...)
198 
        f(7, 42.0...)
199 
        f(8, .42...)
200 
        f(9, .42...)
201 
        f(10, 42e0...)
202 
        f(11, 42e0...)
203 
 
204 
        _ = 42 .x       // a blank must remain between 42 and .x
205 
        _ = 42..x
206 
        _ = 42..x
207 
        _ = 42.0.x
208 
        _ = 42.0.x
209 
        _ = .42.x
210 
        _ = .42.x
211 
        _ = 42e0.x
212 
        _ = 42e0.x
213 
 
214 
        // a blank must remain between the binary operator and the 2nd operand
215 
        _ = x / *y
216 
        _ = x < -1
217 
        _ = x < <-1
218 
        _ = x + +1
219 
        _ = x - -1
220 
        _ = x & &x
221 
        _ = x & ^x
222 
 
223 
        _ = f(x / *y, x < -1, x < <-1, x + +1, x - -1, x & &x, x & ^x)
224 
}
225 
 
226 
func _() {
227 
        _ = T{}
228 
        _ = struct{}{}
229 
        _ = [10]T{}
230 
        _ = [...]T{}
231 
        _ = []T{}
232 
        _ = map[int]T{}
233 
}
234 
 
235 
// one-line structs/interfaces in composite literals (up to a threshold)
236 
func _() {
237 
        _ = struct{}{}
238 
        _ = struct{ x int }{0}
239 
        _ = struct{ x, y, z int }{0, 1, 2}
240 
        _ = struct{ int }{0}
241 
        _ = struct{ s struct{ int } }{struct{ int }{0}}
242 
}
243 
 
244 
func _() {
245 
        // do not modify literals
246 
        _ = "tab1       tab2    tab3    end"    // string contains 3 tabs
247 
        _ = "tab1 tab2 tab3 end"        // same string with 3 blanks - may be unaligned because editors see tabs in strings
248 
        _ = ""                          // this comment should be aligned with the one on the previous line
249 
        _ = ``
250 
        _ = `
251 
`
252 
        _ = `foo
253 
                bar`
254 
        _ = `three spaces before the end of the line starting here:
255 
they must not be removed`
256 
}
257 
 
258 
func _() {
259 
        // smart handling of indentation for multi-line raw strings
260 
        var _ = ``
261 
        var _ = `foo`
262 
        var _ = `foo
263 
bar`
264 
 
265 
        var _ = ``
266 
        var _ = `foo`
267 
        var _ =
268 
        // the next line should remain indented
269 
        `foo
270 
bar`
271 
 
272 
        var _ = // comment
273 
        ``
274 
        var _ = // comment
275 
        `foo`
276 
        var _ = // comment
277 
        // the next line should remain indented
278 
        `foo
279 
bar`
280 
 
281 
        var _ = /* comment */ ``
282 
        var _ = /* comment */ `foo`
283 
        var _ = /* comment */ `foo
284 
bar`
285 
 
286 
        var _ = /* comment */
287 
        ``
288 
        var _ = /* comment */
289 
        `foo`
290 
        var _ = /* comment */
291 
        // the next line should remain indented
292 
        `foo
293 
bar`
294 
 
295 
        var board = []int(
296 
                `...........
297 
...........
298 
....●●●....
299 
....●●●....
300 
..●●●●●●●..
301 
..●●●○●●●..
302 
..●●●●●●●..
303 
....●●●....
304 
....●●●....
305 
...........
306 
...........
307 
`)
308 
 
309 
        var state = S{
310 
                "foo",
311 
                // the next line should remain indented
312 
                `...........
313 
...........
314 
....●●●....
315 
....●●●....
316 
..●●●●●●●..
317 
..●●●○●●●..
318 
..●●●●●●●..
319 
....●●●....
320 
....●●●....
321 
...........
322 
...........
323 
`,
324 
                "bar",
325 
        }
326 
}
327 
 
328 
func _() {
329 
        // one-line function literals (body is on a single line)
330 
        _ = func() {}
331 
        _ = func() int { return 0 }
332 
        _ = func(x, y int) bool { m := (x + y) / 2; return m < 0 }
333 
 
334 
        // multi-line function literals (body is not on one line)
335 
        _ = func() {
336 
        }
337 
        _ = func() int {
338 
                return 0
339 
        }
340 
        _ = func(x, y int) bool {
341 
                m := (x + y) / 2
342 
                return x < y
343 
        }
344 
 
345 
        f(func() {
346 
        })
347 
        f(func() int {
348 
                return 0
349 
        })
350 
        f(func(x, y int) bool {
351 
                m := (x + y) / 2
352 
                return x < y
353 
        })
354 
}
355 
 
356 
func _() {
357 
        _ = [][]int{
358 
                []int{1},
359 
                []int{1, 2},
360 
                []int{1, 2, 3},
361 
        }
362 
        _ = [][]int{
363 
                {1},
364 
                []int{1, 2},
365 
                []int{1, 2, 3},
366 
        }
367 
        _ = [][]int{
368 
                {1},
369 
                {1, 2},
370 
                {1, 2, 3},
371 
        }
372 
        _ = [][]int{{1}, {1, 2}, {1, 2, 3}}
373 
}
374 
 
375 
// various multi-line expressions
376 
func _() {
377 
        // do not add extra indentation to multi-line string lists
378 
        _ = "foo" + "bar"
379 
        _ = "foo" +
380 
                "bar" +
381 
                "bah"
382 
        _ = []string{
383 
                "abc" +
384 
                        "def",
385 
                "foo" +
386 
                        "bar",
387 
        }
388 
}
389 
 
390 
const _ = F1 +
391 
        `string = "%s";` +
392 
        `ptr = *;` +
393 
        `datafmt.T2 = s ["-" p "-"];`
394 
 
395 
const _ = `datafmt "datafmt";` +
396 
        `default = "%v";` +
397 
        `array = *;` +
398 
        `datafmt.T3 = s  {" " a a / ","};`
399 
 
400 
const _ = `datafmt "datafmt";` +
401 
        `default = "%v";` +
402 
        `array = *;` +
403 
        `datafmt.T3 = s  {" " a a / ","};`
404 
 
405 
func _() {
406 
        _ = F1 +
407 
                `string = "%s";` +
408 
                `ptr = *;` +
409 
                `datafmt.T2 = s ["-" p "-"];`
410 
 
411 
        _ =
412 
                `datafmt "datafmt";` +
413 
                        `default = "%v";` +
414 
                        `array = *;` +
415 
                        `datafmt.T3 = s  {" " a a / ","};`
416 
 
417 
        _ = `datafmt "datafmt";` +
418 
                `default = "%v";` +
419 
                `array = *;` +
420 
                `datafmt.T3 = s  {" " a a / ","};`
421 
}
422 
 
423 
func _() {
424 
        // respect source lines in multi-line expressions
425 
        _ = a +
426 
                b +
427 
                c
428 
        _ = a < b ||
429 
                b < a
430 
        _ = "933262154439441526816992388562667004907159682643816214685929" +
431 
                "638952175999932299156089414639761565182862536979208272237582" +
432 
                "51185210916864000000000000000000000000"        // 100!
433 
        _ = "170141183460469231731687303715884105727"   // prime
434 
}
435 
 
436 
// Alignment after overlong lines
437 
const (
438 
        _       = "991"
439 
        _       = "2432902008176640000" // 20!
440 
        _       = "933262154439441526816992388562667004907159682643816214685929" +
441 
                "638952175999932299156089414639761565182862536979208272237582" +
442 
                "51185210916864000000000000000000000000"        // 100!
443 
        _       = "170141183460469231731687303715884105727"     // prime
444 
)
445 
 
446 
// Correct placement of operators and comments in multi-line expressions
447 
func _() {
448 
        _ = a + // comment
449 
                b +     // comment
450 
                c
451 
        _ = "a" +
452 
                "b" +   // comment
453 
                "c"
454 
        _ = "ba0408" + "7265717569726564"       // field 71, encoding 2, string "required"
455 
}
456 
 
457 
// Correct placement of terminating comma/closing parentheses in multi-line calls.
458 
func _() {
459 
        f(1,
460 
                2,
461 
                3)
462 
        f(1,
463 
                2,
464 
                3,
465 
        )
466 
        f(1,
467 
                2,
468 
                3)      // comment
469 
        f(1,
470 
                2,
471 
                3,      // comment
472 
        )
473 
        f(1,
474 
                2,
475 
                3)      // comment
476 
        f(1,
477 
                2,
478 
                3,      // comment
479 
        )
480 
}
481 
 
482 
// Align comments in multi-line lists of single-line expressions.
483 
var txpix = [NCOL]draw.Color{
484 
        draw.Yellow,            // yellow
485 
        draw.Cyan,              // cyan
486 
        draw.Green,             // lime green
487 
        draw.GreyBlue,          // slate
488 
        draw.Red,               /* red */
489 
        draw.GreyGreen,         /* olive green */
490 
        draw.Blue,              /* blue */
491 
        draw.Color(0xFF55AAFF), /* pink */
492 
        draw.Color(0xFFAAFFFF), /* lavender */
493 
        draw.Color(0xBB005DFF), /* maroon */
494 
}
495 
 
496 
func same(t, u *Time) bool {
497 
        // respect source lines in multi-line expressions
498 
        return t.Year == u.Year &&
499 
                t.Month == u.Month &&
500 
                t.Day == u.Day &&
501 
                t.Hour == u.Hour &&
502 
                t.Minute == u.Minute &&
503 
                t.Second == u.Second &&
504 
                t.Weekday == u.Weekday &&
505 
                t.ZoneOffset == u.ZoneOffset &&
506 
                t.Zone == u.Zone
507 
}
508 
 
509 
func (p *parser) charClass() {
510 
        // respect source lines in multi-line expressions
511 
        if cc.negate && len(cc.ranges) == 2 &&
512 
                cc.ranges[0] == '\n' && cc.ranges[1] == '\n' {
513 
                nl := new(_NotNl)
514 
                p.re.add(nl)
515 
        }
516 
}
517 
 
518 
func addState(s []state, inst instr, match []int) {
519 
        // handle comments correctly in multi-line expressions
520 
        for i := 0; i < l; i++ {
521 
                if s[i].inst.index() == index &&        // same instruction
522 
                        s[i].match[0] < pos {   // earlier match already going; leftmost wins
523 
                        return s
524 
                }
525 
        }
526 
}
527 
 
528 
func (self *T) foo(x int) *T    { return self }
529 
 
530 
func _()        { module.Func1().Func2() }
531 
 
532 
func _() {
533 
        _ = new(T).
534 
                foo(1).
535 
                foo(2).
536 
                foo(3)
537 
 
538 
        _ = new(T).
539 
                foo(1).
540 
                foo(2). // inline comments
541 
                foo(3)
542 
 
543 
        _ = new(T).foo(1).foo(2).foo(3)
544 
 
545 
        // handle multiline argument list correctly
546 
        _ = new(T).
547 
                foo(
548 
                        1).
549 
                foo(2)
550 
 
551 
        _ = new(T).foo(
552 
                1).foo(2)
553 
 
554 
        _ = Array[3+
555 
                4]
556 
 
557 
        _ = Method(1, 2,
558 
                3)
559 
 
560 
        _ = new(T).
561 
                foo().
562 
                bar().(*Type)
563 
 
564 
        _ = new(T).
565 
                foo().
566 
                bar().(*Type).
567 
                baz()
568 
 
569 
        _ = new(T).
570 
                foo().
571 
                bar()["idx"]
572 
 
573 
        _ = new(T).
574 
                foo().
575 
                bar()["idx"].
576 
                baz()
577 
 
578 
        _ = new(T).
579 
                foo().
580 
                bar()[1:2]
581 
 
582 
        _ = new(T).
583 
                foo().
584 
                bar()[1:2].
585 
                baz()
586 
 
587 
        _ = new(T).
588 
                Field.
589 
                Array[3+
590 
                        4].
591 
                Table["foo"].
592 
                Blob.(*Type).
593 
                Slices[1:4].
594 
                Method(1, 2,
595 
                        3).
596 
                Thingy
597 
 
598 
        _ = a.b.c
599 
        _ = a.
600 
                b.
601 
                c
602 
        _ = a.b().c
603 
        _ = a.
604 
                b().
605 
                c
606 
        _ = a.b[0].c
607 
        _ = a.
608 
                b[0].
609 
                c
610 
        _ = a.b[0:].c
611 
        _ = a.
612 
                b[0:].
613 
                c
614 
        _ = a.b.(T).c
615 
        _ = a.
616 
                b.(T).
617 
                c
618 
}
619 
 
620 
// Don't introduce extra newlines in strangely formatted expression lists.
621 
func f() {
622 
        // os.Open parameters should remain on two lines
623 
        if writer, err = os.Open(outfile, s.O_WRONLY|os.O_CREATE|
624 
                os.O_TRUNC, 0666); err != nil {
625 
                log.Fatal(err)
626 
        }
627 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.