1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
|
CCCC - a code counter for C and C++
===================================
A program to analyse C and C++ source code and report on
some simple software metrics
Version <unnumbered>
Copyright Tim Littlefair, 1995, 1996, 1997, 1998, 1999, 2000
with contributions from Bill McLean, Herman Hueni, Lynn Wilson
Peter Bell, Thomas Hieber and Kenneth H. Cox.
The development of this program was heavily dependent on
the Purdue Compiler Construction Tool Set (PCCTS)
by Terence Parr, Will Cohen, Hank Dietz, Russel Quoung,
Tom Moog and others.
This software is provided with NO WARRANTY
Parsing
Processing prn8.java as Java
TOK: public 0 0
makeToken(tt=>101, txt=>public,line=>5)
TOK: class 0 0
makeToken(tt=>76, txt=>class,line=>5)
5 101public -> compilationUnit
5 101 public -> typeDefinition
5 101 public -> modifiers
5 101 public -> modifier
TOK: EwoisErrorHandler 0 0
makeToken(tt=>121, txt=>EwoisErrorHandler,line=>5)
5 76 class <- modifier
5 76 class <- modifiers
5 76 class -> classDefinition
TOK: { 0 0
makeToken(tt=>7, txt=>{,line=>6)
TOK: public 0 0
makeToken(tt=>101, txt=>public,line=>7)
6 7 { -> superClassClause
6 7 { <- superClassClause
6 7 { -> implementsClause
6 7 { <- implementsClause
6 7 { -> classBlock
TOK: synchronized 0 0
makeToken(tt=>109, txt=>synchronized,line=>7)
7 101 public -> field
7 101 public -> modifiers
7 101 public -> modifier
TOK: void 0 0
makeToken(tt=>118, txt=>void,line=>7)
7 109 synchronized <- modifier
7 109 synchronized -> modifier
TOK: handleError 0 0
makeToken(tt=>121, txt=>handleError,line=>7)
7 118 void <- modifier
7 118 void <- modifiers
7 118 void -> typeSpec2
7 118 void -> builtInTypeSpec2
7 118 void -> builtInType
TOK: ( 0 0
makeToken(tt=>3, txt=>(,line=>7)
7 121 handleError <- builtInType
7 121 handleError <- builtInTypeSpec2
7 121 handleError <- typeSpec2
7 121 handleError -> typedDeclaration
7 121 handleError -> methodDefinition
TOK: int 0 0
makeToken(tt=>92, txt=>int,line=>7)
TOK: fehlertyp 0 0
makeToken(tt=>121, txt=>fehlertyp,line=>7)
7 92 int -> parameterDeclarationList
7 92 int -> parameterDeclaration
7 92 int -> parameterModifier
7 92 int <- parameterModifier
7 92 int -> typeSpec2
7 92 int -> builtInTypeSpec2
7 92 int -> builtInType
TOK: ) 0 0
makeToken(tt=>4, txt=>),line=>7)
7 121 fehlertyp <- builtInType
7 121 fehlertyp <- builtInTypeSpec2
7 121 fehlertyp <- typeSpec2
TOK: { 0 0
makeToken(tt=>7, txt=>{,line=>8)
7 4 ) -> parameterDeclaratorBrackets
7 4 ) <- parameterDeclaratorBrackets
7 4 ) <- parameterDeclaration
7 4 ) <- parameterDeclarationList
TOK: String 0 0
makeToken(tt=>121, txt=>String,line=>9)
8 7 { -> returnTypeBrackersOnEndOfMethodHead
8 7 { <- returnTypeBrackersOnEndOfMethodHead
8 7 { -> compoundStatement
TOK: lvTyp 0 0
makeToken(tt=>121, txt=>lvTyp,line=>9)
9 121 String -> statement
9 121 String -> ?declaration
9 121 String -> ?modifiers
9 121 String <- ?modifiers
9 121 String -> ?typeSpec
9 121 String -> ?classTypeSpec
9 121 String -> ?identifier
TOK: = 0 0
makeToken(tt=>12, txt=>=,line=>9)
9 121 lvTyp <- ?identifier
9 121 lvTyp <- ?classTypeSpec
9 121 lvTyp <- ?typeSpec
9 121 lvTyp -> ?variableDefinitions
9 121 lvTyp -> ?variableDeclarator
TOK: " 0 0
makeToken(tt=>64, txt=>",line=>9)
9 12 = -> ?declaratorBrackets
9 12 = <- ?declaratorBrackets
9 12 = -> ?varInitializer
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>9)
9 64 " -> ?initializer
9 64 " -> ?expression
9 64 " -> ?assignmentExpression
9 64 " -> ?conditionalExpression
9 64 " -> ?logicalOrExpression
9 64 " -> ?logicalAndExpression
9 64 " -> ?inclusiveOrExpression
9 64 " -> ?exclusiveOrExpression
9 64 " -> ?andExpression
9 64 " -> ?equalityExpression
9 64 " -> ?relationalExpression
9 64 " -> ?shiftExpression
9 64 " -> ?additiveExpression
9 64 " -> ?multiplicativeExpression
9 64 " -> ?unaryExpression
9 64 " -> ?unaryExpressionNotPlusMinus
9 64 " -> ?postfixExpression
9 64 " -> ?primaryExpression
9 64 " -> ?constant
TOK: switch 0 0
makeToken(tt=>108, txt=>switch,line=>10)
9 47 ; <- ?constant
9 47 ; <- ?primaryExpression
9 47 ; <- ?postfixExpression
9 47 ; <- ?unaryExpressionNotPlusMinus
9 47 ; <- ?unaryExpression
9 47 ; <- ?multiplicativeExpression
9 47 ; <- ?additiveExpression
9 47 ; <- ?shiftExpression
9 47 ; <- ?relationalExpression
9 47 ; <- ?equalityExpression
9 47 ; <- ?andExpression
9 47 ; <- ?exclusiveOrExpression
9 47 ; <- ?inclusiveOrExpression
9 47 ; <- ?logicalAndExpression
9 47 ; <- ?logicalOrExpression
9 47 ; <- ?conditionalExpression
9 47 ; <- ?assignmentExpression
9 47 ; <- ?expression
9 47 ; <- ?initializer
9 47 ; <- ?varInitializer
9 47 ; <- ?variableDeclarator
9 47 ; <- ?variableDefinitions
9 47 ; <- ?declaration
9 121 String -> declaration
9 121 String -> modifiers
9 121 String <- modifiers
9 121 String -> typeSpec
9 121 String -> classTypeSpec
9 121 String -> identifier
9 121 lvTyp <- identifier
9 121 lvTyp <- classTypeSpec
9 121 lvTyp <- typeSpec
9 121 lvTyp -> variableDefinitions
9 121 lvTyp -> variableDeclarator
9 12 = -> declaratorBrackets
9 12 = <- declaratorBrackets
9 12 = -> varInitializer
9 64 " -> initializer
9 64 " -> expression
9 64 " -> assignmentExpression
9 64 " -> conditionalExpression
9 64 " -> logicalOrExpression
9 64 " -> logicalAndExpression
9 64 " -> inclusiveOrExpression
9 64 " -> exclusiveOrExpression
9 64 " -> andExpression
9 64 " -> equalityExpression
9 64 " -> relationalExpression
9 64 " -> shiftExpression
9 64 " -> additiveExpression
9 64 " -> multiplicativeExpression
9 64 " -> unaryExpression
9 64 " -> unaryExpressionNotPlusMinus
9 64 " -> postfixExpression
9 64 " -> primaryExpression
9 64 " -> constant
9 47 ; <- constant
9 47 ; <- primaryExpression
9 47 ; <- postfixExpression
9 47 ; <- unaryExpressionNotPlusMinus
9 47 ; <- unaryExpression
9 47 ; <- multiplicativeExpression
9 47 ; <- additiveExpression
9 47 ; <- shiftExpression
9 47 ; <- relationalExpression
9 47 ; <- equalityExpression
9 47 ; <- andExpression
9 47 ; <- exclusiveOrExpression
9 47 ; <- inclusiveOrExpression
9 47 ; <- logicalAndExpression
9 47 ; <- logicalOrExpression
9 47 ; <- conditionalExpression
9 47 ; <- assignmentExpression
9 47 ; <- expression
9 47 ; <- initializer
9 47 ; <- varInitializer
9 47 ; <- variableDeclarator
9 47 ; <- variableDefinitions
9 47 ; <- declaration
TOK: ( 0 0
makeToken(tt=>3, txt=>(,line=>10)
10 108 switch <- statement
10 108 switch -> statement
10 108 switch -> switchStatement
TOK: fehlertyp 0 0
makeToken(tt=>121, txt=>fehlertyp,line=>10)
TOK: ) 0 0
makeToken(tt=>4, txt=>),line=>10)
10 121 fehlertyp -> expression
10 121 fehlertyp -> assignmentExpression
10 121 fehlertyp -> conditionalExpression
10 121 fehlertyp -> logicalOrExpression
10 121 fehlertyp -> logicalAndExpression
10 121 fehlertyp -> inclusiveOrExpression
10 121 fehlertyp -> exclusiveOrExpression
10 121 fehlertyp -> andExpression
10 121 fehlertyp -> equalityExpression
10 121 fehlertyp -> relationalExpression
10 121 fehlertyp -> shiftExpression
10 121 fehlertyp -> additiveExpression
10 121 fehlertyp -> multiplicativeExpression
10 121 fehlertyp -> unaryExpression
10 121 fehlertyp -> unaryExpressionNotPlusMinus
10 121 fehlertyp -> postfixExpression
10 121 fehlertyp -> primaryExpression
TOK: { 0 0
makeToken(tt=>7, txt=>{,line=>11)
10 4 ) <- primaryExpression
10 4 ) <- postfixExpression
10 4 ) <- unaryExpressionNotPlusMinus
10 4 ) <- unaryExpression
10 4 ) <- multiplicativeExpression
10 4 ) <- additiveExpression
10 4 ) <- shiftExpression
10 4 ) <- relationalExpression
10 4 ) <- equalityExpression
10 4 ) <- andExpression
10 4 ) <- exclusiveOrExpression
10 4 ) <- inclusiveOrExpression
10 4 ) <- logicalAndExpression
10 4 ) <- logicalOrExpression
10 4 ) <- conditionalExpression
10 4 ) <- assignmentExpression
10 4 ) <- expression
TOK: case 0 0
makeToken(tt=>121, txt=>case,line=>12)
TOK: WARNING 0 0
makeToken(tt=>121, txt=>WARNING,line=>12)
prn8.java(12): syntax error at token case
prn8.java(10): trying to match switchStatement at 'switch'
12 121 case <- switchStatement
12 121 case <- statement
12 121 case -> statement
12 121 case -> ?declaration
12 121 case -> ?modifiers
12 121 case <- ?modifiers
12 121 case -> ?typeSpec
12 121 case -> ?classTypeSpec
12 121 case -> ?identifier
TOK: : 0 0
makeToken(tt=>9, txt=>:,line=>12)
12 121 WARNING <- ?identifier
12 121 WARNING <- ?classTypeSpec
12 121 WARNING <- ?typeSpec
12 121 WARNING -> ?variableDefinitions
12 121 WARNING -> ?variableDeclarator
TOK: lvTyp 0 0
makeToken(tt=>121, txt=>lvTyp,line=>13)
12 9 : -> ?declaratorBrackets
12 9 : <- ?declaratorBrackets
12 9 : -> ?varInitializer
12 9 : <- ?varInitializer
12 9 : <- ?variableDeclarator
12 9 : <- ?variableDefinitions
12 9 : <- ?declaration
12 121 case -> declaration
12 121 case -> modifiers
12 121 case <- modifiers
12 121 case -> typeSpec
12 121 case -> classTypeSpec
12 121 case -> identifier
12 121 WARNING <- identifier
12 121 WARNING <- classTypeSpec
12 121 WARNING <- typeSpec
12 121 WARNING -> variableDefinitions
12 121 WARNING -> variableDeclarator
12 9 : -> declaratorBrackets
12 9 : <- declaratorBrackets
12 9 : -> varInitializer
12 9 : <- varInitializer
12 9 : <- variableDeclarator
12 9 : <- variableDefinitions
12 9 : <- declaration
prn8.java(12): syntax error at token :
prn8.java(12): trying to match statement at 'case'
freeing token public on line 5 c1:1 c2:27 c3:0 freed:1
freeing token class on line 5 c1:1 c2:27 c3:0 freed:2
freeing token { on line 6 c1:1 c2:27 c3:0 freed:3
freeing token public on line 7 c1:1 c2:27 c3:0 freed:4
freeing token synchronized on line 7 c1:1 c2:27 c3:0 freed:5
freeing token void on line 7 c1:1 c2:27 c3:0 freed:6
freeing token ( on line 7 c1:1 c2:27 c3:0 freed:7
freeing token int on line 7 c1:1 c2:27 c3:0 freed:8
freeing token fehlertyp on line 7 c1:1 c2:27 c3:0 freed:9
freeing token ) on line 7 c1:1 c2:27 c3:0 freed:10
freeing token { on line 8 c1:1 c2:27 c3:0 freed:11
freeing token String on line 9 c1:1 c2:27 c3:0 freed:12
freeing token lvTyp on line 9 c1:1 c2:27 c3:0 freed:13
freeing token = on line 9 c1:1 c2:27 c3:0 freed:14
freeing token " on line 9 c1:1 c2:27 c3:0 freed:15
freeing token ; on line 9 c1:1 c2:27 c3:0 freed:16
freeing token switch on line 10 c1:1 c2:27 c3:0 freed:17
freeing token ( on line 10 c1:1 c2:27 c3:0 freed:18
freeing token fehlertyp on line 10 c1:1 c2:27 c3:0 freed:19
freeing token ) on line 10 c1:1 c2:27 c3:0 freed:20
freeing token { on line 11 c1:1 c2:27 c3:0 freed:21
freeing token case on line 12 c1:1 c2:27 c3:0 freed:22
freeing token WARNING on line 12 c1:1 c2:27 c3:0 freed:23
freeing token : on line 12 c1:1 c2:27 c3:0 freed:24
TOK: = 0 0
makeToken(tt=>12, txt=>=,line=>13)
13 121 lvTyp <- statement
13 121 lvTyp -> statement
13 121 lvTyp -> expression
13 121 lvTyp -> assignmentExpression
13 121 lvTyp -> conditionalExpression
13 121 lvTyp -> logicalOrExpression
13 121 lvTyp -> logicalAndExpression
13 121 lvTyp -> inclusiveOrExpression
13 121 lvTyp -> exclusiveOrExpression
13 121 lvTyp -> andExpression
13 121 lvTyp -> equalityExpression
13 121 lvTyp -> relationalExpression
13 121 lvTyp -> shiftExpression
13 121 lvTyp -> additiveExpression
13 121 lvTyp -> multiplicativeExpression
13 121 lvTyp -> unaryExpression
13 121 lvTyp -> unaryExpressionNotPlusMinus
13 121 lvTyp -> postfixExpression
13 121 lvTyp -> primaryExpression
TOK: " 0 0
makeToken(tt=>64, txt=>",line=>13)
13 12 = <- primaryExpression
13 12 = <- postfixExpression
13 12 = <- unaryExpressionNotPlusMinus
13 12 = <- unaryExpression
13 12 = <- multiplicativeExpression
13 12 = <- additiveExpression
13 12 = <- shiftExpression
13 12 = <- relationalExpression
13 12 = <- equalityExpression
13 12 = <- andExpression
13 12 = <- exclusiveOrExpression
13 12 = <- inclusiveOrExpression
13 12 = <- logicalAndExpression
13 12 = <- logicalOrExpression
13 12 = <- conditionalExpression
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>13)
13 64 " -> assignmentExpression
13 64 " -> conditionalExpression
13 64 " -> logicalOrExpression
13 64 " -> logicalAndExpression
13 64 " -> inclusiveOrExpression
13 64 " -> exclusiveOrExpression
13 64 " -> andExpression
13 64 " -> equalityExpression
13 64 " -> relationalExpression
13 64 " -> shiftExpression
13 64 " -> additiveExpression
13 64 " -> multiplicativeExpression
13 64 " -> unaryExpression
13 64 " -> unaryExpressionNotPlusMinus
13 64 " -> postfixExpression
13 64 " -> primaryExpression
13 64 " -> constant
TOK: break 0 0
makeToken(tt=>72, txt=>break,line=>14)
13 47 ; <- constant
13 47 ; <- primaryExpression
13 47 ; <- postfixExpression
13 47 ; <- unaryExpressionNotPlusMinus
13 47 ; <- unaryExpression
13 47 ; <- multiplicativeExpression
13 47 ; <- additiveExpression
13 47 ; <- shiftExpression
13 47 ; <- relationalExpression
13 47 ; <- equalityExpression
13 47 ; <- andExpression
13 47 ; <- exclusiveOrExpression
13 47 ; <- inclusiveOrExpression
13 47 ; <- logicalAndExpression
13 47 ; <- logicalOrExpression
13 47 ; <- conditionalExpression
13 47 ; <- assignmentExpression
13 47 ; <- assignmentExpression
13 47 ; <- expression
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>14)
14 72 break <- statement
14 72 break -> statement
14 72 break -> breakStatement
TOK: case 0 0
makeToken(tt=>121, txt=>case,line=>15)
TOK: LOGINFO 0 0
makeToken(tt=>121, txt=>LOGINFO,line=>15)
15 121 case <- breakStatement
15 121 case <- statement
15 121 case -> statement
15 121 case -> ?declaration
15 121 case -> ?modifiers
15 121 case <- ?modifiers
15 121 case -> ?typeSpec
15 121 case -> ?classTypeSpec
15 121 case -> ?identifier
TOK: : 0 0
makeToken(tt=>9, txt=>:,line=>15)
15 121 LOGINFO <- ?identifier
15 121 LOGINFO <- ?classTypeSpec
15 121 LOGINFO <- ?typeSpec
15 121 LOGINFO -> ?variableDefinitions
15 121 LOGINFO -> ?variableDeclarator
TOK: lvTyp 0 0
makeToken(tt=>121, txt=>lvTyp,line=>16)
15 9 : -> ?declaratorBrackets
15 9 : <- ?declaratorBrackets
15 9 : -> ?varInitializer
15 9 : <- ?varInitializer
15 9 : <- ?variableDeclarator
15 9 : <- ?variableDefinitions
15 9 : <- ?declaration
15 121 case -> declaration
15 121 case -> modifiers
15 121 case <- modifiers
15 121 case -> typeSpec
15 121 case -> classTypeSpec
15 121 case -> identifier
15 121 LOGINFO <- identifier
15 121 LOGINFO <- classTypeSpec
15 121 LOGINFO <- typeSpec
15 121 LOGINFO -> variableDefinitions
15 121 LOGINFO -> variableDeclarator
15 9 : -> declaratorBrackets
15 9 : <- declaratorBrackets
15 9 : -> varInitializer
15 9 : <- varInitializer
15 9 : <- variableDeclarator
15 9 : <- variableDefinitions
15 9 : <- declaration
prn8.java(15): syntax error at token :
prn8.java(15): trying to match statement at 'case'
TOK: = 0 0
makeToken(tt=>12, txt=>=,line=>16)
16 121 lvTyp <- statement
16 121 lvTyp -> statement
16 121 lvTyp -> expression
16 121 lvTyp -> assignmentExpression
16 121 lvTyp -> conditionalExpression
16 121 lvTyp -> logicalOrExpression
16 121 lvTyp -> logicalAndExpression
16 121 lvTyp -> inclusiveOrExpression
16 121 lvTyp -> exclusiveOrExpression
16 121 lvTyp -> andExpression
16 121 lvTyp -> equalityExpression
16 121 lvTyp -> relationalExpression
16 121 lvTyp -> shiftExpression
16 121 lvTyp -> additiveExpression
16 121 lvTyp -> multiplicativeExpression
16 121 lvTyp -> unaryExpression
16 121 lvTyp -> unaryExpressionNotPlusMinus
16 121 lvTyp -> postfixExpression
16 121 lvTyp -> primaryExpression
TOK: " 0 0
makeToken(tt=>64, txt=>",line=>16)
16 12 = <- primaryExpression
16 12 = <- postfixExpression
16 12 = <- unaryExpressionNotPlusMinus
16 12 = <- unaryExpression
16 12 = <- multiplicativeExpression
16 12 = <- additiveExpression
16 12 = <- shiftExpression
16 12 = <- relationalExpression
16 12 = <- equalityExpression
16 12 = <- andExpression
16 12 = <- exclusiveOrExpression
16 12 = <- inclusiveOrExpression
16 12 = <- logicalAndExpression
16 12 = <- logicalOrExpression
16 12 = <- conditionalExpression
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>16)
16 64 " -> assignmentExpression
16 64 " -> conditionalExpression
16 64 " -> logicalOrExpression
16 64 " -> logicalAndExpression
16 64 " -> inclusiveOrExpression
16 64 " -> exclusiveOrExpression
16 64 " -> andExpression
16 64 " -> equalityExpression
16 64 " -> relationalExpression
16 64 " -> shiftExpression
16 64 " -> additiveExpression
16 64 " -> multiplicativeExpression
16 64 " -> unaryExpression
16 64 " -> unaryExpressionNotPlusMinus
16 64 " -> postfixExpression
16 64 " -> primaryExpression
16 64 " -> constant
TOK: break 0 0
makeToken(tt=>72, txt=>break,line=>17)
16 47 ; <- constant
16 47 ; <- primaryExpression
16 47 ; <- postfixExpression
16 47 ; <- unaryExpressionNotPlusMinus
16 47 ; <- unaryExpression
16 47 ; <- multiplicativeExpression
16 47 ; <- additiveExpression
16 47 ; <- shiftExpression
16 47 ; <- relationalExpression
16 47 ; <- equalityExpression
16 47 ; <- andExpression
16 47 ; <- exclusiveOrExpression
16 47 ; <- inclusiveOrExpression
16 47 ; <- logicalAndExpression
16 47 ; <- logicalOrExpression
16 47 ; <- conditionalExpression
16 47 ; <- assignmentExpression
16 47 ; <- assignmentExpression
16 47 ; <- expression
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>17)
17 72 break <- statement
17 72 break -> statement
17 72 break -> breakStatement
TOK: } 0 0
makeToken(tt=>8, txt=>},line=>18)
TOK: StringBuffer 0 0
makeToken(tt=>121, txt=>StringBuffer,line=>19)
18 8 } <- breakStatement
18 8 } <- statement
TOK: buffer 0 0
makeToken(tt=>121, txt=>buffer,line=>19)
19 121 StringBuffer <- compoundStatement
19 121 StringBuffer <- methodDefinition
freeing token handleError on line 7 c1:1 c2:44 c3:0 freed:25
19 121 StringBuffer <- typedDeclaration
19 121 StringBuffer <- field
19 121 StringBuffer -> field
19 121 StringBuffer -> modifiers
19 121 StringBuffer <- modifiers
19 121 StringBuffer -> typeSpec2
19 121 StringBuffer -> classTypeSpec2
19 121 StringBuffer -> identifier2
TOK: = 0 0
makeToken(tt=>12, txt=>=,line=>19)
19 121 buffer <- identifier2
19 121 buffer <- classTypeSpec2
19 121 buffer <- typeSpec2
19 121 buffer -> typedDeclaration
19 121 buffer -> variableDefinitions
19 121 buffer -> variableDeclarator
TOK: new 0 0
makeToken(tt=>96, txt=>new,line=>19)
19 12 = -> declaratorBrackets
19 12 = <- declaratorBrackets
19 12 = -> varInitializer
TOK: StringBuffer 0 0
makeToken(tt=>121, txt=>StringBuffer,line=>19)
19 96 new -> initializer
19 96 new -> expression
19 96 new -> assignmentExpression
19 96 new -> conditionalExpression
19 96 new -> logicalOrExpression
19 96 new -> logicalAndExpression
19 96 new -> inclusiveOrExpression
19 96 new -> exclusiveOrExpression
19 96 new -> andExpression
19 96 new -> equalityExpression
19 96 new -> relationalExpression
19 96 new -> shiftExpression
19 96 new -> additiveExpression
19 96 new -> multiplicativeExpression
19 96 new -> unaryExpression
19 96 new -> unaryExpressionNotPlusMinus
19 96 new -> postfixExpression
19 96 new -> primaryExpression
19 96 new -> newExpression
TOK: ( 0 0
makeToken(tt=>3, txt=>(,line=>19)
19 121 StringBuffer -> type
19 121 StringBuffer -> identifier
TOK: lvTyp 0 0
makeToken(tt=>121, txt=>lvTyp,line=>19)
19 3 ( <- identifier
19 3 ( <- type
TOK: ) 0 0
makeToken(tt=>4, txt=>),line=>19)
19 121 lvTyp -> argList
19 121 lvTyp -> expressionList
19 121 lvTyp -> expression
19 121 lvTyp -> assignmentExpression
19 121 lvTyp -> conditionalExpression
19 121 lvTyp -> logicalOrExpression
19 121 lvTyp -> logicalAndExpression
19 121 lvTyp -> inclusiveOrExpression
19 121 lvTyp -> exclusiveOrExpression
19 121 lvTyp -> andExpression
19 121 lvTyp -> equalityExpression
19 121 lvTyp -> relationalExpression
19 121 lvTyp -> shiftExpression
19 121 lvTyp -> additiveExpression
19 121 lvTyp -> multiplicativeExpression
19 121 lvTyp -> unaryExpression
19 121 lvTyp -> unaryExpressionNotPlusMinus
19 121 lvTyp -> postfixExpression
19 121 lvTyp -> primaryExpression
TOK: ; 0 0
makeToken(tt=>47, txt=>;,line=>19)
19 4 ) <- primaryExpression
19 4 ) <- postfixExpression
19 4 ) <- unaryExpressionNotPlusMinus
19 4 ) <- unaryExpression
19 4 ) <- multiplicativeExpression
19 4 ) <- additiveExpression
19 4 ) <- shiftExpression
19 4 ) <- relationalExpression
19 4 ) <- equalityExpression
19 4 ) <- andExpression
19 4 ) <- exclusiveOrExpression
19 4 ) <- inclusiveOrExpression
19 4 ) <- logicalAndExpression
19 4 ) <- logicalOrExpression
19 4 ) <- conditionalExpression
19 4 ) <- assignmentExpression
19 4 ) <- expression
19 4 ) <- expressionList
19 4 ) <- argList
TOK: buffer 0 0
makeToken(tt=>121, txt=>buffer,line=>20)
19 47 ; <- newExpression
19 47 ; <- primaryExpression
19 47 ; <- postfixExpression
19 47 ; <- unaryExpressionNotPlusMinus
19 47 ; <- unaryExpression
19 47 ; <- multiplicativeExpression
19 47 ; <- additiveExpression
19 47 ; <- shiftExpression
19 47 ; <- relationalExpression
19 47 ; <- equalityExpression
19 47 ; <- andExpression
19 47 ; <- exclusiveOrExpression
19 47 ; <- inclusiveOrExpression
19 47 ; <- logicalAndExpression
19 47 ; <- logicalOrExpression
19 47 ; <- conditionalExpression
19 47 ; <- assignmentExpression
19 47 ; <- expression
19 47 ; <- initializer
19 47 ; <- varInitializer
19 47 ; <- variableDeclarator
19 47 ; <- variableDefinitions
freeing token lvTyp on line 13 c1:1 c2:52 c3:0 freed:26
freeing token = on line 13 c1:1 c2:52 c3:0 freed:27
freeing token " on line 13 c1:1 c2:52 c3:0 freed:28
freeing token ; on line 13 c1:1 c2:52 c3:0 freed:29
freeing token break on line 14 c1:1 c2:52 c3:0 freed:30
freeing token ; on line 14 c1:1 c2:52 c3:0 freed:31
freeing token case on line 15 c1:1 c2:52 c3:0 freed:32
freeing token LOGINFO on line 15 c1:1 c2:52 c3:0 freed:33
freeing token : on line 15 c1:1 c2:52 c3:0 freed:34
freeing token lvTyp on line 16 c1:1 c2:52 c3:0 freed:35
freeing token = on line 16 c1:1 c2:52 c3:0 freed:36
freeing token " on line 16 c1:1 c2:52 c3:0 freed:37
freeing token ; on line 16 c1:1 c2:52 c3:0 freed:38
freeing token break on line 17 c1:1 c2:52 c3:0 freed:39
freeing token ; on line 17 c1:1 c2:52 c3:0 freed:40
freeing token } on line 18 c1:1 c2:52 c3:0 freed:41
freeing token StringBuffer on line 19 c1:1 c2:52 c3:0 freed:42
freeing token buffer on line 19 c1:1 c2:52 c3:0 freed:43
freeing token = on line 19 c1:1 c2:52 c3:0 freed:44
freeing token new on line 19 c1:1 c2:52 c3:0 freed:45
freeing token StringBuffer on line 19 c1:1 c2:52 c3:0 freed:46
freeing token ( on line 19 c1:1 c2:52 c3:0 freed:47
freeing token lvTyp on line 19 c1:1 c2:52 c3:0 freed:48
freeing token ) on line 19 c1:1 c2:52 c3:0 freed:49
freeing token ; on line 19 c1:1 c2:52 c3:0 freed:50
TOK: . 0 0
makeToken(tt=>11, txt=>.,line=>20)
20 121 buffer <- typedDeclaration
20 121 buffer <- field
20 121 buffer -> field
20 121 buffer -> modifiers
20 121 buffer <- modifiers
20 121 buffer -> typeSpec2
20 121 buffer -> classTypeSpec2
20 121 buffer -> identifier2
TOK: append 0 0
makeToken(tt=>121, txt=>append,line=>20)
TOK: ( 0 0
makeToken(tt=>3, txt=>(,line=>20)
TOK: " 0 0
makeToken(tt=>64, txt=>",line=>20)
20 3 ( <- identifier2
20 3 ( <- classTypeSpec2
20 3 ( <- typeSpec2
20 3 ( -> typedDeclaration
prn8.java(20): syntax error at token (
prn8.java(20): trying to match typedDeclaration at '('
TOK: ) 0 0
makeToken(tt=>4, txt=>),line=>20)
TOK: . 0 0
makeToken(tt=>11, txt=>.,line=>20)
TOK: append 0 0
makeToken(tt=>121, txt=>append,line=>20)
TOK: ( 0 0
makeToken(tt=>3, txt=>(,line=>20)
20 121 append <- typedDeclaration
20 121 append <- field
20 121 append -> field
20 121 append -> modifiers
20 121 append <- modifiers
20 121 append -> ctorDefinition
Assertion failed: className==LT(1)->getText(), file java.cpp, line 1278
abnormal program termination
make: *** [prn8.do_the_test] Error 3
|
