bash - format_types.go
1 package bash
2
3 // File automatically generated with format.sh.
4
5 import "io"
6
7 func (f *ArithmeticExpansion) printType(w io.Writer, v bool) {
8 pp := indentPrinter{w}
9
10 pp.Print("ArithmeticExpansion {")
11
12 if f.WordsAndOperators == nil {
13 pp.Print("\nWordsAndOperators: nil")
14 } else if len(f.WordsAndOperators) > 0 {
15 pp.Print("\nWordsAndOperators: [")
16
17 ipp := indentPrinter{&pp}
18
19 for n, e := range f.WordsAndOperators {
20 ipp.Printf("\n%d: ", n)
21 e.printType(&ipp, v)
22 }
23
24 pp.Print("\n]")
25 } else if v {
26 pp.Print("\nWordsAndOperators: []")
27 }
28
29 pp.Print("\nTokens: ")
30 f.Tokens.printType(&pp, v)
31
32 io.WriteString(w, "\n}")
33 }
34
35 func (f *Assignment) printType(w io.Writer, v bool) {
36 pp := indentPrinter{w}
37
38 pp.Print("Assignment {")
39
40 pp.Print("\nIdentifier: ")
41 f.Identifier.printType(&pp, v)
42
43 pp.Print("\nAssignment: ")
44 f.Assignment.printType(&pp, v)
45
46 pp.Print("\nValue: ")
47 f.Value.printType(&pp, v)
48
49 pp.Print("\nTokens: ")
50 f.Tokens.printType(&pp, v)
51
52 io.WriteString(w, "\n}")
53 }
54
55 func (f *Command) printType(w io.Writer, v bool) {
56 pp := indentPrinter{w}
57
58 pp.Print("Command {")
59
60 if f.Vars == nil {
61 pp.Print("\nVars: nil")
62 } else if len(f.Vars) > 0 {
63 pp.Print("\nVars: [")
64
65 ipp := indentPrinter{&pp}
66
67 for n, e := range f.Vars {
68 ipp.Printf("\n%d: ", n)
69 e.printType(&ipp, v)
70 }
71
72 pp.Print("\n]")
73 } else if v {
74 pp.Print("\nVars: []")
75 }
76
77 if f.Redirections == nil {
78 pp.Print("\nRedirections: nil")
79 } else if len(f.Redirections) > 0 {
80 pp.Print("\nRedirections: [")
81
82 ipp := indentPrinter{&pp}
83
84 for n, e := range f.Redirections {
85 ipp.Printf("\n%d: ", n)
86 e.printType(&ipp, v)
87 }
88
89 pp.Print("\n]")
90 } else if v {
91 pp.Print("\nRedirections: []")
92 }
93
94 if f.Words == nil {
95 pp.Print("\nWords: nil")
96 } else if len(f.Words) > 0 {
97 pp.Print("\nWords: [")
98
99 ipp := indentPrinter{&pp}
100
101 for n, e := range f.Words {
102 ipp.Printf("\n%d: ", n)
103 e.printType(&ipp, v)
104 }
105
106 pp.Print("\n]")
107 } else if v {
108 pp.Print("\nWords: []")
109 }
110
111 pp.Print("\nTokens: ")
112 f.Tokens.printType(&pp, v)
113
114 io.WriteString(w, "\n}")
115 }
116
117 func (f *CommandOrCompound) printType(w io.Writer, v bool) {
118 pp := indentPrinter{w}
119
120 pp.Print("CommandOrCompound {")
121
122 if f.Command != nil {
123 pp.Print("\nCommand: ")
124 f.Command.printType(&pp, v)
125 } else if v {
126 pp.Print("\nCommand: nil")
127 }
128
129 if f.Compound != nil {
130 pp.Print("\nCompound: ")
131 f.Compound.printType(&pp, v)
132 } else if v {
133 pp.Print("\nCompound: nil")
134 }
135
136 pp.Print("\nTokens: ")
137 f.Tokens.printType(&pp, v)
138
139 io.WriteString(w, "\n}")
140 }
141
142 func (f *CommandSubstitution) printType(w io.Writer, v bool) {
143 pp := indentPrinter{w}
144
145 pp.Print("CommandSubstitution {")
146
147 pp.Print("\nSubstitutionType: ")
148 f.SubstitutionType.printType(&pp, v)
149
150 pp.Print("\nCommand: ")
151 f.Command.printType(&pp, v)
152
153 pp.Print("\nTokens: ")
154 f.Tokens.printType(&pp, v)
155
156 io.WriteString(w, "\n}")
157 }
158
159 func (f *Compound) printType(w io.Writer, v bool) {
160 pp := indentPrinter{w}
161
162 pp.Print("Compound {")
163
164 pp.Print("\nTokens: ")
165 f.Tokens.printType(&pp, v)
166
167 io.WriteString(w, "\n}")
168 }
169
170 func (f *File) printType(w io.Writer, v bool) {
171 pp := indentPrinter{w}
172
173 pp.Print("File {")
174
175 if f.Lines == nil {
176 pp.Print("\nLines: nil")
177 } else if len(f.Lines) > 0 {
178 pp.Print("\nLines: [")
179
180 ipp := indentPrinter{&pp}
181
182 for n, e := range f.Lines {
183 ipp.Printf("\n%d: ", n)
184 e.printType(&ipp, v)
185 }
186
187 pp.Print("\n]")
188 } else if v {
189 pp.Print("\nLines: []")
190 }
191
192 pp.Print("\nTokens: ")
193 f.Tokens.printType(&pp, v)
194
195 io.WriteString(w, "\n}")
196 }
197
198 func (f *Heredoc) printType(w io.Writer, v bool) {
199 pp := indentPrinter{w}
200
201 pp.Print("Heredoc {")
202
203 if f.HeredocPartsOrWords == nil {
204 pp.Print("\nHeredocPartsOrWords: nil")
205 } else if len(f.HeredocPartsOrWords) > 0 {
206 pp.Print("\nHeredocPartsOrWords: [")
207
208 ipp := indentPrinter{&pp}
209
210 for n, e := range f.HeredocPartsOrWords {
211 ipp.Printf("\n%d: ", n)
212 e.printType(&ipp, v)
213 }
214
215 pp.Print("\n]")
216 } else if v {
217 pp.Print("\nHeredocPartsOrWords: []")
218 }
219
220 pp.Print("\nTokens: ")
221 f.Tokens.printType(&pp, v)
222
223 io.WriteString(w, "\n}")
224 }
225
226 func (f *HeredocPartOrWord) printType(w io.Writer, v bool) {
227 pp := indentPrinter{w}
228
229 pp.Print("HeredocPartOrWord {")
230
231 if f.HeredocPart != nil {
232 pp.Print("\nHeredocPart: ")
233 f.HeredocPart.printType(&pp, v)
234 } else if v {
235 pp.Print("\nHeredocPart: nil")
236 }
237
238 if f.Word != nil {
239 pp.Print("\nWord: ")
240 f.Word.printType(&pp, v)
241 } else if v {
242 pp.Print("\nWord: nil")
243 }
244
245 pp.Print("\nTokens: ")
246 f.Tokens.printType(&pp, v)
247
248 io.WriteString(w, "\n}")
249 }
250
251 func (f *Line) printType(w io.Writer, v bool) {
252 pp := indentPrinter{w}
253
254 pp.Print("Line {")
255
256 if f.Statements == nil {
257 pp.Print("\nStatements: nil")
258 } else if len(f.Statements) > 0 {
259 pp.Print("\nStatements: [")
260
261 ipp := indentPrinter{&pp}
262
263 for n, e := range f.Statements {
264 ipp.Printf("\n%d: ", n)
265 e.printType(&ipp, v)
266 }
267
268 pp.Print("\n]")
269 } else if v {
270 pp.Print("\nStatements: []")
271 }
272
273 pp.Print("\nTokens: ")
274 f.Tokens.printType(&pp, v)
275
276 io.WriteString(w, "\n}")
277 }
278
279 func (f *Parameter) printType(w io.Writer, v bool) {
280 pp := indentPrinter{w}
281
282 pp.Print("Parameter {")
283
284 if f.Parameter != nil {
285 pp.Print("\nParameter: ")
286 f.Parameter.printType(&pp, v)
287 } else if v {
288 pp.Print("\nParameter: nil")
289 }
290
291 if f.Array != nil {
292 pp.Print("\nArray: ")
293 f.Array.printType(&pp, v)
294 } else if v {
295 pp.Print("\nArray: nil")
296 }
297
298 pp.Print("\nTokens: ")
299 f.Tokens.printType(&pp, v)
300
301 io.WriteString(w, "\n}")
302 }
303
304 func (f *ParameterAssign) printType(w io.Writer, v bool) {
305 pp := indentPrinter{w}
306
307 pp.Print("ParameterAssign {")
308
309 if f.Identifier != nil {
310 pp.Print("\nIdentifier: ")
311 f.Identifier.printType(&pp, v)
312 } else if v {
313 pp.Print("\nIdentifier: nil")
314 }
315
316 if f.Subscript != nil {
317 pp.Print("\nSubscript: ")
318 f.Subscript.printType(&pp, v)
319 } else if v {
320 pp.Print("\nSubscript: nil")
321 }
322
323 pp.Print("\nTokens: ")
324 f.Tokens.printType(&pp, v)
325
326 io.WriteString(w, "\n}")
327 }
328
329 func (f *ParameterExpansion) printType(w io.Writer, v bool) {
330 pp := indentPrinter{w}
331
332 pp.Print("ParameterExpansion {")
333
334 if f.Indirect || v {
335 pp.Printf("\nIndirect: %v", f.Indirect)
336 }
337
338 pp.Print("\nParameter: ")
339 f.Parameter.printType(&pp, v)
340
341 pp.Print("\nType: ")
342 f.Type.printType(&pp, v)
343
344 if f.SubstringStart != nil {
345 pp.Print("\nSubstringStart: ")
346 f.SubstringStart.printType(&pp, v)
347 } else if v {
348 pp.Print("\nSubstringStart: nil")
349 }
350
351 if f.SubstringEnd != nil {
352 pp.Print("\nSubstringEnd: ")
353 f.SubstringEnd.printType(&pp, v)
354 } else if v {
355 pp.Print("\nSubstringEnd: nil")
356 }
357
358 if f.Word != nil {
359 pp.Print("\nWord: ")
360 f.Word.printType(&pp, v)
361 } else if v {
362 pp.Print("\nWord: nil")
363 }
364
365 if f.Pattern != nil {
366 pp.Print("\nPattern: ")
367 f.Pattern.printType(&pp, v)
368 } else if v {
369 pp.Print("\nPattern: nil")
370 }
371
372 if f.String != nil {
373 pp.Print("\nString: ")
374 f.String.printType(&pp, v)
375 } else if v {
376 pp.Print("\nString: nil")
377 }
378
379 pp.Print("\nTokens: ")
380 f.Tokens.printType(&pp, v)
381
382 io.WriteString(w, "\n}")
383 }
384
385 func (f *Pipeline) printType(w io.Writer, v bool) {
386 pp := indentPrinter{w}
387
388 pp.Print("Pipeline {")
389
390 pp.Print("\nPipelineTime: ")
391 f.PipelineTime.printType(&pp, v)
392
393 if f.Not || v {
394 pp.Printf("\nNot: %v", f.Not)
395 }
396
397 pp.Print("\nCommandOrCompound: ")
398 f.CommandOrCompound.printType(&pp, v)
399
400 if f.Pipeline != nil {
401 pp.Print("\nPipeline: ")
402 f.Pipeline.printType(&pp, v)
403 } else if v {
404 pp.Print("\nPipeline: nil")
405 }
406
407 pp.Print("\nTokens: ")
408 f.Tokens.printType(&pp, v)
409
410 io.WriteString(w, "\n}")
411 }
412
413 func (f *Redirection) printType(w io.Writer, v bool) {
414 pp := indentPrinter{w}
415
416 pp.Print("Redirection {")
417
418 if f.Input != nil {
419 pp.Print("\nInput: ")
420 f.Input.printType(&pp, v)
421 } else if v {
422 pp.Print("\nInput: nil")
423 }
424
425 if f.Redirector != nil {
426 pp.Print("\nRedirector: ")
427 f.Redirector.printType(&pp, v)
428 } else if v {
429 pp.Print("\nRedirector: nil")
430 }
431
432 pp.Print("\nOutput: ")
433 f.Output.printType(&pp, v)
434
435 if f.Heredoc != nil {
436 pp.Print("\nHeredoc: ")
437 f.Heredoc.printType(&pp, v)
438 } else if v {
439 pp.Print("\nHeredoc: nil")
440 }
441
442 pp.Print("\nTokens: ")
443 f.Tokens.printType(&pp, v)
444
445 io.WriteString(w, "\n}")
446 }
447
448 func (f *Statement) printType(w io.Writer, v bool) {
449 pp := indentPrinter{w}
450
451 pp.Print("Statement {")
452
453 pp.Print("\nPipeline: ")
454 f.Pipeline.printType(&pp, v)
455
456 pp.Print("\nLogicalOperator: ")
457 f.LogicalOperator.printType(&pp, v)
458
459 if f.Statement != nil {
460 pp.Print("\nStatement: ")
461 f.Statement.printType(&pp, v)
462 } else if v {
463 pp.Print("\nStatement: nil")
464 }
465
466 pp.Print("\nJobControl: ")
467 f.JobControl.printType(&pp, v)
468
469 pp.Print("\nTokens: ")
470 f.Tokens.printType(&pp, v)
471
472 io.WriteString(w, "\n}")
473 }
474
475 func (f *String) printType(w io.Writer, v bool) {
476 pp := indentPrinter{w}
477
478 pp.Print("String {")
479
480 if f.WordsOrTokens == nil {
481 pp.Print("\nWordsOrTokens: nil")
482 } else if len(f.WordsOrTokens) > 0 {
483 pp.Print("\nWordsOrTokens: [")
484
485 ipp := indentPrinter{&pp}
486
487 for n, e := range f.WordsOrTokens {
488 ipp.Printf("\n%d: ", n)
489 e.printType(&ipp, v)
490 }
491
492 pp.Print("\n]")
493 } else if v {
494 pp.Print("\nWordsOrTokens: []")
495 }
496
497 pp.Print("\nTokens: ")
498 f.Tokens.printType(&pp, v)
499
500 io.WriteString(w, "\n}")
501 }
502
503 func (f *Value) printType(w io.Writer, v bool) {
504 pp := indentPrinter{w}
505
506 pp.Print("Value {")
507
508 if f.Word != nil {
509 pp.Print("\nWord: ")
510 f.Word.printType(&pp, v)
511 } else if v {
512 pp.Print("\nWord: nil")
513 }
514
515 if f.Array == nil {
516 pp.Print("\nArray: nil")
517 } else if len(f.Array) > 0 {
518 pp.Print("\nArray: [")
519
520 ipp := indentPrinter{&pp}
521
522 for n, e := range f.Array {
523 ipp.Printf("\n%d: ", n)
524 e.printType(&ipp, v)
525 }
526
527 pp.Print("\n]")
528 } else if v {
529 pp.Print("\nArray: []")
530 }
531
532 pp.Print("\nTokens: ")
533 f.Tokens.printType(&pp, v)
534
535 io.WriteString(w, "\n}")
536 }
537
538 func (f *Word) printType(w io.Writer, v bool) {
539 pp := indentPrinter{w}
540
541 pp.Print("Word {")
542
543 if f.Parts == nil {
544 pp.Print("\nParts: nil")
545 } else if len(f.Parts) > 0 {
546 pp.Print("\nParts: [")
547
548 ipp := indentPrinter{&pp}
549
550 for n, e := range f.Parts {
551 ipp.Printf("\n%d: ", n)
552 e.printType(&ipp, v)
553 }
554
555 pp.Print("\n]")
556 } else if v {
557 pp.Print("\nParts: []")
558 }
559
560 pp.Print("\nTokens: ")
561 f.Tokens.printType(&pp, v)
562
563 io.WriteString(w, "\n}")
564 }
565
566 func (f *WordOrOperator) printType(w io.Writer, v bool) {
567 pp := indentPrinter{w}
568
569 pp.Print("WordOrOperator {")
570
571 if f.Word != nil {
572 pp.Print("\nWord: ")
573 f.Word.printType(&pp, v)
574 } else if v {
575 pp.Print("\nWord: nil")
576 }
577
578 if f.Operator != nil {
579 pp.Print("\nOperator: ")
580 f.Operator.printType(&pp, v)
581 } else if v {
582 pp.Print("\nOperator: nil")
583 }
584
585 pp.Print("\nTokens: ")
586 f.Tokens.printType(&pp, v)
587
588 io.WriteString(w, "\n}")
589 }
590
591 func (f *WordOrToken) printType(w io.Writer, v bool) {
592 pp := indentPrinter{w}
593
594 pp.Print("WordOrToken {")
595
596 if f.Token != nil {
597 pp.Print("\nToken: ")
598 f.Token.printType(&pp, v)
599 } else if v {
600 pp.Print("\nToken: nil")
601 }
602
603 if f.Word != nil {
604 pp.Print("\nWord: ")
605 f.Word.printType(&pp, v)
606 } else if v {
607 pp.Print("\nWord: nil")
608 }
609
610 pp.Print("\nTokens: ")
611 f.Tokens.printType(&pp, v)
612
613 io.WriteString(w, "\n}")
614 }
615
616 func (f *WordPart) printType(w io.Writer, v bool) {
617 pp := indentPrinter{w}
618
619 pp.Print("WordPart {")
620
621 if f.Part != nil {
622 pp.Print("\nPart: ")
623 f.Part.printType(&pp, v)
624 } else if v {
625 pp.Print("\nPart: nil")
626 }
627
628 if f.ParameterExpansion != nil {
629 pp.Print("\nParameterExpansion: ")
630 f.ParameterExpansion.printType(&pp, v)
631 } else if v {
632 pp.Print("\nParameterExpansion: nil")
633 }
634
635 if f.CommandSubstitution != nil {
636 pp.Print("\nCommandSubstitution: ")
637 f.CommandSubstitution.printType(&pp, v)
638 } else if v {
639 pp.Print("\nCommandSubstitution: nil")
640 }
641
642 if f.ArithmeticExpansion != nil {
643 pp.Print("\nArithmeticExpansion: ")
644 f.ArithmeticExpansion.printType(&pp, v)
645 } else if v {
646 pp.Print("\nArithmeticExpansion: nil")
647 }
648
649 pp.Print("\nTokens: ")
650 f.Tokens.printType(&pp, v)
651
652 io.WriteString(w, "\n}")
653 }
654