bash - format_print.go
1 package bash
2
3 import (
4 "strings"
5
6 "vimagination.zapto.org/parser"
7 )
8
9 func (a ArithmeticExpansion) printSource(w writer, v bool) {
10 if a.Expression {
11 w.WriteString("((")
12 } else {
13 w.WriteString("$((")
14 }
15
16 if len(a.WordsAndOperators) > 0 {
17 if v {
18 w.WriteString(" ")
19 }
20
21 a.WordsAndOperators[0].printSource(w, v)
22
23 for _, wo := range a.WordsAndOperators[1:] {
24 if v && !wo.operatorIsToken(parser.Token{Type: TokenPunctuator, Data: ";"}) {
25 w.WriteString(" ")
26 }
27
28 wo.printSource(w, v)
29 }
30
31 if v {
32 w.WriteString(" ")
33 }
34 }
35
36 w.WriteString("))")
37 }
38
39 func (a ArrayWord) printSource(w writer, v bool) {
40 if len(a.Comments[0]) > 0 {
41 a.Comments[0].printSource(w, true)
42 }
43
44 a.Word.printSource(w, v)
45
46 if len(a.Comments[1]) > 0 {
47 w.WriteString(" ")
48 a.Comments[1].printSource(w, false)
49 }
50 }
51
52 func (a Assignment) printSource(w writer, v bool) {
53 if a.Assignment == AssignmentAssign || a.Assignment == AssignmentAppend {
54 a.Identifier.printSource(w, v)
55 a.Assignment.printSource(w, v)
56
57 if a.Value != nil {
58 a.Value.printSource(w, v)
59 } else {
60 parens := 0
61
62 for _, e := range a.Expression {
63 if parens > 0 {
64 w.WriteString(" ")
65 }
66
67 e.printSource(w, v)
68
69 if v && e.Operator != nil {
70 switch e.Operator.Token {
71 case parser.Token{Type: TokenPunctuator, Data: "("}:
72 parens++
73 case parser.Token{Type: TokenPunctuator, Data: ")"}:
74 parens--
75 }
76 }
77 }
78 }
79 }
80 }
81
82 func (a AssignmentOrWord) printSource(w writer, v bool) {
83 if a.Assignment != nil {
84 a.Assignment.printSource(w, v)
85 } else if a.Word != nil {
86 a.Word.printSource(w, v)
87 }
88 }
89
90 func (b BraceExpansion) printSource(w writer, v bool) {
91 if b.BraceExpansionType == BraceExpansionWords && len(b.Words) > 1 || (b.BraceExpansionType == BraceExpansionSequence && (len(b.Words) == 2 || len(b.Words) == 3)) {
92 w.WriteString("{")
93
94 b.Words[0].printSource(w, v)
95
96 for _, wd := range b.Words[1:] {
97 b.BraceExpansionType.printSource(w, v)
98 wd.printSource(w, v)
99 }
100
101 w.WriteString("}")
102 }
103 }
104
105 func (b BraceWord) printSource(w writer, v bool) {
106 for _, wp := range b.Parts {
107 wp.printSource(w, v)
108 }
109 }
110
111 func (c CaseCompound) printSource(w writer, v bool) {
112 w.WriteString("case ")
113 c.Word.printSource(w, v)
114
115 if len(c.Comments[0]) > 0 {
116 w.WriteString(" ")
117 c.Comments[0].printSource(w, false)
118 w.WriteString("\nin")
119 } else {
120 w.WriteString(" in")
121 }
122
123 if len(c.Comments[1]) > 0 {
124 w.WriteString(" ")
125 c.Comments[1].printSource(w, false)
126 }
127
128 for _, m := range c.Matches {
129 w.WriteString("\n")
130 m.printSource(w, v)
131 }
132
133 if len(c.Comments[2]) > 0 {
134 w.WriteString("\n")
135 c.Comments[2].printSource(w, false)
136 }
137
138 w.WriteString("\nesac")
139 }
140
141 func (c Command) printSource(w writer, v bool) {
142 if len(c.Vars) > 0 {
143 c.Vars[0].printSource(w, v)
144
145 for _, vr := range c.Vars[1:] {
146 w.WriteString(" ")
147 vr.printSource(w, v)
148 }
149 }
150
151 if len(c.AssignmentsOrWords) > 0 {
152 if len(c.Vars) > 0 {
153 w.WriteString(" ")
154 }
155
156 c.AssignmentsOrWords[0].printSource(w, v)
157
158 for _, wd := range c.AssignmentsOrWords[1:] {
159 w.WriteString(" ")
160 wd.printSource(w, v)
161 }
162 }
163
164 if len(c.Redirections) > 0 {
165 if len(c.Vars) > 0 || len(c.AssignmentsOrWords) > 0 {
166 w.WriteString(" ")
167 }
168
169 c.Redirections[0].printSource(w, v)
170
171 for _, r := range c.Redirections[1:] {
172 w.WriteString(" ")
173 r.printSource(w, v)
174 }
175 }
176 }
177
178 func (c Command) printHeredoc(w writer, v bool) {
179 for _, r := range c.Redirections {
180 r.printHeredoc(w, v)
181 }
182 }
183
184 func (c Command) hasHeredoc() bool {
185 for _, r := range c.Redirections {
186 if r.isHeredoc() {
187 return true
188 }
189 }
190
191 return false
192 }
193
194 func (c CommandOrCompound) printSource(w writer, v bool) {
195 if c.Command != nil {
196 c.Command.printSource(w, v)
197 } else if c.Compound != nil {
198 c.Compound.printSource(w, v)
199 }
200 }
201
202 func (c CommandOrCompound) printHeredoc(w writer, v bool) {
203 if c.Command != nil {
204 c.Command.printHeredoc(w, v)
205 } else if c.Compound != nil {
206 c.Compound.printHeredoc(w, v)
207 }
208 }
209
210 func (c CommandOrCompound) hasHeredoc() bool {
211 if c.Command != nil && c.Command.hasHeredoc() {
212 return true
213 }
214
215 if c.Compound != nil && c.Compound.hasHeredoc() {
216 return true
217 }
218
219 return false
220 }
221
222 func (c CommandSubstitution) printSource(w writer, v bool) {
223 closing := ")"
224
225 switch c.SubstitutionType {
226 case SubstitutionNew:
227 w.WriteString("$(")
228 case SubstitutionBacktick:
229 closing = "`"
230
231 if c.Backtick != nil {
232 closing = c.Backtick.Data
233 }
234
235 w.WriteString(closing)
236
237 closing = c.Backtick.Data
238 case SubstitutionProcessInput:
239 w.WriteString("<(")
240 case SubstitutionProcessOutput:
241 w.WriteString(">(")
242 }
243
244 if c.Command.isMultiline(v) {
245 ip := w.Indent()
246
247 ip.WriteString("\n")
248 c.Command.printSource(ip, v)
249 w.WriteString("\n")
250 } else {
251 c.Command.printSourceEnd(w, v, false)
252 }
253
254 w.WriteString(closing)
255 }
256
257 func (c Compound) printSource(w writer, v bool) {
258 if c.IfCompound != nil {
259 c.IfCompound.printSource(w, v)
260 } else if c.CaseCompound != nil {
261 c.CaseCompound.printSource(w, v)
262 } else if c.LoopCompound != nil {
263 c.LoopCompound.printSource(w, v)
264 } else if c.ForCompound != nil {
265 c.ForCompound.printSource(w, v)
266 } else if c.SelectCompound != nil {
267 c.SelectCompound.printSource(w, v)
268 } else if c.GroupingCompound != nil {
269 c.GroupingCompound.printSource(w, v)
270 } else if c.TestCompound != nil {
271 c.TestCompound.printSource(w, v)
272 } else if c.ArithmeticCompound != nil {
273 c.ArithmeticCompound.printSource(w, v)
274 } else if c.FunctionCompound != nil {
275 c.FunctionCompound.printSource(w, v)
276 }
277
278 for _, r := range c.Redirections {
279 w.WriteString(" ")
280 r.printSource(w, v)
281 }
282 }
283
284 func (c Compound) printHeredoc(w writer, v bool) {
285 for _, r := range c.Redirections {
286 r.printHeredoc(w, v)
287 }
288 }
289
290 func (c Compound) hasHeredoc() bool {
291 for _, r := range c.Redirections {
292 if r.isHeredoc() {
293 return true
294 }
295 }
296
297 return false
298 }
299
300 func (f File) printSource(w writer, v bool) {
301 f.printSourceEnd(w, v, true)
302 }
303
304 func (f File) printSourceEnd(w writer, v, end bool) {
305 f.Comments[0].printSource(w, true)
306
307 topLevel := w.Underlying() == w
308
309 if len(f.Lines) > 0 {
310 if topLevel && len(f.Comments[0]) > 0 {
311 w.WriteString("\n")
312 }
313
314 f.Lines[0].printSourceEnd(w, v, end || len(f.Lines) > 1)
315
316 lastLine := lastTokenPos(f.Lines[0].Tokens)
317
318 for n, l := range f.Lines[1:] {
319 if firstTokenPos(l.Tokens) > lastLine+1 {
320 w.WriteString("\n")
321 }
322
323 w.WriteString("\n")
324 l.printSourceEnd(w, v, end || len(f.Lines) > n+1)
325
326 lastLine = lastTokenPos(l.Tokens)
327 }
328 }
329
330 if len(f.Comments[1]) > 0 {
331 w.WriteString("\n\n")
332 f.Comments[1].printSource(w, false)
333 }
334
335 if topLevel && end {
336 w.WriteString("\n")
337 }
338 }
339
340 func firstTokenPos(tk Tokens) (pos uint64) {
341 if len(tk) > 0 {
342 pos = tk[0].Line
343 }
344
345 return pos
346 }
347
348 func lastTokenPos(tk Tokens) (pos uint64) {
349 if len(tk) > 0 {
350 pos = tk[len(tk)-1].Line
351 }
352
353 return pos
354 }
355
356 func (f ForCompound) printSource(w writer, v bool) {
357 if f.ArithmeticExpansion != nil || f.Identifier != nil {
358 w.WriteString("for ")
359
360 if f.ArithmeticExpansion != nil {
361 f.ArithmeticExpansion.printSource(w, v)
362 } else {
363 w.WriteString(f.Identifier.Data)
364
365 if f.Words != nil {
366 w.WriteString(" ")
367 f.Comments[0].printSource(w, true)
368 w.WriteString("in")
369
370 for _, wd := range f.Words {
371 w.WriteString(" ")
372 wd.printSource(w, v)
373 }
374 }
375 }
376
377 ip := w.Indent()
378
379 ip.WriteString("; ")
380 f.Comments[1].printSource(ip, true)
381 ip.WriteString("do\n")
382 f.File.printSource(ip, v)
383 w.WriteString("\ndone")
384 }
385 }
386
387 func (f FunctionCompound) printSource(w writer, v bool) {
388 if f.Identifier != nil {
389 if f.HasKeyword {
390 w.WriteString("function ")
391 }
392
393 w.WriteString(f.Identifier.Data)
394 w.WriteString("() ")
395 f.Comments.printSource(w, true)
396 f.Body.printSource(w, v)
397 }
398 }
399
400 func (g GroupingCompound) printSource(w writer, v bool) {
401 if g.SubShell {
402 w.WriteString("(")
403 } else {
404 w.WriteString("{")
405 }
406
407 ip := w.Indent()
408 multiline := v || g.File.isMultiline(v)
409
410 if len(g.File.Comments[0]) > 0 || !multiline {
411 w.WriteString(" ")
412 } else {
413 ip.WriteString("\n")
414 }
415
416 g.File.printSource(ip, v)
417
418 if multiline {
419 w.WriteString("\n")
420 } else {
421 w.WriteString(" ")
422 }
423
424 if g.SubShell {
425 w.WriteString(")")
426 } else {
427 w.WriteString("}")
428 }
429 }
430
431 func (h Heredoc) printSource(w writer, v bool) {
432 w.WriteString("\n")
433
434 for _, p := range h.HeredocPartsOrWords {
435 p.printSource(w, v)
436 }
437 }
438
439 func (h HeredocPartOrWord) printSource(w writer, v bool) {
440 if h.HeredocPart != nil {
441 w.WriteString(h.HeredocPart.Data)
442 } else if h.Word != nil {
443 h.Word.printSource(w, v)
444 }
445 }
446
447 func (i IfCompound) printSource(w writer, v bool) {
448 w.WriteString("if ")
449 i.If.printSource(w, v)
450
451 for _, e := range i.ElIf {
452 w.WriteString("\nelif ")
453 e.printSource(w, v)
454 }
455
456 if i.Else != nil {
457 ip := w.Indent()
458
459 w.WriteString("\nelse")
460 ip.WriteString("\n")
461 i.Else.printSource(ip, v)
462 }
463
464 w.WriteString("\nfi")
465 }
466
467 func (l Line) printSource(w writer, v bool) {
468 l.printSourceEnd(w, v, true)
469 }
470
471 func (l Line) printSourceEnd(w writer, v, end bool) {
472 if len(l.Statements) > 0 {
473 end = end && !l.hasHeredoc()
474
475 l.Comments[0].printSource(w, true)
476 l.Statements[0].printSourceEnd(w, v, end || len(l.Statements) > 1)
477
478 for n, s := range l.Statements[1:] {
479 if v {
480 l.Statements[n].printHeredoc(w, v)
481 w.WriteString("\n")
482 } else {
483 w.WriteString(" ")
484 }
485
486 s.printSourceEnd(w, v, end || len(l.Statements) > n+1)
487 }
488
489 if len(l.Comments[1]) > 0 {
490 w.WriteString(" ")
491 l.Comments[1].printSource(w, false)
492 }
493
494 if v {
495 l.Statements[len(l.Statements)-1].printHeredoc(w, v)
496 } else {
497 for _, s := range l.Statements {
498 s.printHeredoc(w, v)
499 }
500 }
501 }
502 }
503
504 func (l Line) hasHeredoc() bool {
505 for _, s := range l.Statements {
506 if s.hasHeredoc() {
507 return true
508 }
509 }
510
511 return false
512 }
513
514 func (l LoopCompound) printSource(w writer, v bool) {
515 if l.Until {
516 w.WriteString("until ")
517 } else {
518 w.WriteString("while ")
519 }
520
521 l.Statement.printSource(w, v)
522
523 if l.Statement.endsWithGrouping() {
524 w.WriteString(";")
525 }
526
527 if len(l.Comments) > 0 {
528 w.WriteString(" ")
529 l.Comments.printSource(w, true)
530 w.WriteString("do")
531 } else {
532 w.WriteString(" do")
533 }
534
535 ip := w.Indent()
536
537 ip.WriteString("\n")
538 l.File.printSource(ip, v)
539 w.WriteString("\ndone")
540 }
541
542 func (p ParameterAssign) printSource(w writer, v bool) {
543 if p.Identifier != nil {
544 w.WriteString(p.Identifier.Data)
545
546 if len(p.Subscript) > 0 {
547 w.WriteString("[")
548 p.Subscript[0].printSource(w, v)
549
550 for _, s := range p.Subscript[1:] {
551 if v {
552 w.WriteString(" ")
553 }
554
555 s.printSource(w, v)
556 }
557
558 w.WriteString("]")
559 }
560 }
561 }
562
563 func (p ParameterExpansion) printSource(w writer, v bool) {
564 w.WriteString("${")
565
566 if p.Indirect || p.Type == ParameterPrefix || p.Type == ParameterPrefixSeperate {
567 w.WriteString("!")
568 } else if p.Type == ParameterLength {
569 w.WriteString("#")
570 }
571
572 p.Parameter.printSource(w, v)
573
574 if p.BraceWord != nil {
575 switch p.Type {
576 case ParameterSubstitution:
577 w.WriteString(":=")
578 p.BraceWord.printSource(w, v)
579 case ParameterAssignment:
580 w.WriteString(":?")
581 p.BraceWord.printSource(w, v)
582 case ParameterMessage:
583 w.WriteString(":+")
584 p.BraceWord.printSource(w, v)
585 case ParameterSetAssign:
586 w.WriteString(":-")
587 p.BraceWord.printSource(w, v)
588 case ParameterUnsetSubstitution:
589 w.WriteString("=")
590 p.BraceWord.printSource(w, v)
591 case ParameterUnsetAssignment:
592 w.WriteString("?")
593 p.BraceWord.printSource(w, v)
594 case ParameterUnsetMessage:
595 w.WriteString("+")
596 p.BraceWord.printSource(w, v)
597 case ParameterUnsetSetAssign:
598 w.WriteString("-")
599 p.BraceWord.printSource(w, v)
600 case ParameterRemoveStartShortest:
601 w.WriteString("#")
602 p.BraceWord.printSource(w, v)
603 case ParameterRemoveStartLongest:
604 w.WriteString("##")
605 p.BraceWord.printSource(w, v)
606 case ParameterRemoveEndShortest:
607 w.WriteString("%")
608 p.BraceWord.printSource(w, v)
609 case ParameterRemoveEndLongest:
610 w.WriteString("%%")
611 p.BraceWord.printSource(w, v)
612 }
613 } else if p.Pattern != nil {
614 isReplacement := false
615
616 switch p.Type {
617 case ParameterReplace:
618 isReplacement = true
619
620 w.WriteString("/")
621 w.WriteString(p.Pattern.Data)
622 case ParameterReplaceAll:
623 isReplacement = true
624
625 w.WriteString("//")
626 w.WriteString(p.Pattern.Data)
627 case ParameterReplaceStart:
628 isReplacement = true
629
630 w.WriteString("/#")
631 w.WriteString(p.Pattern.Data)
632 case ParameterReplaceEnd:
633 isReplacement = true
634
635 w.WriteString("/%")
636 w.WriteString(p.Pattern.Data)
637 case ParameterLowercaseFirstMatch:
638 w.WriteString(",")
639 w.WriteString(p.Pattern.Data)
640 case ParameterLowercaseAllMatches:
641 w.WriteString(",,")
642 w.WriteString(p.Pattern.Data)
643 case ParameterUppercaseFirstMatch:
644 w.WriteString("^")
645 w.WriteString(p.Pattern.Data)
646 case ParameterUppercaseAllMatches:
647 w.WriteString("^^")
648 w.WriteString(p.Pattern.Data)
649 }
650
651 if isReplacement && p.String != nil {
652 w.WriteString("/")
653 p.String.printSource(w, v)
654 }
655 } else if !p.Indirect {
656 switch p.Type {
657 case ParameterPrefix:
658 w.WriteString("*")
659 case ParameterPrefixSeperate:
660 w.WriteString("@")
661 }
662 }
663
664 switch p.Type {
665 case ParameterSubstring:
666 if p.SubstringStart != nil {
667 w.WriteString(":")
668
669 if len(p.SubstringStart.Parts) > 0 && p.SubstringStart.Parts[0].Part != nil && strings.HasPrefix(p.SubstringStart.Parts[0].Part.Data, "-") {
670 w.WriteString(" ")
671 }
672
673 p.SubstringStart.printSource(w, v)
674
675 if p.SubstringEnd != nil {
676 w.WriteString(":")
677 p.SubstringEnd.printSource(w, v)
678 }
679 }
680 case ParameterUppercase:
681 w.WriteString("@U")
682 case ParameterUppercaseFirst:
683 w.WriteString("@u")
684 case ParameterLowercase:
685 w.WriteString("@L")
686 case ParameterQuoted:
687 w.WriteString("@Q")
688 case ParameterEscaped:
689 w.WriteString("@E")
690 case ParameterPrompt:
691 w.WriteString("@P")
692 case ParameterDeclare:
693 w.WriteString("@A")
694 case ParameterQuotedArrays:
695 w.WriteString("@K")
696 case ParameterAttributes:
697 w.WriteString("@a")
698 case ParameterQuotedArraysSeperate:
699 w.WriteString("@k")
700 }
701
702 w.WriteString("}")
703 }
704
705 func (p Parameter) printSource(w writer, v bool) {
706 if p.Parameter != nil {
707 w.WriteString(p.Parameter.Data)
708
709 if p.Array != nil {
710 w.WriteString("[")
711
712 for _, a := range p.Array {
713 a.printSource(w, v)
714 }
715
716 w.WriteString("]")
717 }
718 }
719 }
720
721 func (p Pattern) printSource(w writer, v bool) {
722 for _, word := range p.Parts {
723 word.printSource(w, v)
724 }
725 }
726
727 func (p PatternLines) printSource(w writer, v bool) {
728 if len(p.Patterns) > 0 {
729 p.Comments.printSource(w, true)
730 p.Patterns[0].printSource(w, v)
731
732 for _, pattern := range p.Patterns[1:] {
733 w.WriteString("|")
734 pattern.printSource(w, v)
735 }
736
737 ip := w.Indent()
738
739 w.WriteString(")")
740 ip.WriteString("\n")
741
742 if len(p.Lines.Lines) > 0 {
743 p.Lines.printSource(ip, v)
744 } else {
745 ip.WriteString(";")
746 }
747
748 p.CaseTerminationType.printSource(ip, v)
749 }
750 }
751
752 func (p Pipeline) printSource(w writer, v bool) {
753 p.PipelineTime.printSource(w, v)
754
755 if p.Not {
756 w.WriteString("! ")
757 }
758
759 if p.Coproc {
760 w.WriteString("coproc ")
761
762 if p.CoprocIdentifier != nil {
763 w.WriteString(p.CoprocIdentifier.Data)
764 w.WriteString(" ")
765 }
766 }
767
768 p.CommandOrCompound.printSource(w, v)
769
770 if p.Pipeline != nil {
771 w.WriteString(" | ")
772 p.Pipeline.printSource(w, v)
773 }
774 }
775
776 func (p Pipeline) endsWithGrouping() bool {
777 if p.Pipeline != nil {
778 return p.Pipeline.endsWithGrouping()
779 }
780
781 return p.CommandOrCompound.Compound != nil && len(p.CommandOrCompound.Compound.Redirections) == 0 && (p.CommandOrCompound.Compound.GroupingCompound != nil || p.CommandOrCompound.Compound.FunctionCompound != nil && p.CommandOrCompound.Compound.FunctionCompound.Body.GroupingCompound != nil)
782 }
783
784 func (p Pipeline) printHeredoc(w writer, v bool) {
785 p.CommandOrCompound.printHeredoc(w, v)
786
787 if p.Pipeline != nil {
788 p.Pipeline.printHeredoc(w, v)
789 }
790 }
791
792 func (p Pipeline) hasHeredoc() bool {
793 if p.Pipeline != nil && p.Pipeline.hasHeredoc() {
794 return true
795 }
796
797 return p.CommandOrCompound.hasHeredoc()
798 }
799
800 func (r Redirection) printSource(w writer, v bool) {
801 if r.Redirector != nil {
802 if r.Input != nil {
803 w.WriteString(r.Input.Data)
804 }
805
806 w.WriteString(r.Redirector.Data)
807
808 if v && r.Redirector.Data != "<<" && r.Redirector.Data != "<<-" && r.Redirector.Data != ">&" || r.Output.firstPartIsProcessSubstitution() {
809 w.WriteString(" ")
810 }
811
812 r.Output.printSource(w, v)
813 }
814 }
815
816 func (r Redirection) printHeredoc(w writer, v bool) {
817 if r.Redirector != nil && r.Heredoc != nil && (r.Redirector.Data == "<<" || r.Redirector.Data == "<<-") {
818 if r.Redirector.Data == "<<" {
819 w = w.Underlying()
820 }
821
822 r.Heredoc.printSource(w, v)
823 r.Output.printSource(w, v)
824 }
825 }
826
827 func (s SelectCompound) printSource(w writer, v bool) {
828 if s.Identifier != nil {
829 w.WriteString("select ")
830 w.WriteString(s.Identifier.Data)
831
832 if s.Words != nil {
833 w.WriteString(" ")
834 s.Comments[0].printSource(w, true)
835 w.WriteString("in")
836
837 for _, wd := range s.Words {
838 w.WriteString(" ")
839 wd.printSource(w, v)
840 }
841 }
842
843 ip := w.Indent()
844
845 ip.WriteString("; ")
846 s.Comments[1].printSource(w, true)
847 ip.WriteString("do\n")
848 s.File.printSource(ip, v)
849 w.WriteString("\ndone")
850 }
851 }
852
853 func (s Statement) printSource(w writer, v bool) {
854 s.printSourceEnd(w, v, true)
855 }
856
857 func (s Statement) printSourceEnd(w writer, v, end bool) {
858 s.Pipeline.printSource(w, v)
859
860 if (s.LogicalOperator == LogicalOperatorAnd || s.LogicalOperator == LogicalOperatorOr) && s.Statement != nil {
861 w.WriteString(" ")
862 s.LogicalOperator.printSource(w, v)
863 w.WriteString(" ")
864 s.Statement.printSourceEnd(w, v, false)
865 }
866
867 if s.JobControl == JobControlBackground {
868 if v {
869 w.WriteString(" &")
870 } else {
871 w.WriteString("&")
872 }
873 } else if end && !s.endsWithGrouping() {
874 w.WriteString(";")
875 }
876 }
877
878 func (s Statement) endsWithGrouping() bool {
879 if s.Statement != nil {
880 return s.Statement.endsWithGrouping()
881 }
882
883 return s.Pipeline.endsWithGrouping()
884 }
885
886 func (s Statement) hasHeredoc() bool {
887 if s.Statement != nil && s.Statement.hasHeredoc() {
888 return true
889 }
890
891 return s.Pipeline.hasHeredoc()
892 }
893
894 func (s Statement) printHeredoc(w writer, v bool) {
895 s.Pipeline.printHeredoc(w, v)
896
897 if s.Statement != nil {
898 s.Statement.printHeredoc(w, v)
899 }
900 }
901
902 func (s String) printSource(w writer, v bool) {
903 for _, p := range s.WordsOrTokens {
904 p.printSource(w, v)
905 }
906 }
907
908 func (t TestCompound) printSource(w writer, v bool) {
909 w.WriteString("[[")
910
911 iw := w
912 multi := t.isMultiline(v)
913
914 if multi {
915 iw = w.Indent()
916 multi = true
917
918 if len(t.Comments[0]) > 0 {
919 w.WriteString(" ")
920 t.Comments[0].printSource(w, len(t.Tests.Comments[0]) > 0)
921 }
922
923 iw.WriteString("\n")
924 } else {
925 w.WriteString(" ")
926 }
927
928 t.Tests.printSource(iw, v)
929
930 if len(t.Comments[1]) > 0 {
931 if t.Tests.lastIsComment() {
932 w.WriteString("\n")
933 }
934
935 w.WriteString("\n")
936 t.Comments[1].printSource(w, true)
937 } else if multi {
938 w.WriteString("\n")
939 } else {
940 w.WriteString(" ")
941 }
942
943 w.WriteString("]]")
944 }
945
946 func (t Tests) printSource(w writer, v bool) {
947 t.Comments[0].printSource(w, true)
948
949 if t.Not {
950 w.WriteString("! ")
951
952 t.Comments[1].printSource(w, true)
953 }
954
955 if t.Parens != nil {
956 w.WriteString("(")
957
958 multi := t.Parens.isMultiline(v) || len(t.Comments[2]) > 0 || len(t.Comments[3]) > 0
959 iw := w
960
961 if multi {
962 iw = w.Indent()
963
964 if len(t.Comments[2]) > 0 {
965 w.WriteString(" ")
966 t.Comments[2].printSource(w, len(t.Parens.Comments[0]) > 0)
967 }
968
969 iw.WriteString("\n")
970 } else {
971 w.WriteString(" ")
972 }
973
974 t.Parens.printSource(iw, v)
975
976 if multi {
977 if len(t.Comments[3]) > 0 && len(t.Parens.Comments[4]) > 0 {
978 w.WriteString("\n\n")
979 } else {
980 w.WriteString("\n")
981 }
982 } else {
983 w.WriteString(" ")
984 }
985
986 t.Comments[3].printSource(w, true)
987 w.WriteString(")")
988 } else if t.Word != nil && t.Test == TestOperatorNone {
989 t.Word.printSource(w, v)
990 } else if t.Word != nil && t.Pattern != nil && t.Test >= TestOperatorStringsEqual {
991 t.Word.printSource(w, v)
992 w.WriteString(" ")
993 t.Test.printSource(w, v)
994 w.WriteString(" ")
995 t.Comments[2].printSource(w, true)
996 t.Pattern.printSource(w, v)
997 } else if t.Word != nil && t.Test >= TestOperatorFileExists && t.Test <= TestOperatorStringIsNonZero {
998 t.Test.printSource(w, v)
999 w.WriteString(" ")
1000 t.Word.printSource(w, v)
1001 }
1002
1003 if t.Tests != nil && (t.LogicalOperator == LogicalOperatorOr || t.LogicalOperator == LogicalOperatorAnd) {
1004 w.WriteString(" ")
1005 t.Comments[4].printSource(w, true)
1006 t.LogicalOperator.printSource(w, v)
1007 w.WriteString(" ")
1008 t.Tests.printSource(w, v)
1009 } else if len(t.Comments[4]) > 0 {
1010 w.WriteString(" ")
1011 t.Comments[4].printSource(w, false)
1012 }
1013 }
1014
1015 func (t Tests) lastIsComment() bool {
1016 if t.Tests != nil {
1017 return t.Tests.lastIsComment()
1018 }
1019
1020 return len(t.Comments[4]) > 0
1021 }
1022
1023 func (t TestConsequence) printSource(w writer, v bool) {
1024 t.Test.printSource(w, v)
1025
1026 if t.Test.endsWithGrouping() {
1027 w.WriteString(";")
1028 }
1029
1030 ip := w.Indent()
1031
1032 if len(t.Comments) > 0 {
1033 w.WriteString(" ")
1034 t.Comments.printSource(w, true)
1035 ip.WriteString("then\n")
1036 } else {
1037 ip.WriteString(" then\n")
1038 }
1039
1040 t.Consequence.printSource(ip, v)
1041 }
1042
1043 func (ve Value) printSource(w writer, v bool) {
1044 if ve.Word != nil {
1045 ve.Word.printSource(w, v)
1046 } else if ve.Array != nil {
1047 iw := w
1048 ml := ve.isMultiline(v)
1049 lastHadComment := ml
1050
1051 if ml {
1052 iw = w.Indent()
1053 }
1054
1055 if len(ve.Comments[0]) > 0 {
1056 w.WriteString("(")
1057
1058 if len(ve.Comments[0]) > 0 {
1059 w.WriteString(" ")
1060 ve.Comments[0].printSource(w, len(ve.Array) > 0)
1061
1062 lastHadComment = true
1063 }
1064 } else {
1065 w.WriteString("(")
1066 }
1067
1068 if len(ve.Array) > 0 {
1069 lastHadComment = lastHadComment || len(ve.Array[0].Comments[0]) > 0
1070
1071 for _, word := range ve.Array {
1072 if lastHadComment {
1073 iw.WriteString("\n")
1074 } else if v && len(word.Comments[0]) == 0 {
1075 iw.WriteString(" ")
1076 }
1077
1078 word.printSource(iw, v)
1079
1080 lastHadComment = len(word.Comments[1]) != 0
1081 }
1082
1083 if v && !ml {
1084 iw.WriteString(" ")
1085 }
1086 }
1087
1088 if len(ve.Comments[1]) != 0 {
1089 w.WriteString("\n")
1090
1091 if lastHadComment {
1092 w.WriteString("\n")
1093 }
1094
1095 ve.Comments[1].printSource(w, false)
1096
1097 lastHadComment = true
1098 }
1099
1100 if lastHadComment || ml {
1101 w.WriteString("\n")
1102 }
1103
1104 w.WriteString(")")
1105 }
1106 }
1107
1108 func (wo WordOrOperator) printSource(w writer, v bool) {
1109 if wo.Operator != nil {
1110 w.WriteString(wo.Operator.Data)
1111 } else if wo.Word != nil {
1112 wo.Word.printSource(w, v)
1113 }
1114 }
1115
1116 func (wt WordOrToken) printSource(w writer, v bool) {
1117 if wt.Word != nil {
1118 wt.Word.printSource(w, v)
1119 } else if wt.Token != nil {
1120 w.WriteString(wt.Token.Data)
1121 }
1122 }
1123
1124 func (wp WordPart) printSource(w writer, v bool) {
1125 if wp.Part != nil {
1126 if len(wp.Part.Data) > 0 {
1127 w.WriteString(wp.Part.Data[:1])
1128 w.Underlying().WriteString(wp.Part.Data[1:])
1129 }
1130 } else if wp.ArithmeticExpansion != nil {
1131 wp.ArithmeticExpansion.printSource(w, v)
1132 } else if wp.CommandSubstitution != nil {
1133 wp.CommandSubstitution.printSource(w, v)
1134 } else if wp.ParameterExpansion != nil {
1135 wp.ParameterExpansion.printSource(w, v)
1136 } else if wp.BraceExpansion != nil {
1137 wp.BraceExpansion.printSource(w, v)
1138 }
1139 }
1140
1141 func (wd Word) printSource(w writer, v bool) {
1142 for _, word := range wd.Parts {
1143 word.printSource(w, v)
1144 }
1145 }
1146
1147 func (wd Word) firstPartIsProcessSubstitution() bool {
1148 return len(wd.Parts) > 0 && wd.Parts[0].CommandSubstitution != nil && (wd.Parts[0].CommandSubstitution.SubstitutionType == SubstitutionProcessInput || wd.Parts[0].CommandSubstitution.SubstitutionType == SubstitutionProcessOutput)
1149 }
1150