r - format_types.go
1 package r
2
3 // File automatically generated with format.sh.
4
5 import "io"
6
7 func (f *AdditionExpression) printType(w io.Writer, v bool) {
8 pp := indentPrinter{w}
9
10 pp.Print("AdditionExpression {")
11
12 pp.Print("\nMultiplicationExpression: ")
13 f.MultiplicationExpression.printType(&pp, v)
14
15 pp.Print("\nAdditionType: ")
16 f.AdditionType.printType(&pp, v)
17
18 if f.AdditionExpression != nil {
19 pp.Print("\nAdditionExpression: ")
20 f.AdditionExpression.printType(&pp, v)
21 } else if v {
22 pp.Print("\nAdditionExpression: nil")
23 }
24 pp.Print("\nComments: [")
25
26 ipp := indentPrinter{&pp}
27
28 for n, e := range f.Comments {
29 ipp.Printf("\n%d: ", n)
30 e.printType(&ipp, v)
31 }
32
33 pp.Print("\n]")
34
35 pp.Print("\nTokens: ")
36 f.Tokens.printType(&pp, v)
37
38 io.WriteString(w, "\n}")
39 }
40
41 func (f *AndExpression) printType(w io.Writer, v bool) {
42 pp := indentPrinter{w}
43
44 pp.Print("AndExpression {")
45
46 pp.Print("\nNotExpression: ")
47 f.NotExpression.printType(&pp, v)
48
49 pp.Print("\nAndType: ")
50 f.AndType.printType(&pp, v)
51
52 if f.AndExpression != nil {
53 pp.Print("\nAndExpression: ")
54 f.AndExpression.printType(&pp, v)
55 } else if v {
56 pp.Print("\nAndExpression: nil")
57 }
58 pp.Print("\nComments: [")
59
60 ipp := indentPrinter{&pp}
61
62 for n, e := range f.Comments {
63 ipp.Printf("\n%d: ", n)
64 e.printType(&ipp, v)
65 }
66
67 pp.Print("\n]")
68
69 pp.Print("\nTokens: ")
70 f.Tokens.printType(&pp, v)
71
72 io.WriteString(w, "\n}")
73 }
74
75 func (f *Arg) printType(w io.Writer, v bool) {
76 pp := indentPrinter{w}
77
78 pp.Print("Arg {")
79
80 if f.QueryExpression != nil {
81 pp.Print("\nQueryExpression: ")
82 f.QueryExpression.printType(&pp, v)
83 } else if v {
84 pp.Print("\nQueryExpression: nil")
85 }
86
87 if f.Ellipsis != nil {
88 pp.Print("\nEllipsis: ")
89 f.Ellipsis.printType(&pp, v)
90 } else if v {
91 pp.Print("\nEllipsis: nil")
92 }
93 pp.Print("\nComments: [")
94
95 ipp := indentPrinter{&pp}
96
97 for n, e := range f.Comments {
98 ipp.Printf("\n%d: ", n)
99 e.printType(&ipp, v)
100 }
101
102 pp.Print("\n]")
103
104 pp.Print("\nTokens: ")
105 f.Tokens.printType(&pp, v)
106
107 io.WriteString(w, "\n}")
108 }
109
110 func (f *ArgList) printType(w io.Writer, v bool) {
111 pp := indentPrinter{w}
112
113 pp.Print("ArgList {")
114
115 if f.Args == nil {
116 pp.Print("\nArgs: nil")
117 } else if len(f.Args) > 0 {
118 pp.Print("\nArgs: [")
119
120 ipp := indentPrinter{&pp}
121
122 for n, e := range f.Args {
123 ipp.Printf("\n%d: ", n)
124 e.printType(&ipp, v)
125 }
126
127 pp.Print("\n]")
128 } else if v {
129 pp.Print("\nArgs: []")
130 }
131
132 pp.Print("\nComments: ")
133 f.Comments.printType(&pp, v)
134
135 pp.Print("\nTokens: ")
136 f.Tokens.printType(&pp, v)
137
138 io.WriteString(w, "\n}")
139 }
140
141 func (f *Argument) printType(w io.Writer, v bool) {
142 pp := indentPrinter{w}
143
144 pp.Print("Argument {")
145
146 if f.Identifier != nil {
147 pp.Print("\nIdentifier: ")
148 f.Identifier.printType(&pp, v)
149 } else if v {
150 pp.Print("\nIdentifier: nil")
151 }
152
153 if f.Default != nil {
154 pp.Print("\nDefault: ")
155 f.Default.printType(&pp, v)
156 } else if v {
157 pp.Print("\nDefault: nil")
158 }
159 pp.Print("\nComments: [")
160
161 ipp := indentPrinter{&pp}
162
163 for n, e := range f.Comments {
164 ipp.Printf("\n%d: ", n)
165 e.printType(&ipp, v)
166 }
167
168 pp.Print("\n]")
169
170 pp.Print("\nTokens: ")
171 f.Tokens.printType(&pp, v)
172
173 io.WriteString(w, "\n}")
174 }
175
176 func (f *AssignmentExpression) printType(w io.Writer, v bool) {
177 pp := indentPrinter{w}
178
179 pp.Print("AssignmentExpression {")
180
181 pp.Print("\nFormulaeExpression: ")
182 f.FormulaeExpression.printType(&pp, v)
183
184 pp.Print("\nAssignmentType: ")
185 f.AssignmentType.printType(&pp, v)
186
187 if f.AssignmentExpression != nil {
188 pp.Print("\nAssignmentExpression: ")
189 f.AssignmentExpression.printType(&pp, v)
190 } else if v {
191 pp.Print("\nAssignmentExpression: nil")
192 }
193 pp.Print("\nComments: [")
194
195 ipp := indentPrinter{&pp}
196
197 for n, e := range f.Comments {
198 ipp.Printf("\n%d: ", n)
199 e.printType(&ipp, v)
200 }
201
202 pp.Print("\n]")
203
204 pp.Print("\nTokens: ")
205 f.Tokens.printType(&pp, v)
206
207 io.WriteString(w, "\n}")
208 }
209
210 func (f *Call) printType(w io.Writer, v bool) {
211 pp := indentPrinter{w}
212
213 pp.Print("Call {")
214
215 if f.Args == nil {
216 pp.Print("\nArgs: nil")
217 } else if len(f.Args) > 0 {
218 pp.Print("\nArgs: [")
219
220 ipp := indentPrinter{&pp}
221
222 for n, e := range f.Args {
223 ipp.Printf("\n%d: ", n)
224 e.printType(&ipp, v)
225 }
226
227 pp.Print("\n]")
228 } else if v {
229 pp.Print("\nArgs: []")
230 }
231
232 pp.Print("\nComments: ")
233 f.Comments.printType(&pp, v)
234
235 pp.Print("\nTokens: ")
236 f.Tokens.printType(&pp, v)
237
238 io.WriteString(w, "\n}")
239 }
240
241 func (f *CompoundExpression) printType(w io.Writer, v bool) {
242 pp := indentPrinter{w}
243
244 pp.Print("CompoundExpression {")
245
246 if f.Expressions == nil {
247 pp.Print("\nExpressions: nil")
248 } else if len(f.Expressions) > 0 {
249 pp.Print("\nExpressions: [")
250
251 ipp := indentPrinter{&pp}
252
253 for n, e := range f.Expressions {
254 ipp.Printf("\n%d: ", n)
255 e.printType(&ipp, v)
256 }
257
258 pp.Print("\n]")
259 } else if v {
260 pp.Print("\nExpressions: []")
261 }
262
263 pp.Print("\nComments: ")
264 f.Comments.printType(&pp, v)
265
266 pp.Print("\nTokens: ")
267 f.Tokens.printType(&pp, v)
268
269 io.WriteString(w, "\n}")
270 }
271
272 func (f *ExponentiationExpression) printType(w io.Writer, v bool) {
273 pp := indentPrinter{w}
274
275 pp.Print("ExponentiationExpression {")
276
277 pp.Print("\nSubsetExpression: ")
278 f.SubsetExpression.printType(&pp, v)
279
280 if f.ExponentiationExpression != nil {
281 pp.Print("\nExponentiationExpression: ")
282 f.ExponentiationExpression.printType(&pp, v)
283 } else if v {
284 pp.Print("\nExponentiationExpression: nil")
285 }
286 pp.Print("\nComments: [")
287
288 ipp := indentPrinter{&pp}
289
290 for n, e := range f.Comments {
291 ipp.Printf("\n%d: ", n)
292 e.printType(&ipp, v)
293 }
294
295 pp.Print("\n]")
296
297 pp.Print("\nTokens: ")
298 f.Tokens.printType(&pp, v)
299
300 io.WriteString(w, "\n}")
301 }
302
303 func (f *Expression) printType(w io.Writer, v bool) {
304 pp := indentPrinter{w}
305
306 pp.Print("Expression {")
307
308 if f.FlowControl != nil {
309 pp.Print("\nFlowControl: ")
310 f.FlowControl.printType(&pp, v)
311 } else if v {
312 pp.Print("\nFlowControl: nil")
313 }
314
315 if f.FunctionDefinition != nil {
316 pp.Print("\nFunctionDefinition: ")
317 f.FunctionDefinition.printType(&pp, v)
318 } else if v {
319 pp.Print("\nFunctionDefinition: nil")
320 }
321
322 if f.QueryExpression != nil {
323 pp.Print("\nQueryExpression: ")
324 f.QueryExpression.printType(&pp, v)
325 } else if v {
326 pp.Print("\nQueryExpression: nil")
327 }
328 pp.Print("\nComments: [")
329
330 ipp := indentPrinter{&pp}
331
332 for n, e := range f.Comments {
333 ipp.Printf("\n%d: ", n)
334 e.printType(&ipp, v)
335 }
336
337 pp.Print("\n]")
338
339 pp.Print("\nTokens: ")
340 f.Tokens.printType(&pp, v)
341
342 io.WriteString(w, "\n}")
343 }
344
345 func (f *File) printType(w io.Writer, v bool) {
346 pp := indentPrinter{w}
347
348 pp.Print("File {")
349
350 if f.Statements == nil {
351 pp.Print("\nStatements: nil")
352 } else if len(f.Statements) > 0 {
353 pp.Print("\nStatements: [")
354
355 ipp := indentPrinter{&pp}
356
357 for n, e := range f.Statements {
358 ipp.Printf("\n%d: ", n)
359 e.printType(&ipp, v)
360 }
361
362 pp.Print("\n]")
363 } else if v {
364 pp.Print("\nStatements: []")
365 }
366
367 pp.Print("\nComments: ")
368 f.Comments.printType(&pp, v)
369
370 pp.Print("\nTokens: ")
371 f.Tokens.printType(&pp, v)
372
373 io.WriteString(w, "\n}")
374 }
375
376 func (f *FlowControl) printType(w io.Writer, v bool) {
377 pp := indentPrinter{w}
378
379 pp.Print("FlowControl {")
380
381 if f.IfControl != nil {
382 pp.Print("\nIfControl: ")
383 f.IfControl.printType(&pp, v)
384 } else if v {
385 pp.Print("\nIfControl: nil")
386 }
387
388 if f.WhileControl != nil {
389 pp.Print("\nWhileControl: ")
390 f.WhileControl.printType(&pp, v)
391 } else if v {
392 pp.Print("\nWhileControl: nil")
393 }
394
395 if f.RepeatControl != nil {
396 pp.Print("\nRepeatControl: ")
397 f.RepeatControl.printType(&pp, v)
398 } else if v {
399 pp.Print("\nRepeatControl: nil")
400 }
401
402 if f.ForControl != nil {
403 pp.Print("\nForControl: ")
404 f.ForControl.printType(&pp, v)
405 } else if v {
406 pp.Print("\nForControl: nil")
407 }
408
409 pp.Print("\nTokens: ")
410 f.Tokens.printType(&pp, v)
411
412 io.WriteString(w, "\n}")
413 }
414
415 func (f *ForControl) printType(w io.Writer, v bool) {
416 pp := indentPrinter{w}
417
418 pp.Print("ForControl {")
419
420 if f.Var != nil {
421 pp.Print("\nVar: ")
422 f.Var.printType(&pp, v)
423 } else if v {
424 pp.Print("\nVar: nil")
425 }
426
427 pp.Print("\nList: ")
428 f.List.printType(&pp, v)
429
430 pp.Print("\nExpr: ")
431 f.Expr.printType(&pp, v)
432 pp.Print("\nComments: [")
433
434 ipp := indentPrinter{&pp}
435
436 for n, e := range f.Comments {
437 ipp.Printf("\n%d: ", n)
438 e.printType(&ipp, v)
439 }
440
441 pp.Print("\n]")
442
443 pp.Print("\nTokens: ")
444 f.Tokens.printType(&pp, v)
445
446 io.WriteString(w, "\n}")
447 }
448
449 func (f *FormulaeExpression) printType(w io.Writer, v bool) {
450 pp := indentPrinter{w}
451
452 pp.Print("FormulaeExpression {")
453
454 if f.OrExpression != nil {
455 pp.Print("\nOrExpression: ")
456 f.OrExpression.printType(&pp, v)
457 } else if v {
458 pp.Print("\nOrExpression: nil")
459 }
460
461 if f.FormulaeExpression != nil {
462 pp.Print("\nFormulaeExpression: ")
463 f.FormulaeExpression.printType(&pp, v)
464 } else if v {
465 pp.Print("\nFormulaeExpression: nil")
466 }
467
468 pp.Print("\nComments: ")
469 f.Comments.printType(&pp, v)
470
471 pp.Print("\nTokens: ")
472 f.Tokens.printType(&pp, v)
473
474 io.WriteString(w, "\n}")
475 }
476
477 func (f *FunctionDefinition) printType(w io.Writer, v bool) {
478 pp := indentPrinter{w}
479
480 pp.Print("FunctionDefinition {")
481
482 pp.Print("\nArgList: ")
483 f.ArgList.printType(&pp, v)
484
485 pp.Print("\nBody: ")
486 f.Body.printType(&pp, v)
487
488 pp.Print("\nComments: ")
489 f.Comments.printType(&pp, v)
490
491 pp.Print("\nTokens: ")
492 f.Tokens.printType(&pp, v)
493
494 io.WriteString(w, "\n}")
495 }
496
497 func (f *IfControl) printType(w io.Writer, v bool) {
498 pp := indentPrinter{w}
499
500 pp.Print("IfControl {")
501
502 pp.Print("\nCond: ")
503 f.Cond.printType(&pp, v)
504
505 pp.Print("\nExpr: ")
506 f.Expr.printType(&pp, v)
507
508 if f.Else != nil {
509 pp.Print("\nElse: ")
510 f.Else.printType(&pp, v)
511 } else if v {
512 pp.Print("\nElse: nil")
513 }
514 pp.Print("\nComments: [")
515
516 ipp := indentPrinter{&pp}
517
518 for n, e := range f.Comments {
519 ipp.Printf("\n%d: ", n)
520 e.printType(&ipp, v)
521 }
522
523 pp.Print("\n]")
524
525 pp.Print("\nTokens: ")
526 f.Tokens.printType(&pp, v)
527
528 io.WriteString(w, "\n}")
529 }
530
531 func (f *Index) printType(w io.Writer, v bool) {
532 pp := indentPrinter{w}
533
534 pp.Print("Index {")
535
536 if f.Double || v {
537 pp.Printf("\nDouble: %v", f.Double)
538 }
539
540 if f.Args == nil {
541 pp.Print("\nArgs: nil")
542 } else if len(f.Args) > 0 {
543 pp.Print("\nArgs: [")
544
545 ipp := indentPrinter{&pp}
546
547 for n, e := range f.Args {
548 ipp.Printf("\n%d: ", n)
549 e.printType(&ipp, v)
550 }
551
552 pp.Print("\n]")
553 } else if v {
554 pp.Print("\nArgs: []")
555 }
556
557 pp.Print("\nTokens: ")
558 f.Tokens.printType(&pp, v)
559
560 io.WriteString(w, "\n}")
561 }
562
563 func (f *IndexExpression) printType(w io.Writer, v bool) {
564 pp := indentPrinter{w}
565
566 pp.Print("IndexExpression {")
567
568 pp.Print("\nQueryExpression: ")
569 f.QueryExpression.printType(&pp, v)
570 pp.Print("\nComments: [")
571
572 ipp := indentPrinter{&pp}
573
574 for n, e := range f.Comments {
575 ipp.Printf("\n%d: ", n)
576 e.printType(&ipp, v)
577 }
578
579 pp.Print("\n]")
580
581 pp.Print("\nTokens: ")
582 f.Tokens.printType(&pp, v)
583
584 io.WriteString(w, "\n}")
585 }
586
587 func (f *IndexOrCallExpression) printType(w io.Writer, v bool) {
588 pp := indentPrinter{w}
589
590 pp.Print("IndexOrCallExpression {")
591
592 if f.SimpleExpression != nil {
593 pp.Print("\nSimpleExpression: ")
594 f.SimpleExpression.printType(&pp, v)
595 } else if v {
596 pp.Print("\nSimpleExpression: nil")
597 }
598
599 if f.IndexOrCallExpression != nil {
600 pp.Print("\nIndexOrCallExpression: ")
601 f.IndexOrCallExpression.printType(&pp, v)
602 } else if v {
603 pp.Print("\nIndexOrCallExpression: nil")
604 }
605
606 if f.Index != nil {
607 pp.Print("\nIndex: ")
608 f.Index.printType(&pp, v)
609 } else if v {
610 pp.Print("\nIndex: nil")
611 }
612
613 if f.Call != nil {
614 pp.Print("\nCall: ")
615 f.Call.printType(&pp, v)
616 } else if v {
617 pp.Print("\nCall: nil")
618 }
619
620 pp.Print("\nComments: ")
621 f.Comments.printType(&pp, v)
622
623 pp.Print("\nTokens: ")
624 f.Tokens.printType(&pp, v)
625
626 io.WriteString(w, "\n}")
627 }
628
629 func (f *MultiplicationExpression) printType(w io.Writer, v bool) {
630 pp := indentPrinter{w}
631
632 pp.Print("MultiplicationExpression {")
633
634 pp.Print("\nPipeOrSpecialExpression: ")
635 f.PipeOrSpecialExpression.printType(&pp, v)
636
637 pp.Print("\nMultiplicationType: ")
638 f.MultiplicationType.printType(&pp, v)
639
640 if f.MultiplicationExpression != nil {
641 pp.Print("\nMultiplicationExpression: ")
642 f.MultiplicationExpression.printType(&pp, v)
643 } else if v {
644 pp.Print("\nMultiplicationExpression: nil")
645 }
646 pp.Print("\nComments: [")
647
648 ipp := indentPrinter{&pp}
649
650 for n, e := range f.Comments {
651 ipp.Printf("\n%d: ", n)
652 e.printType(&ipp, v)
653 }
654
655 pp.Print("\n]")
656
657 pp.Print("\nTokens: ")
658 f.Tokens.printType(&pp, v)
659
660 io.WriteString(w, "\n}")
661 }
662
663 func (f *NotExpression) printType(w io.Writer, v bool) {
664 pp := indentPrinter{w}
665
666 pp.Print("NotExpression {")
667
668 if f.Nots != 0 || v {
669 pp.Printf("\nNots: %v", f.Nots)
670 }
671
672 pp.Print("\nRelationalExpression: ")
673 f.RelationalExpression.printType(&pp, v)
674
675 if f.Comments == nil {
676 pp.Print("\nComments: nil")
677 } else if len(f.Comments) > 0 {
678 pp.Print("\nComments: [")
679
680 ipp := indentPrinter{&pp}
681
682 for n, e := range f.Comments {
683 ipp.Printf("\n%d: ", n)
684 e.printType(&ipp, v)
685 }
686
687 pp.Print("\n]")
688 } else if v {
689 pp.Print("\nComments: []")
690 }
691
692 pp.Print("\nTokens: ")
693 f.Tokens.printType(&pp, v)
694
695 io.WriteString(w, "\n}")
696 }
697
698 func (f *OrExpression) printType(w io.Writer, v bool) {
699 pp := indentPrinter{w}
700
701 pp.Print("OrExpression {")
702
703 pp.Print("\nAndExpression: ")
704 f.AndExpression.printType(&pp, v)
705
706 pp.Print("\nOrType: ")
707 f.OrType.printType(&pp, v)
708
709 if f.OrExpression != nil {
710 pp.Print("\nOrExpression: ")
711 f.OrExpression.printType(&pp, v)
712 } else if v {
713 pp.Print("\nOrExpression: nil")
714 }
715 pp.Print("\nComments: [")
716
717 ipp := indentPrinter{&pp}
718
719 for n, e := range f.Comments {
720 ipp.Printf("\n%d: ", n)
721 e.printType(&ipp, v)
722 }
723
724 pp.Print("\n]")
725
726 pp.Print("\nTokens: ")
727 f.Tokens.printType(&pp, v)
728
729 io.WriteString(w, "\n}")
730 }
731
732 func (f *ParenthesizedExpression) printType(w io.Writer, v bool) {
733 pp := indentPrinter{w}
734
735 pp.Print("ParenthesizedExpression {")
736
737 pp.Print("\nExpression: ")
738 f.Expression.printType(&pp, v)
739
740 pp.Print("\nTokens: ")
741 f.Tokens.printType(&pp, v)
742
743 io.WriteString(w, "\n}")
744 }
745
746 func (f *PipeOrSpecialExpression) printType(w io.Writer, v bool) {
747 pp := indentPrinter{w}
748
749 pp.Print("PipeOrSpecialExpression {")
750
751 pp.Print("\nSequenceExpression: ")
752 f.SequenceExpression.printType(&pp, v)
753
754 if f.Operator != nil {
755 pp.Print("\nOperator: ")
756 f.Operator.printType(&pp, v)
757 } else if v {
758 pp.Print("\nOperator: nil")
759 }
760
761 if f.PipeOrSpecialExpression != nil {
762 pp.Print("\nPipeOrSpecialExpression: ")
763 f.PipeOrSpecialExpression.printType(&pp, v)
764 } else if v {
765 pp.Print("\nPipeOrSpecialExpression: nil")
766 }
767 pp.Print("\nComments: [")
768
769 ipp := indentPrinter{&pp}
770
771 for n, e := range f.Comments {
772 ipp.Printf("\n%d: ", n)
773 e.printType(&ipp, v)
774 }
775
776 pp.Print("\n]")
777
778 pp.Print("\nTokens: ")
779 f.Tokens.printType(&pp, v)
780
781 io.WriteString(w, "\n}")
782 }
783
784 func (f *QueryExpression) printType(w io.Writer, v bool) {
785 pp := indentPrinter{w}
786
787 pp.Print("QueryExpression {")
788
789 if f.AssignmentExpression != nil {
790 pp.Print("\nAssignmentExpression: ")
791 f.AssignmentExpression.printType(&pp, v)
792 } else if v {
793 pp.Print("\nAssignmentExpression: nil")
794 }
795
796 if f.QueryExpression != nil {
797 pp.Print("\nQueryExpression: ")
798 f.QueryExpression.printType(&pp, v)
799 } else if v {
800 pp.Print("\nQueryExpression: nil")
801 }
802 pp.Print("\nComments: [")
803
804 ipp := indentPrinter{&pp}
805
806 for n, e := range f.Comments {
807 ipp.Printf("\n%d: ", n)
808 e.printType(&ipp, v)
809 }
810
811 pp.Print("\n]")
812
813 pp.Print("\nTokens: ")
814 f.Tokens.printType(&pp, v)
815
816 io.WriteString(w, "\n}")
817 }
818
819 func (f *RelationalExpression) printType(w io.Writer, v bool) {
820 pp := indentPrinter{w}
821
822 pp.Print("RelationalExpression {")
823
824 pp.Print("\nAdditionExpression: ")
825 f.AdditionExpression.printType(&pp, v)
826
827 pp.Print("\nRelationalOperator: ")
828 f.RelationalOperator.printType(&pp, v)
829
830 if f.RelationalExpression != nil {
831 pp.Print("\nRelationalExpression: ")
832 f.RelationalExpression.printType(&pp, v)
833 } else if v {
834 pp.Print("\nRelationalExpression: nil")
835 }
836 pp.Print("\nComments: [")
837
838 ipp := indentPrinter{&pp}
839
840 for n, e := range f.Comments {
841 ipp.Printf("\n%d: ", n)
842 e.printType(&ipp, v)
843 }
844
845 pp.Print("\n]")
846
847 pp.Print("\nTokens: ")
848 f.Tokens.printType(&pp, v)
849
850 io.WriteString(w, "\n}")
851 }
852
853 func (f *RepeatControl) printType(w io.Writer, v bool) {
854 pp := indentPrinter{w}
855
856 pp.Print("RepeatControl {")
857
858 pp.Print("\nExpr: ")
859 f.Expr.printType(&pp, v)
860
861 pp.Print("\nTokens: ")
862 f.Tokens.printType(&pp, v)
863
864 io.WriteString(w, "\n}")
865 }
866
867 func (f *ScopeExpression) printType(w io.Writer, v bool) {
868 pp := indentPrinter{w}
869
870 pp.Print("ScopeExpression {")
871
872 pp.Print("\nIndexOrCallExpression: ")
873 f.IndexOrCallExpression.printType(&pp, v)
874
875 if f.ScopeExpression != nil {
876 pp.Print("\nScopeExpression: ")
877 f.ScopeExpression.printType(&pp, v)
878 } else if v {
879 pp.Print("\nScopeExpression: nil")
880 }
881 pp.Print("\nComments: [")
882
883 ipp := indentPrinter{&pp}
884
885 for n, e := range f.Comments {
886 ipp.Printf("\n%d: ", n)
887 e.printType(&ipp, v)
888 }
889
890 pp.Print("\n]")
891
892 pp.Print("\nTokens: ")
893 f.Tokens.printType(&pp, v)
894
895 io.WriteString(w, "\n}")
896 }
897
898 func (f *SequenceExpression) printType(w io.Writer, v bool) {
899 pp := indentPrinter{w}
900
901 pp.Print("SequenceExpression {")
902
903 pp.Print("\nUnaryExpression: ")
904 f.UnaryExpression.printType(&pp, v)
905
906 if f.SequenceExpression != nil {
907 pp.Print("\nSequenceExpression: ")
908 f.SequenceExpression.printType(&pp, v)
909 } else if v {
910 pp.Print("\nSequenceExpression: nil")
911 }
912 pp.Print("\nComments: [")
913
914 ipp := indentPrinter{&pp}
915
916 for n, e := range f.Comments {
917 ipp.Printf("\n%d: ", n)
918 e.printType(&ipp, v)
919 }
920
921 pp.Print("\n]")
922
923 pp.Print("\nTokens: ")
924 f.Tokens.printType(&pp, v)
925
926 io.WriteString(w, "\n}")
927 }
928
929 func (f *SimpleExpression) printType(w io.Writer, v bool) {
930 pp := indentPrinter{w}
931
932 pp.Print("SimpleExpression {")
933
934 if f.Identifier != nil {
935 pp.Print("\nIdentifier: ")
936 f.Identifier.printType(&pp, v)
937 } else if v {
938 pp.Print("\nIdentifier: nil")
939 }
940
941 if f.Constant != nil {
942 pp.Print("\nConstant: ")
943 f.Constant.printType(&pp, v)
944 } else if v {
945 pp.Print("\nConstant: nil")
946 }
947
948 if f.Ellipsis != nil {
949 pp.Print("\nEllipsis: ")
950 f.Ellipsis.printType(&pp, v)
951 } else if v {
952 pp.Print("\nEllipsis: nil")
953 }
954
955 if f.ParenthesizedExpression != nil {
956 pp.Print("\nParenthesizedExpression: ")
957 f.ParenthesizedExpression.printType(&pp, v)
958 } else if v {
959 pp.Print("\nParenthesizedExpression: nil")
960 }
961
962 if f.CompoundExpression != nil {
963 pp.Print("\nCompoundExpression: ")
964 f.CompoundExpression.printType(&pp, v)
965 } else if v {
966 pp.Print("\nCompoundExpression: nil")
967 }
968
969 pp.Print("\nTokens: ")
970 f.Tokens.printType(&pp, v)
971
972 io.WriteString(w, "\n}")
973 }
974
975 func (f *SubsetExpression) printType(w io.Writer, v bool) {
976 pp := indentPrinter{w}
977
978 pp.Print("SubsetExpression {")
979
980 pp.Print("\nScopeExpression: ")
981 f.ScopeExpression.printType(&pp, v)
982
983 pp.Print("\nSubsetType: ")
984 f.SubsetType.printType(&pp, v)
985
986 if f.SubsetExpression != nil {
987 pp.Print("\nSubsetExpression: ")
988 f.SubsetExpression.printType(&pp, v)
989 } else if v {
990 pp.Print("\nSubsetExpression: nil")
991 }
992 pp.Print("\nComments: [")
993
994 ipp := indentPrinter{&pp}
995
996 for n, e := range f.Comments {
997 ipp.Printf("\n%d: ", n)
998 e.printType(&ipp, v)
999 }
1000
1001 pp.Print("\n]")
1002
1003 pp.Print("\nTokens: ")
1004 f.Tokens.printType(&pp, v)
1005
1006 io.WriteString(w, "\n}")
1007 }
1008
1009 func (f *UnaryExpression) printType(w io.Writer, v bool) {
1010 pp := indentPrinter{w}
1011
1012 pp.Print("UnaryExpression {")
1013
1014 if f.UnaryType == nil {
1015 pp.Print("\nUnaryType: nil")
1016 } else if len(f.UnaryType) > 0 {
1017 pp.Print("\nUnaryType: [")
1018
1019 ipp := indentPrinter{&pp}
1020
1021 for n, e := range f.UnaryType {
1022 ipp.Printf("\n%d: ", n)
1023 e.printType(&ipp, v)
1024 }
1025
1026 pp.Print("\n]")
1027 } else if v {
1028 pp.Print("\nUnaryType: []")
1029 }
1030
1031 pp.Print("\nExponentiationExpression: ")
1032 f.ExponentiationExpression.printType(&pp, v)
1033
1034 if f.Comments == nil {
1035 pp.Print("\nComments: nil")
1036 } else if len(f.Comments) > 0 {
1037 pp.Print("\nComments: [")
1038
1039 ipp := indentPrinter{&pp}
1040
1041 for n, e := range f.Comments {
1042 ipp.Printf("\n%d: ", n)
1043 e.printType(&ipp, v)
1044 }
1045
1046 pp.Print("\n]")
1047 } else if v {
1048 pp.Print("\nComments: []")
1049 }
1050
1051 pp.Print("\nTokens: ")
1052 f.Tokens.printType(&pp, v)
1053
1054 io.WriteString(w, "\n}")
1055 }
1056
1057 func (f *WhileControl) printType(w io.Writer, v bool) {
1058 pp := indentPrinter{w}
1059
1060 pp.Print("WhileControl {")
1061
1062 pp.Print("\nCond: ")
1063 f.Cond.printType(&pp, v)
1064
1065 pp.Print("\nExpr: ")
1066 f.Expr.printType(&pp, v)
1067 pp.Print("\nComments: [")
1068
1069 ipp := indentPrinter{&pp}
1070
1071 for n, e := range f.Comments {
1072 ipp.Printf("\n%d: ", n)
1073 e.printType(&ipp, v)
1074 }
1075
1076 pp.Print("\n]")
1077
1078 pp.Print("\nTokens: ")
1079 f.Tokens.printType(&pp, v)
1080
1081 io.WriteString(w, "\n}")
1082 }
1083