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

Subversion Repositories openrisc

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

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.