source: branches/dev-jk-2597/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag @ 13822

Last change on this file since 13822 was 13822, checked in by Jonathan Kämpe, 8 weeks ago

#5862 Now printing empty array subscripts in order to detect them in tests. Fixed a couple of occurences.

File size: 76.5 KB
Line 
1/*
2    Copyright (C) 2009-2019 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17import java.io.ByteArrayOutputStream;
18import java.util.Collection;
19
20import org.jmodelica.util.streams.CodeStream;
21import org.jmodelica.util.streams.NotNullCodeStream;
22
23aspect BasePrinter {
24
25    /**
26     * Superclass to all classes that perform the dispatch.
27     */ 
28    public class Printer {
29
30        private static final Map<String, Map<String, String>> INDENT_MAPS = new HashMap<String, Map<String, String>>();
31        private final Map<String, String> INDENTS;
32               
33                protected String step;
34               
35                public Printer(String step) {
36                        this.step = step;
37                        Map<String,String> indents = INDENT_MAPS.get(step);
38                        if (indents == null) {
39                            indents = new HashMap<String,String>();
40                            INDENT_MAPS.put(step, indents);
41                        }
42                        INDENTS = indents;
43                }
44               
45                public String indent(String old) {
46                    String res = INDENTS.get(old);
47                    if (res == null) {
48                        res = old + step;
49                        INDENTS.put(old, res);
50                    }
51                        return res;
52                }
53
54                public void print(ASTNode node, CodeStream str, String indent) { 
55                }
56
57                public void print(Collection<? extends ASTNode> nodes, CodeStream str, String indent) {
58                        for (ASTNode node : nodes)
59                                print(node, str, indent);
60                }
61               
62                public void print(String s, CodeStream str) {
63                    str.print(s);
64                }
65               
66                public String op(FBinExp e) { return e.op(); }
67
68        /**
69         * Method that returns the printer that should be used when
70         * annotations are PrettyPrinted in the flat tree.
71         */
72        public PrettyPrinter annotationPrinter() {
73            return ASTNode.AnnotationPrettyPrinter;
74        }
75
76        /**
77         * Method returns true if the supplied attribute should be printed.
78         * Checked by PrettyPrinting of FAttributes
79         */
80        public boolean inAnnotation() {
81            return false;
82        }
83        }
84}
85
86aspect PrettyPrint {
87
88    /**
89     * Static printer instance.
90     */
91    static PrettyPrinter ASTNode.prettyPrinter = new PrettyPrinter();
92
93    /**
94     * Select first variant.
95     */ 
96    public class PrettyPrinter extends Printer {
97                public PrettyPrinter() {
98                        super(" ");
99                }
100               
101                public void print(ASTNode node, CodeStream str, String indent) { 
102                        node.prettyPrint(this, str, indent); 
103                }
104        }
105
106        /**
107         * Wraps a prettyPrint() call to be deferred until the sting is needed.
108         */
109        public class PrettyPrintDelegate {
110                private ASTNode n;
111                private String i;
112               
113                public PrettyPrintDelegate(ASTNode node) {
114                        this(node, "");
115                }
116               
117                public PrettyPrintDelegate(ASTNode node, String indent) {
118                        n = node;
119                        i = indent;
120                }
121               
122                public String toString() {
123                        return n.prettyPrint(i);
124                }
125        }
126
127    public String ASTNode.prettyPrint(String indent) {
128        ByteArrayOutputStream os = new ByteArrayOutputStream();
129        CodeStream str = new NotNullCodeStream(os);
130        prettyPrint(str, indent);
131        return os.toString();
132    }
133
134    public String ASTNode.prettyPrint(Printer printer) {
135        return prettyPrint(printer, "");
136    }
137
138    public String ASTNode.prettyPrint(Printer printer, String indent) {
139        ByteArrayOutputStream baos = new ByteArrayOutputStream();
140        CodeStream str = new NotNullCodeStream(baos);
141        printer.print(this, str, indent);
142        return baos.toString();
143    }
144
145    // Override ASTNode.prettyPrint to get method on Python side (jpype bug)
146    public String BaseNode.prettyPrint(String indent) {
147        return super.prettyPrint(indent);
148    }
149
150    public void ASTNode.prettyPrint(CodeStream str, String indent) {
151         prettyPrint(prettyPrinter, str, indent);
152    }
153
154    /**
155     * Overrides default behaviour since we should use AnnotationPrettyPrinter
156     * when printing annotation nodes.
157     */
158    @Override
159    public void FAnnotationAttribute.prettyPrint(CodeStream str, String indent) {
160        prettyPrint(AnnotationPrettyPrinter, str, indent);
161    }
162       
163        public void ASTNode.prettyPrint(Printer p, CodeStream str, String indent) {
164                for (ASTNode n : this)
165                        p.print(n, str, indent);
166        }
167       
168        /**
169         * Prints a list of any type of ASTNode, adding <code>sep</code> between nodes.
170         *
171         * Typical use: <code>list.prettyPrintWithSep(p, str, indent, ", ");</code>
172         * (Prints comma-separated list.)
173         */
174        public void List.prettyPrintWithSep(Printer p, CodeStream str, String indent, String sep) {
175                String prefix = "";
176                for (ASTNode n : this) {
177                        str.print(prefix);
178                        p.print(n, str, indent);
179                        prefix = sep;
180                }
181        }
182       
183        public String List.toString() {
184                ByteArrayOutputStream os = new ByteArrayOutputStream();
185                CodeStream str = new CodeStream(os);
186                prettyPrintWithSep(prettyPrinter, str, "", ", ");
187                return os.toString();
188        }
189       
190        public static String ASTNode.prettyPrintWithSep(java.util.List<? extends ASTNode> l, String sep) {
191                ByteArrayOutputStream os = new ByteArrayOutputStream();
192                CodeStream str = new NotNullCodeStream(os);
193                prettyPrintWithSep(l, prettyPrinter, str, "", sep);
194                return os.toString();
195        }
196
197        /**
198         * Prints an ArrayList of any type of ASTNode, adding <code>sep</code> between nodes.
199         *
200         * Typical use: <code>prettyPrintWithSep(list, p, str, indent, ", ");</code>
201         * (Prints comma-separated list.)
202         */
203        public static void ASTNode.prettyPrintWithSep(java.util.List<? extends ASTNode> l, Printer p, CodeStream str, String indent, String sep) {
204                String prefix = "";
205                for (ASTNode n : l) {
206                        str.print(prefix);
207                        p.print(n, str, indent);
208                        prefix = sep;
209                }
210        }
211       
212        /**
213         * Prints a list of any type of ASTNode, adding <code>prefix</code> before each node and
214         * <code>suffix</code> after each node.
215         */
216        public void List.prettyPrintWithFix(Printer p, CodeStream str, String indent, String prefix, String suffix) {
217                for (ASTNode n : this) {
218                        str.print(prefix);
219                        p.print(n, str, indent);
220                        str.print(suffix);
221                }
222        }
223       
224        /**
225         * Prints an ArrayList of any type of ASTNode, adding <code>prefix</code> before each node and
226         * <code>suffix</code> after each node.
227         */
228        public static void ASTNode.prettyPrintWithFix(java.util.List<? extends ASTNode> l, Printer p, CodeStream str, String indent, String prefix, String suffix) {
229                for (ASTNode n : l) {
230                        str.print(prefix);
231                        p.print(n, str, indent);
232                        str.print(suffix);
233                }
234        }
235       
236        /**
237         * Prints a list of any type of ASTNode, adding <code>indent</code> before each node and
238         * <code>suffix</code> plus a line break after after each node.
239         */
240        public void List.prettyPrintWithIndent(Printer p, CodeStream str, String indent, String suffix) {
241                prettyPrintWithFix(p, str, indent, indent, suffix + str.getLineEnder());
242        }
243       
244        /**
245         * Prints an ArrayList of any type of ASTNode, adding <code>indent</code> before each node and
246         * <code>suffix</code> plus a line break after after each node.
247         */
248        public static void ASTNode.prettyPrintWithIndent(java.util.List<? extends ASTNode> l, Printer p, CodeStream str, String indent, String suffix) {
249                prettyPrintWithFix(l, p, str, indent, indent, suffix + str.getLineEnder());
250        }
251       
252        /**
253         * Prints a list of any type of ASTNode, adding <code>indent</code> before each node and
254         * a line break after after each node.
255         */
256        public void List.prettyPrintWithIndent(Printer p, CodeStream str, String indent) {
257                prettyPrintWithFix(p, str, indent, indent, str.getLineEnder());
258        }
259       
260        /**
261         * Prints an ArrayList of any type of ASTNode, adding <code>indent</code> before each node and
262         * a line break after after each node.
263         */
264        public static void ASTNode.prettyPrintWithIndent(java.util.List<? extends ASTNode> l, Printer p, CodeStream str, String indent) {
265                prettyPrintWithFix(l, p, str, indent, indent, str.getLineEnder());
266        }
267       
268        public void Program.prettyPrint(Printer p, CodeStream str, String indent) {
269                for (SrcStoredDefinition sd : getUnstructuredEntitys()) {
270                        p.print(sd,str,indent);
271                }
272        }
273
274    public void SrcStoredDefinition.prettyPrint(Printer p, CodeStream str, String indent) {
275        if (hasSrcWithin()) {
276            str.print(indent, "within");
277            if (getSrcWithin().hasPackageName()) {
278                str.print(" ");
279                p.print(getSrcWithin().getPackageName(),str,indent);
280            }
281            str.println(";");
282        }
283        for (SrcClassDecl cd : getSrcClassDecls()) {
284            p.print(cd, str, indent);
285        }
286    }
287
288
289    public void SrcShortClassDecl.prettyPrint(Printer p, CodeStream str, String indent) {
290        str.print(indent);
291        indent = p.indent(indent);
292        if (getEncapsulated()) {
293            str.print("encapsulated ");
294        }
295        if (getPartial()) {
296            str.print("partial ");
297        }
298        if (getRedeclare()) {
299            str.print("redeclare ");
300        }
301        if (getFinal()) {
302            str.print("final ");
303        }
304        if (getInner()) {
305            str.print("inner ");
306        }
307        if (getOuter()) {
308            str.print("outer ");
309        }
310        if (getReplaceable()) {
311            str.print("replaceable ");
312        }
313       
314        str.print(getSrcRestriction(), " ");
315        p.print(getName(), str, indent);
316        str.print(" = ", getSrcExtendsClauseShortClass().getSuper().name());
317        if (getSrcExtendsClauseShortClass().hasSrcArraySubscripts()) {
318            p.print(getSrcExtendsClauseShortClass().getSrcArraySubscripts(), str, indent);
319        }
320        if (getSrcExtendsClauseShortClass().hasSrcClassModification()) {
321            p.print(getSrcExtendsClauseShortClass().getSrcClassModification(), str, indent);
322        }
323        if (hasSrcConstrainingClause()) {
324            p.print(getSrcConstrainingClause(), str, indent);
325        }
326    }
327
328    public void SrcFullClassDecl.prettyPrint(Printer p, CodeStream str, String indent) {
329        str.print(indent);
330        if (getEncapsulated()) {
331            str.print("encapsulated ");
332        }
333        if (getPartial()) {
334            str.print("partial ");
335        }
336        if (getRedeclare()) {
337            str.print("redeclare ");
338        }
339        if (getFinal()) {
340            str.print("final ");
341        }
342        if (getInner()) {
343            str.print("inner ");
344        }
345        if (getOuter()) {
346            str.print("outer ");
347        }
348        if (getReplaceable()) {
349            str.print("replaceable ");
350        }
351
352        str.print(getSrcRestriction(), " ");
353        if (isClassExtends()) {
354            str.print("extends ");
355        }
356        prettyPrintClassName(p, str, indent);
357
358        if (hasSrcStringComment()) {
359            p.print(getSrcStringComment(), str, indent);
360        }
361
362        if (hasSrcConstrainingClause()) {
363            str.print("constrainedby ");
364            p.print(getSrcConstrainingClause(), str, indent);
365            str.print(" ");
366            if (hasConstrainingClauseComment()) {
367                p.print(getConstrainingClauseComment(), str, indent);
368            }
369        }
370
371        str.println();
372
373        for (SrcClause cl : getSrcClauses()) {
374            p.print(cl, str, indent);
375        }
376
377        if (hasSrcExternalClause()) {
378            p.print(getSrcExternalClause(), str, indent);
379        }
380
381        if (hasSrcAnnotation()) {
382            p.print(getSrcAnnotation(), str, indent);
383        }
384
385        p.print(getSrcEndDecl(), str, indent);
386    }
387
388    public void SrcFullClassDecl.prettyPrintClassName(Printer p, CodeStream str, String indent) {
389        p.print(getName(), str, indent);
390    }
391
392    public void SrcParseAnnotation.prettyPrint(Printer p, CodeStream str, String indent) {
393        str.print(indent, "annotation ");
394        p.print(getSrcClassModification(), str, indent);
395        str.print(";");
396        str.println();
397    }
398
399    public void SrcClause.prettyPrint(Printer p, CodeStream str, String indent) {
400        String header = clauseHeader();
401        if (header != null) {
402            str.println(indent, header);
403        }
404        prettyPrintClauseBody(p, str, p.indent(indent), true);
405    }
406
407    syn String SrcClause.clauseHeader() = clauseHeader(" ");
408    syn String SrcClause.clauseHeader(String separator);
409    eq SrcPublicElementList.clauseHeader(String separator)     = "public";
410    eq SrcDefaultElementList.clauseHeader(String separator)    = null;
411    eq SrcProtectedElementList.clauseHeader(String separator)  = "protected";
412    eq SrcEquationClause.clauseHeader(String separator)        = "equation";
413    eq SrcInitialEquationClause.clauseHeader(String separator) = "initial" + separator + "equation";
414    eq SrcAlgorithm.clauseHeader(String separator)             = "algorithm";
415    eq SrcInitialAlgorithm.clauseHeader(String separator)      = "initial" + separator + "algorithm";
416
417    public abstract void SrcClause.prettyPrintClauseBody(Printer p, CodeStream str, String indent, boolean doFormating);
418
419    public void SrcElementList.prettyPrintClauseBody(Printer p, CodeStream str, String indent, boolean doFormatting) {
420        boolean prevWantsBlankLine = false;
421        boolean first = true;
422        for (SrcElement e : getSrcElements()) {
423            boolean wantsBlankLine = e.prettyPrintWantsBlankLine();
424            if (doFormatting && !first && (wantsBlankLine || prevWantsBlankLine)) {
425                str.println();
426            }
427            if (doFormatting && !e.prettyPrintsAsLine()) {
428                str.print(indent);
429                p.print(e, str, indent);
430                str.println(";");
431            } else {
432                p.print(e, str, indent);
433            }
434            prevWantsBlankLine = wantsBlankLine;
435            first = false;
436        }
437    }
438
439    syn boolean SrcElement.prettyPrintsAsLine();
440    eq SrcImportClause.prettyPrintsAsLine()     = true;
441    eq SrcExtendsClause.prettyPrintsAsLine()    = false;
442    eq SrcComponentClause.prettyPrintsAsLine()  = false;
443    eq SrcClassDecl.prettyPrintsAsLine()        = true;
444    eq SrcBadElement.prettyPrintsAsLine()       = true;
445
446    syn boolean SrcElement.prettyPrintWantsBlankLine() = false;
447    eq SrcClassDecl.prettyPrintWantsBlankLine()        = true;
448
449    public void SrcEquationClause.prettyPrintClauseBody(Printer p, CodeStream str, String indent, boolean doFormatting) {
450        for (SrcAbstractEquation e : getSrcAbstractEquations()) {
451            p.print(e, str, indent);
452            if (doFormatting) {
453                str.println(";");
454            }
455        }
456    }
457
458    public void SrcAlgorithm.prettyPrintClauseBody(Printer p, CodeStream str, String indent, boolean doFormatting) {
459        for (SrcStatement s : getSrcStatements()) {
460            p.print(s, str, indent);
461        }
462    }
463
464        public void SrcAssignStmt.prettyPrint(Printer p, CodeStream str, String indent) {
465                str.print(indent);
466                p.print(getLeft(), str, indent);
467                str.print(":=");
468                p.print(getRight(), str, indent);
469                str.println(';');
470        }
471
472    public void SrcFunctionCallStmt.prettyPrint(Printer p, CodeStream str, String indent) {
473        str.print(indent, "(");
474        boolean first = true;
475        for (SrcFunctionCallLeft fcl : getLefts()) {
476            if (!first) {
477                str.print(",");
478            }
479            first = false;
480            p.print(fcl, str, indent);
481        }
482        str.print(") := ");
483        p.print(getSrcFunctionCall(), str, indent);
484        str.println(";");
485    }
486
487    public void SrcBreakStmt.prettyPrint(Printer p, CodeStream str, String indent) {
488        str.println(indent, "break;");
489    }
490
491    public void SrcReturnStmt.prettyPrint(Printer p, CodeStream str, String indent) {
492        str.println(indent, "return;");
493    }
494
495    public void SrcIfStmt.prettyPrint(Printer p, CodeStream str, String indent) {
496        str.print(indent, "if ");
497        boolean first = true;
498        for (SrcIfWhenClause iwc : getSrcIfWhenClauses()) {
499            if (!first) {
500                str.print(indent, "elseif ");
501            }
502            first = false;
503            p.print(iwc, str, indent);
504        }
505        if (hasSrcElseClause())
506            p.print(getSrcElseClause(), str, indent);
507        str.println(indent, "end if;");
508    }
509
510    public void SrcElseClause.prettyPrint(Printer p, CodeStream str, String indent) {
511        if (getNumStmt() > 0) {
512            str.println(indent, "else");
513            for (SrcStatement stmt : getStmts()) {
514                p.print(stmt, str, p.indent(indent));
515            }
516        }
517    }
518
519
520    public void SrcWhenStmt.prettyPrint(Printer p, CodeStream str, String indent) {
521        str.print(indent, "when ");
522        boolean first = true;
523        for (SrcIfWhenClause iwc : getSrcIfWhenClauses()) {
524            if (!first) {
525                str.print(indent, "elsewhen ");
526            }
527            first = false;
528            p.print(iwc, str, p.indent(indent));
529        }
530        str.println(indent, "end when;");
531    }
532
533        public void SrcIfWhenClause.prettyPrint(Printer p, CodeStream str, String indent) {
534                p.print(getTest(), str, indent);
535                str.println(" then");
536                for (SrcStatement s : getSrcStatements()) {
537                        p.print(s, str, p.indent(indent));
538                }
539        }
540
541    public void SrcForStmt.prettyPrint(Printer p, CodeStream str, String indent) {
542        str.print(indent, "for ");
543        boolean first = true;
544        for (SrcForIndex fi : getSrcForIndexs()) {
545            if (!first) {
546                str.print(",");
547            }
548            first = false;
549            p.print(fi, str, indent);
550        }
551        str.println(" loop");
552        p.print(getSrcStatementList(), str, p.indent(indent));
553        str.println(indent, "end for;");
554    }
555
556    public void SrcWhileStmt.prettyPrint(Printer p, CodeStream str, String indent) {
557        str.print(indent, "while ");
558        p.print(getTest(), str, indent);
559        str.println(" loop");
560        for (SrcStatement s : getSrcWhileStmts())
561            p.print(s, str, p.indent(indent));
562        str.println(indent, "end while;");
563    }
564
565        public void SrcForIndex.prettyPrint(Printer p, CodeStream str, String indent) {
566                str.print(getSrcForIndexDecl().name());
567                if (hasSrcExp()) {
568                        str.print(" in ");
569                        p.print(getSrcExp(), str, indent);
570                }
571        }
572       
573        // For debugging
574        public void SrcLibNode.prettyPrint(Printer p, CodeStream str, String indent) {
575                str.formatln("%s%structured library '%s' at '%s'", indent, 
576                                (getStructured() ? "S" : "Uns"), name(), dirName());
577        }
578
579        syn boolean SrcComponentClause.isEnumComponentClause() = false;
580        eq SrcEnumComponentClause.isEnumComponentClause() = true;
581
582    public void SrcComponentClause.prettyPrint(Printer p, CodeStream str, String indent) {
583        if (getRedeclare()) {
584            str.print("redeclare ");
585        }
586        if (getFinal()) {
587            str.print("final ");
588        }
589        if (getInner()) {
590            str.print("inner ");
591        }
592        if (getOuter()) {
593            str.print("outer ");
594        }
595        if (getReplaceable()) {
596            str.print("replaceable ");
597        }
598        if (hasSrcTypePrefixFlow()) {
599            str.print(getSrcTypePrefixFlow(), " ");
600        }
601        if (hasSrcTypePrefixVariability()) {
602            str.print(getSrcTypePrefixVariability(), " ");
603        }
604        if (hasSrcTypePrefixInputOutput()) {
605            str.print(getSrcTypePrefixInputOutput(), " ");
606        }
607       
608        p.print(getClassName(), str, indent);
609        p.print(getTypeArraySubscriptsOpt(), str, indent);
610       
611        str.print(" ");
612        if (isEnumComponentClause()) {
613            str.print("(");
614            if (hasSrcComponentDecl()) {
615                getSrcComponentDecls().prettyPrintWithSep(p, str, indent, ", ");
616            } else {
617                str.print(":");
618            }
619            str.print(")");
620        } else {
621            getSrcComponentDecls().prettyPrintWithSep(p, str, indent, ", ");
622        }
623       
624        p.print(getSrcConstrainingClauseOpt(), str, indent);
625    }
626
627    public void SrcComponentDecl.prettyPrint(Printer p, CodeStream str, String indent) {
628        str.print(getName().getID());
629        p.print(getVarArraySubscriptsOpt(), str, indent);
630        p.print(getSrcModificationOpt(), str, indent);
631        p.print(getSrcConditionalAttributeOpt(), str, indent);
632    }
633
634    public void SrcConditionalAttribute.prettyPrint(Printer p, CodeStream str, String indent) {
635        str.print(" if ");
636        p.print(getSrcExp(), str, indent);
637    }
638
639    public void SrcConstrainingClause.prettyPrint(Printer p, CodeStream str, String indent) {
640        str.print(" constrainedby ", getSrcAccess().name());
641        if (hasSrcClassModification()) {
642            str.print(' ');
643            p.print(getSrcClassModification(), str, indent);
644        }
645    }
646
647        public void SrcArraySubscripts.prettyPrint(Printer p, CodeStream str, String indent) {
648                if (getNumSrcSubscript()>0) {
649                        str.print("[");
650                        for (int i=0;i<getNumSrcSubscript();i++) {
651                                p.print(getSrcSubscript(i),str,indent);
652                                if (i<getNumSrcSubscript()-1)
653                                        str.print(",");
654                        }
655                        str.print("]");
656                }
657        }
658
659        public void SrcColonSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
660                str.print(":");
661        }
662       
663        public void SrcExpSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
664                p.print(getSrcExp(),str,indent);
665        }
666
667        public void SrcRangeExp.prettyPrint(Printer p, CodeStream str, String indent) { 
668                for (int i=0;i<getNumSrcExp();i++) {
669                        p.print(getSrcExp(i),str,indent);
670                        if (i<getNumSrcExp()-1)
671                                str.print(":");
672                }
673        }
674
675    public void SrcImportClause.prettyPrint(Printer p, CodeStream str, String indent) {
676        str.print(indent, "import ");
677        prettyPrintPreName(p, str, indent);
678        p.print(getPackageName(), str, indent);
679        prettyPrintPostName(p, str, indent);
680        p.print(getSrcComment(), str, indent);
681        str.println(";");
682    }
683
684    public void SrcImportClause.prettyPrintPreName(Printer p, CodeStream str, String indent) {}
685
686    public void SrcImportClauseRename.prettyPrintPreName(Printer p, CodeStream str, String indent) {
687        p.print(getSrcIdDecl(), str, indent);
688        str.print(" = ");
689    }
690
691    public void SrcImportClause.prettyPrintPostName(Printer p, CodeStream str, String indent) {}
692
693    public void SrcImportClauseUnqualified.prettyPrintPostName(Printer p, CodeStream str, String indent) {
694        str.print(".*");
695    }
696
697    public void SrcExtendsClause.prettyPrint(Printer p, CodeStream str, String indent) {
698        str.print(indent, "extends ");
699        p.print(getSuper(), str, indent);
700        p.print(getSrcClassModificationOpt(), str, indent);
701    }
702
703        public void SrcCompleteModification.prettyPrint(Printer p, CodeStream str, String indent) {
704                p.print(getSrcClassModification(),str,indent);
705                if (hasSrcValueModification())
706                  p.print(getSrcValueModification(),str,indent);
707        }
708       
709        public void SrcValueModification.prettyPrint(Printer p, CodeStream str, String indent) {
710                str.print(" = ");
711                p.print(getSrcExp(),str,indent);
712        }
713       
714    public void SrcDummyModification.prettyPrint(Printer p, CodeStream str, String indent) {
715        str.print(" = ");
716        p.print(myFExp(),str,indent);
717    }
718       
719        public void SrcClassModification.prettyPrint(Printer p, CodeStream str, String indent) {
720                str.print("(");
721                for (int i = 0; i < getNumSrcArgument(); i++) {
722                        p.print(getSrcArgument(i), str, indent);
723                        if (i < getNumSrcArgument() - 1)
724                                str.print(", ");
725                }
726                str.print(")");
727        }
728
729    public void SrcElementModification.prettyPrint(Printer p, CodeStream str, String indent) {
730        if (getEach()) {
731            str.print("each ");
732        }
733        if (getFinal()) {
734            str.print("final ");
735        }
736        p.print(getName(), str, indent);
737        if (hasSrcModification()) {
738            p.print(getSrcModification(), str, indent);
739        }
740    }
741
742    public void SrcComponentRedeclare.prettyPrint(Printer p, CodeStream str, String indent) {
743        if (getEach()) {
744            str.print("each ");
745        }
746        if (getFinal()) {
747            str.print("final ");
748        }
749        p.print(getSrcComponentClause(), str, indent);
750    }
751
752    public void SrcClassRedeclare.prettyPrint(Printer p, CodeStream str, String indent) {
753        if (getEach())
754            str.print("each ");
755        if (getFinal())
756            str.print("final ");
757        p.print(getSrcBaseClassDecl(), str, indent);
758    }
759
760        public void Opt.prettyPrint(Printer p, CodeStream str, String indent) {
761                if (getNumChild()>0)
762                        p.print(getChild(0),str,indent);
763        }
764
765        public void SrcEquation.prettyPrint(Printer p,CodeStream str, String indent) {
766                p.print(getLeft(),str,indent);
767                str.print(" = ");
768                p.print(getRight(),str,indent);
769        }
770
771        public void SrcConnectClause.prettyPrint(Printer p,CodeStream str, String indent) {
772                str.print("connect(");
773                p.print(getConnector1(),str,indent);
774                str.print(",");
775                p.print(getConnector2(),str,indent);
776                str.print(")");
777        }
778       
779        public void SrcDotAddExp.prettyPrint(Printer p,CodeStream str, String indent) {
780                p.print(getLeft(),str,indent);
781                if(!(getRight() instanceof SrcNegExp)) 
782                        str.print(op());
783                p.print(getRight(),str,indent);
784        }
785               
786        public void SrcDotSubExp.prettyPrint(Printer p, CodeStream str, String indent) {
787                p.print(getLeft(),str,indent);
788                str.print(op());
789                if (getRight().isAddOrSub()) {
790                        str.print("(");
791                        p.print(getRight(),str,indent);
792                        str.print(")");
793                } else
794                        p.print(getRight(),str,indent);
795        }
796               
797        public void SrcDotMulExp.prettyPrint(Printer p,CodeStream str, String indent) {
798                if (getLeft().isAddOrSub()) {
799                        str.print("(");
800                        p.print(getLeft(),str,indent);
801                        str.print(")");
802                } else
803                        p.print(getLeft(),str,indent); 
804                str.print(op());
805                if (getRight().isAddOrSub()) {
806                        str.print("(");
807                        p.print(getRight(),str,indent);
808                        str.print(")");
809                } else
810                        p.print(getRight(),str,indent);
811        }
812               
813        public void SrcDotDivExp.prettyPrint(Printer p, CodeStream str, String indent){
814                if (getLeft().isAddOrSub()) {
815                        str.print("(");
816                        p.print(getLeft(),str,indent);
817                        str.print(")");
818                } else
819                        p.print(getLeft(),str,indent);
820                str.print(op());       
821                str.print("(");
822                p.print(getRight(),str,indent);
823                str.print(")");
824        }
825               
826        public void SrcDotPowExp.prettyPrint(Printer p, CodeStream str, String indent){
827                if (!(getLeft().isPrimary())) {
828                        str.print("(");
829                        p.print(getLeft(),str,indent);
830                        str.print(")");
831                } else
832                        p.print(getLeft(),str,indent);
833                str.print(op());
834                if (!(getRight().isPrimary())) {
835                        str.print("(");
836                        p.print(getRight(),str,indent);
837                        str.print(")");
838                } else
839                        p.print(getRight(),str,indent);
840        }
841               
842        public void SrcNegExp.prettyPrint(Printer p,CodeStream str, String indent){
843                str.print("-");
844                if (getSrcExp().isAddOrSub()) {
845                        str.print("(");
846                        p.print(getSrcExp(),str,indent);
847                        str.print(")");
848                } else
849                        p.print(getSrcExp(),str,indent);
850        }
851       
852        public void SrcIfExp.prettyPrint(Printer p, CodeStream str, String indent) {
853        prettyPrintAsElseExp(p, str, indent);
854    }
855   
856    public void SrcExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
857        str.print(' ');
858        p.print(this, str, indent);
859    }
860   
861    public void SrcIfExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
862        str.print("if ");
863        p.print(getSrcIfExp(), str, indent);
864        str.print(" then ");
865        p.print(getThenExp(), str, indent);
866        str.print(" else");
867        getElseExp().prettyPrintAsElseExp(p, str, indent);
868    }
869       
870        public void SrcRealLitExp.prettyPrint(Printer p, CodeStream str, String indent) {
871                str.print(getUNSIGNED_NUMBER());
872        }
873
874        public void SrcIntegerLitExp.prettyPrint(Printer p, CodeStream str, String indent) {
875                str.print(getUNSIGNED_INTEGER());
876        }
877       
878        public void SrcTimeExp.prettyPrint(Printer p, CodeStream str, String indent) {
879                str.print("time");
880        }
881
882        public void SrcEndExp.prettyPrint(Printer p, CodeStream str, String indent) {
883                str.print("end");
884        }
885       
886        public void SrcFunctionCall.prettyPrint(Printer p, CodeStream str, String indent) {
887                p.print(getName(),str,indent);
888                str.print("("); 
889                p.print(getSrcFunctionArgumentsOpt(),str,indent);
890                str.print(")");
891        }
892
893    public void SrcIterExp.prettyPrint(Printer p, CodeStream str, String ident) {
894        getSrcExp().prettyPrint(p,str,ident);
895        str.print(" for ");
896        for (int i = 1; i < getNumChild(); i++) {
897            getChild(i).prettyPrint(p, str, ident);
898        }
899    }
900
901        public void SrcFunctionArguments.prettyPrint(Printer p, CodeStream str, String indent) {
902                for (int i = 0; i < getNumSrcExp(); i++) {
903                        p.print(getSrcExp(i), str, indent);
904                        if (i < getNumSrcExp() + getNumSrcNamedArgument() - 1) {
905                                str.print(",");
906                    }
907                }
908                for (int i = 0; i < getNumSrcNamedArgument(); i++) {
909            p.print(getSrcNamedArgument(i), str, indent);
910            if (i < getNumSrcNamedArgument() - 1) {
911                str.print(",");
912            }
913        }
914        }
915       
916        public void SrcNamedArgument.prettyPrint(Printer p, CodeStream str, String indent) {
917            p.print(getName(), str, indent);
918            str.print("=");
919            getSrcExp().prettyPrint(p, str, indent);
920        }
921
922    public void SrcIdDecl.prettyPrint(Printer p, CodeStream str, String indent) {
923        str.print(getID());
924    }
925
926    public void SrcEndDecl.prettyPrint(Printer p, CodeStream str, String indent) {
927        str.println(indent, "end ", getEndID(), ";");
928    }
929
930    public void SrcNamedAccess.prettyPrint(Printer p, CodeStream str, String indent) {
931        str.print(getID());
932    }
933
934    public void SrcArrayAccess.prettyPrint(Printer p, CodeStream str, String indent) {
935        str.print(getID());
936        getSrcArraySubscripts().prettyPrint(p, str, indent);
937    }
938
939        public void SrcDot.prettyPrint(Printer p, CodeStream str, String indent) {
940                getSrcNamedAccesss().prettyPrintWithSep(p, str, indent, ".");
941        }
942
943        public void SrcGlobalAccess.prettyPrint(Printer p, CodeStream str, String indent) {
944                str.print(".");
945                p.print(getSrcAccess(),str,indent);     
946        }
947
948    public void SrcStringLitExp.prettyPrint(Printer p, CodeStream str, String indent) {
949        str.print("\"", getSTRING(), "\"");
950    }
951
952        public void SrcBooleanLitExpTrue.prettyPrint(Printer p, CodeStream str, String indent) {
953                str.print("true");
954        }
955
956        public void SrcBooleanLitExpFalse.prettyPrint(Printer p, CodeStream str, String indent) {
957                str.print("false");
958        }
959       
960        public void SrcArrayConstructor.prettyPrint(Printer p, CodeStream str, String indent) {
961                str.print("{");
962                p.print(getSrcFunctionArguments(),str,indent);
963                str.print("}");
964        }
965       
966        public void SrcMatrix.prettyPrint(Printer p, CodeStream str, String indent) {
967                str.print("[");
968                getRows().prettyPrintWithSep(p, str, indent, "; ");
969                str.print("]");
970        }
971       
972        public void SrcMatrixRow.prettyPrint(Printer p, CodeStream str, String indent) {
973                getSrcExps().prettyPrintWithSep(p, str, indent, ", ");
974        }
975       
976        syn boolean SrcExp.isAddOrSub() = false;
977        eq SrcDotAddExp.isAddOrSub() = true;
978        eq SrcDotSubExp.isAddOrSub() = true;
979        syn boolean SrcExp.isPrimary() = false;
980        eq SrcAccessExp.isPrimary() = true;
981        eq SrcRealLitExp.isPrimary() = true;
982
983    public void SrcLogBinExp.prettyPrint(Printer p, CodeStream str, String indent) {
984        p.print(getLeft(),str,indent);
985        str.print(op());
986        p.print(getRight(),str,indent);
987    }
988
989        syn String SrcBinExp.op();
990        eq SrcLtExp.op()     = "<";
991        eq SrcLeqExp.op()    = "<=";
992        eq SrcGtExp .op()    = ">";
993        eq SrcGeqExp.op()    = ">=";
994        eq SrcEqExp.op()     = "==";
995        eq SrcNeqExp.op()    = "<>";
996        eq SrcOrExp.op()     = " or ";
997        eq SrcAndExp.op()    = " and ";
998        eq SrcAddExp.op()    = "+";
999        eq SrcSubExp.op()    = "-";
1000        eq SrcMulExp.op()    = "*";
1001        eq SrcDivExp.op()    = "/";
1002        eq SrcPowExp.op()    = "^";
1003        eq SrcDotAddExp.op() = ".+";
1004        eq SrcDotSubExp.op() = ".-";
1005        eq SrcDotMulExp.op() = ".*";
1006        eq SrcDotDivExp.op() = "./";
1007        eq SrcDotPowExp.op() = ".^";
1008       
1009        public void SrcNotExp.prettyPrint(Printer p, CodeStream str, String indent) {
1010                str.print("not ");
1011                p.print(getSrcExp(),str,indent);
1012        }
1013
1014
1015        syn String SrcTypePrefixFlow.toString();
1016        eq SrcFlow.toString()   = "flow";
1017        eq SrcStream.toString() = "stream";
1018        syn String SrcTypePrefixInputOutput.toString();
1019        eq SrcInput.toString()  = "input";
1020        eq SrcOutput.toString() = "output";
1021        syn String SrcTypePrefixVariability.toString();
1022        eq SrcParameter.toString()  = "parameter";
1023        eq SrcDiscrete.toString()   = "discrete";
1024        eq SrcConstant.toString()   = "constant";
1025        eq SrcContinuous.toString() = "";
1026       
1027        syn String FType.toString() = isArray() ? name() + size() : name();
1028       
1029    eq FFunctionType.toString() {
1030        StringBuilder sb = new StringBuilder();
1031        sb.append("((");
1032        sb.append(getOutputs().toString());
1033        sb.append(") = ");
1034        sb.append(getName());
1035        sb.append("(");
1036        sb.append(getInputs().toString());
1037        sb.append("))");
1038        if (ndims() > 0) {
1039            sb.append(size());
1040        }
1041        return sb.toString();
1042    }
1043       
1044        syn String FRecordComponentType.toString() = getFType() + " " + getName();
1045   
1046    public void FRecordComponentType.prettyPrint(Printer p, CodeStream str, String indent) {
1047        str.print(getFType(), " ", getName());
1048    }
1049
1050}
1051
1052aspect TypeStructurePrint {
1053
1054    /**
1055     * Returns what is printed by {@link #printStructure(CodeStream)} as a String.
1056     */
1057    public String FType.printStructure() {
1058        ByteArrayOutputStream os = new ByteArrayOutputStream();
1059        CodeStream str = new NotNullCodeStream(os);
1060        printStructure(str);
1061        return os.toString();
1062    }
1063
1064    /**
1065     * Prints a string representation of the structure of this type. The
1066     * representation for scalar types is its name. The representation for composite
1067     * types its name and size, and the name and size of any components. This can be
1068     * used to provide more informative error messages for composite types.
1069     *
1070     * @param str
1071     *            the stream that is printed to.
1072     */
1073    public void FType.printStructure(CodeStream str) {
1074        str.print(toString());
1075    }
1076
1077    public void FRecordType.printStructure(CodeStream str) {
1078        str.print(name());
1079        if (hasComponent()) {
1080            str.print("(");
1081            String sep = "";
1082            for (FRecordComponentType frct : getComponents()) {
1083                str.print(sep);
1084                frct.printStructure(str);
1085                sep = ", ";
1086            }
1087            str.print(")");
1088        }
1089        if (ndims() > 0) {
1090            str.print(size());
1091        }
1092    }
1093
1094    public void FRecordComponentType.printStructure(CodeStream str) {
1095        str.print(getFType().toString());
1096    }
1097
1098}
1099
1100aspect FlatPrettyPrint {
1101
1102    public void FClass.prettyPrint(Printer p, CodeStream str, String indent) {
1103        String nextInd = p.indent(indent);
1104        str.formatln("%sfclass %s", indent, name());
1105        ArrayList<FVariable> protectedVars = new ArrayList<FVariable>();
1106        for (FVariable fv : getFVariables()) {
1107            if (!fv.isDerivativeVariable() && !fv.isPreVariable() &&
1108                    !fv.getVisibilityType().isRuntimeOptionVisibility()) {
1109                if (fv.isProtected()) {
1110                  protectedVars.add(fv);
1111                } else {
1112                    p.print(fv, str, nextInd);
1113                    str.println(";");
1114                }
1115            }
1116        }
1117        if (!protectedVars.isEmpty()) {
1118            str.println(indent, "protected");
1119            for (FVariable fv : protectedVars) {
1120                p.print(fv, str, nextInd);
1121                str.println(";");
1122            }
1123        }
1124        if (getNumFGlobalVariable() > 0) {
1125            str.println(indent, "global variables");
1126            for (FVariable fv : getFGlobalVariables()) {
1127                p.print(fv, str, nextInd);
1128                str.println(";");
1129            }
1130        }
1131        if (getNumFInitialEquation() > 0) {
1132            str.println(indent, "initial equation");
1133        }
1134        getFInitialEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
1135
1136        if (getNumParameterEquation() > 0) {
1137            str.println(indent, "parameter equation");
1138        }
1139        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
1140   
1141        prettyPrintEquations(p, str, indent);
1142       
1143        if (getNumFFunctionDecl() > 0 || getNumFRecordDecl() > 0 || 
1144                getNumFEnumDecl() > 0 || getNumFDerivedType() > 0) {
1145            str.println();
1146            str.formatln("%spublic", indent);
1147            p.print(getFFunctionDecls(), str, nextInd);
1148            p.print(getFRecordDecls(), str, nextInd);
1149            p.print(getFEnumDecls(), str, nextInd);
1150            p.print(getFDerivedTypes(), str, nextInd);
1151        }
1152       
1153        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p, indent, ";" + str.getLineEnder());
1154
1155        str.println(indent, "end ", name(), ";");
1156    }
1157   
1158    public void FClass.prettyPrintEquations(Printer p, CodeStream str, String indent) {
1159        boolean wroteEquation = false;
1160        String nextInd = p.indent(indent);
1161        for (FAbstractEquation e : equationsForPrinting()) {
1162            if (e instanceof FAlgorithm) {
1163                p.print(e, str, indent);
1164                wroteEquation = false;
1165            } else {
1166                if (!e.isIgnored()) {
1167                    if (!wroteEquation) {
1168                        str.println(indent, "equation");
1169                        wroteEquation = true;
1170                    }
1171                    p.print(e, str, nextInd);
1172                    str.println(";");
1173                }
1174            }
1175        }
1176    }
1177   
1178    public Iterable<FAbstractEquation> FClass.equationsForPrinting() {
1179        return getFAbstractEquations();
1180    }
1181
1182        syn String FVariable.prettyPrintType() = 
1183                getDerivedType().isEmpty() ? type().scalarType().toString() : getDerivedType();
1184        syn String FAbstractVariable.displayName()  = name();
1185        eq FVariable.displayName()                  = getFAccess().toString();
1186        eq FDerivativeVariable.displayName()        = name();
1187        eq FPreBooleanVariable.displayName()        = name();
1188        eq FPreEnumVariable.displayName()           = name();
1189        eq FPreIntegerVariable.displayName()        = name();
1190        eq FPreRealVariable.displayName()           = name();
1191        eq FPreStringVariable.displayName()         = name();
1192        eq FDummyDerivativeVariable.displayName()   = derPrefixName();
1193        eq FDynamicDerivativeVariable.displayName() = dynDerName();
1194
1195    public void FVariable.prettyPrint(Printer p, CodeStream str, String indent) {
1196        str.print(indent);
1197       
1198        str.print(getTypePrefixVariability());
1199       
1200        if (!getCausalityConnectorPrefix().isNone()) {
1201            str.print(getCausalityConnectorPrefix(), " ");
1202        }
1203       
1204        str.print(prettyPrintType(), " ", displayName());
1205   
1206        getFAttributeList().prettyPrintFAttributeList(str, p);
1207       
1208        if (hasBindingExp()) {
1209            str.print(" = ");
1210            FExp bindingExp = getBindingExp();
1211            p.print(bindingExp, str, indent);
1212           
1213        }
1214       
1215        p.print(getFStringCommentOpt(), str, indent);
1216       
1217        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p);
1218
1219        if (isIndependentParameter() && hasBindingExp()) {
1220            str.print(" /* ");
1221            try {
1222                str.print(getBindingExp().ceval());
1223            } catch (ConstantEvaluationException e){
1224                str.print("evaluation error");
1225            }
1226            str.print(" */");
1227        }
1228    }
1229
1230    public void FVariable.printFAttributes(CodeStream str, String ... attributes) {
1231        boolean first = true;
1232        for (String attribute : attributes) {
1233            if (attributeSet(attribute)) {
1234                if (!first) {
1235                    str.print(',');
1236                }
1237                first = false;
1238                str.print(attribute, "=", attributeExp(attribute));
1239            }
1240        }
1241    }
1242
1243    public void List.prettyPrintFAttributeList(CodeStream str, Printer p) {
1244        prettyPrintFAttributeList(str, p, "", "");
1245    }
1246
1247    public void List.prettyPrintFAnnotationAttributeList(CodeStream str, Printer p) {
1248        prettyPrintFAnnotationAttributeList(str, p, "");
1249    }
1250
1251    public void List.prettyPrintFAnnotationAttributeList(CodeStream str, Printer p, String extraEnd) {
1252        prettyPrintFAnnotationAttributeList(str, p, " ", extraEnd);
1253    }
1254   
1255    public void List.prettyPrintFAnnotationAttributeList(CodeStream str, Printer p, String extraStart, String extraEnd) {
1256        prettyPrintFAttributeList(str, p.annotationPrinter(), extraStart + "annotation", extraEnd);
1257    }
1258   
1259    public void List.prettyPrintFAttributeList(CodeStream str, Printer p, String extraStart, String extraEnd) {
1260        boolean firstAttr = true;
1261        for (ASTNode astNode : this) {
1262            FAttribute attr = (FAttribute)astNode;
1263            if (attr.shouldPrettyPrint(p)) {
1264                if (!firstAttr) 
1265                    str.print(",");
1266                else
1267                    str.print(extraStart, "(");
1268                firstAttr = false;
1269                p.print(attr, str, "");
1270            }
1271        }
1272        if (!firstAttr) {
1273            str.print(")", extraEnd);
1274        }
1275    }
1276   
1277    public boolean FAttribute.shouldPrettyPrint(Printer p) {
1278        if (p.inAnnotation())
1279            return  isAnnotation();
1280        return getAttributeSet() && (isModification() || isInternal());
1281
1282    }
1283       
1284    public void FAttribute.prettyPrint(Printer p, CodeStream str, String indent) {
1285                       
1286                                                if (hasFEach())
1287                                                        str.print("each ");
1288                                                if (hasFFinal())
1289                                                        str.print("final ");   
1290                                        str.print(getName().name());
1291                                        getFAttributeList().prettyPrintFAttributeList(str, p);
1292                                        if (hasValue()) {
1293                                                str.print(" = ");
1294                                                p.print(getValue(),str,"");
1295                                                }
1296        }
1297
1298    public void FFunctionDecl.prettyPrint(Printer p, CodeStream str, String indent) {
1299        str.println(indent, "function ", name());
1300        getFFunctionVariables().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1301        p.print(getFAlgorithm(), str, indent);
1302        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p, indent, ";" + str.getLineEnder());
1303        str.println(indent, "end ", name(), ";");
1304        str.println();
1305    }
1306
1307    public void FRecordDecl.prettyPrint(Printer p, CodeStream str, String indent) {
1308        str.println(indent, "record ", name());
1309        getFVariables().prettyPrintWithFix(p, str, p.indent(indent), "", ";" + str.getLineEnder());
1310        str.println(indent, "end ", name(), ";");
1311        str.println();
1312    }
1313
1314    public void FEnumDecl.prettyPrint(Printer p, CodeStream str, String indent) {
1315        str.print(indent, "type ", getName().name(), " = enumeration(");
1316        p.print(getFEnumSpecification(), str, indent);
1317        str.print(")");
1318        FDerivedType t = myFDerivedType();
1319        if (t != null && t.getFAttributes().getNumChild() > 0) {
1320            str.print("(");
1321            t.getFAttributes().prettyPrintWithSep(p, str, indent, ", ");
1322            str.print(")");
1323        }
1324        str.println(";");
1325        str.println();
1326    }
1327
1328    public void FDerivedType.prettyPrint(Printer p, CodeStream str, String indent) {
1329        prettyPrintWithName(p, str, indent, getName());
1330    }
1331   
1332    private void FDerivedType.prettyPrintWithName(Printer p, CodeStream str, String indent, String name) {
1333        if (!getBaseType().isEnum()) {
1334            str.print(indent, "type ", name, " = ", getBaseType());
1335            getFAttributeList().prettyPrintFAttributeList(str, p);
1336            str.println(";");
1337        }
1338    }
1339
1340    public abstract void FEnumSpecification.prettyPrint(Printer p, CodeStream str, String indent);
1341
1342    public void FEnumLiteralList.prettyPrint(Printer p, CodeStream str, String indent) {
1343        getFEnumLiterals().prettyPrintWithSep(p, str, indent, ", ");
1344    }
1345
1346    public void FEnumLiteral.prettyPrint(Printer p, CodeStream str, String indent) {
1347                p.print(getName(), str, indent);
1348                p.print(getFStringCommentOpt(), str, indent);
1349    }
1350
1351    public void InstEnumLiteral.prettyPrint(Printer p, CodeStream str, String indent) {
1352                str.print(indent, name());
1353        SrcStringComment comment = myStringComment();
1354        if (comment != null) {
1355            comment.prettyPrint(p, str, indent);
1356        }
1357    }
1358
1359    public void FStringComment.prettyPrint(Printer p, CodeStream str, String indent) {
1360        str.print(" \"", getComment(), "\"");
1361    }
1362
1363    public void FFunctionVariable.prettyPrint(Printer p, CodeStream str, String indent) {
1364        if (!getCausalityConnectorPrefix().isNone()) {
1365            str.print(getCausalityConnectorPrefix(), " ");
1366        }
1367        str.print(getType().scalarType());
1368        if (isArray()) {
1369            str.print("[");
1370            for (int i = 0; i < ndims(); i++) {
1371                str.print(":");
1372                if (i < ndims() - 1) {
1373                    str.print(",");
1374                }
1375            }
1376            str.print("]");
1377        }
1378        str.print(" ", name());
1379        getFAttributeList().prettyPrintFAttributeList(str, p);
1380        if (hasBindingExp()) {
1381            str.print(" := ");
1382            p.print(getBindingExp(), str, indent);
1383        }
1384    }
1385
1386    public void FAccessPart.prettyPrint(Printer p, CodeStream str, String indent) {
1387        str.print(getName());
1388                if (hasFArraySubscripts())
1389                        p.print(getFArraySubscripts(),str,indent);
1390    }
1391   
1392    public void FAccess.prettyPrint(Printer p, CodeStream str, String indent) {
1393    }
1394   
1395    public void FAccessString.prettyPrint(Printer p, CodeStream str, String indent) {
1396                str.print(getName());
1397    }
1398   
1399    public void FAccessFull.prettyPrint(Printer p, CodeStream str, String indent) {
1400                for (int i = 0, n = getNumFAccessPart(); i < n; i++) {
1401                        p.print(getFAccessPart(i), str, indent);
1402                        if (i < n - 1)
1403                                str.print(".");
1404                }
1405    }
1406   
1407    public void FArraySubscripts.prettyPrint(Printer p, CodeStream str, String indent) {
1408        str.print("[");
1409        for (int i = 0; i < numSubscript(); i++) {
1410            subscript(i).prettyPrint(p, str, indent);
1411            if (i < numSubscript() - 1) {
1412                str.print(",");
1413            }
1414        }
1415        str.print("]");
1416        }
1417
1418        public void FColonSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1419                str.print(":");
1420        }
1421
1422        public void FIntegerSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1423                str.print(getValue());
1424        }
1425       
1426        public void FExpSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1427                p.print(getFExp(),str,indent);
1428        }
1429
1430    public void IntegerSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1431        str.print(value);
1432    }
1433
1434    public String IntegerSubscript.prettyPrint(String indent) {
1435        return String.valueOf(value);
1436    }
1437
1438        protected void FRangeExp.prettyPrintExp(Printer p, CodeStream str, String indent) { 
1439                for (int i=0;i<getNumFExp();i++) {
1440                        p.print(getFExp(i),str,indent);
1441                        if (i<getNumFExp()-1)
1442                                str.print(":");
1443                }
1444        }
1445
1446
1447        public void FEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1448                str.print(indent);
1449        p.print(getLeft(),str,indent);
1450                str.print(" = ");
1451                p.print(getRight(),str,indent);
1452        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p);
1453        }
1454
1455
1456        public void FIfWhenElseEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1457                str.print(indent);
1458                if (isElse())
1459                        str.print("else");
1460                prettyPrintHead(p, str, indent);
1461                getFAbstractEquations().prettyPrintWithFix(p, str, p.indent(indent), "", ";" + str.getLineEnder());
1462                prettyPrintTail(p, str, indent);
1463        }
1464
1465        protected void FIfWhenElseEquation.prettyPrintHead(Printer p, CodeStream str, String indent) {
1466                str.println();
1467        }
1468
1469        protected void FIfWhenElseEquation.prettyPrintTail(Printer p, CodeStream str, String indent) {
1470        }
1471
1472    protected void FIfWhenEquation.prettyPrintHead(Printer p, CodeStream str, String indent) {
1473        str.print(ifWhenType(), " ");
1474        p.print(getTest(), str, indent);
1475        str.println(" then");
1476    }
1477
1478    protected void FIfWhenEquation.prettyPrintTail(Printer p, CodeStream str, String indent) {
1479        if (hasElse()) 
1480            p.print(getElse(), str, indent);
1481        if (!isElse()) {
1482            str.print(indent, "end ", ifWhenType());
1483        }
1484    }
1485
1486        syn String FIfWhenEquation.ifWhenType();
1487        eq FIfEquation.ifWhenType()   = "if";
1488        eq FWhenEquation.ifWhenType() = "when";
1489       
1490
1491    public void FConnectClause.prettyPrint(Printer p, CodeStream str, String indent) {
1492        str.print(indent, "connect(");
1493        p.print(getConnector1(), str, indent);
1494        str.print(", ");
1495        p.print(getConnector2(), str, indent);
1496        str.print(")");
1497    }
1498
1499        public void FFunctionCallEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1500                str.print(indent);
1501                if (getNumLeft() > 0) {
1502                        str.print("(");
1503                        getLefts().prettyPrintWithSep(p, str, indent, ", ");
1504                        str.print(") = ");
1505                }
1506                p.print(getCall(), str, indent);
1507        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p);
1508        }
1509       
1510        public void FAlgorithm.prettyPrint(Printer p, CodeStream str, String indent) {
1511                str.print(indent);
1512                str.println("algorithm");
1513                getFStatements().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1514        }
1515       
1516        public void FAssignStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1517                p.print(getLeft(), str, indent);
1518                str.print(" := ");
1519                p.print(getRight(), str, indent);
1520        }
1521       
1522        public void FFunctionCallStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1523                if (getNumLeft() > 0) {
1524                        str.print("(");
1525                        getLefts().prettyPrintWithSep(p, str, indent, ", ");
1526                        str.print(") := ");
1527                }
1528                p.print(getCall(), str, indent);
1529        }
1530       
1531        public void FBreakStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1532                str.print("break");
1533        }
1534       
1535        public void FReturnStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1536                str.print("return");
1537        }
1538
1539    public void FIfWhenStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1540        getFIfWhenClauses().prettyPrintWithSep(p, str, indent, indent + "else");
1541        prettyPrintElse(p, str, indent);
1542        str.print(indent, "end ", getKeyword());
1543    }
1544
1545    protected void FIfWhenStmt.prettyPrintElse(Printer p, CodeStream str, String indent) {}
1546
1547    protected void FIfStmt.prettyPrintElse(Printer p, CodeStream str, String indent) {
1548        if (getNumElseStmt() > 0) {
1549            str.println(indent, "else");
1550            getElseStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1551        }
1552    }
1553
1554    public void FIfWhenClause.prettyPrint(Printer p, CodeStream str, String indent) {
1555        str.print(getKeyword(), " ");
1556        p.print(getTest(), str, indent);
1557        str.println(" then");
1558        getFStatements().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1559    }
1560
1561        syn String FIfWhenStmt.getKeyword() = null;
1562        eq FIfStmt.getKeyword() = "if";
1563        eq FWhenStmt.getKeyword() = "when";
1564        inh String FIfWhenClause.getKeyword();
1565        eq FIfWhenStmt.getFIfWhenClause(int i).getKeyword() = getKeyword();
1566
1567    public void FForStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1568        str.print("for ");
1569        p.print(getIndex(), str, indent);
1570        str.println(" loop");
1571        getForStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1572        str.print(indent, "end for");
1573    }
1574
1575    public void InstForStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1576        str.print("for ");
1577        getInstForIndexList().prettyPrintWithSep(p, str, indent, ", ");
1578        str.println(" loop");
1579        getForStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1580        str.print(indent, "end for");
1581    }
1582
1583    public void FWhileStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1584        str.print("while ");
1585        p.print(getTest(), str, indent);
1586        str.println(" loop");
1587        getWhileStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1588        str.print(indent, "end while");
1589    }
1590
1591    public void FExternalStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1592        str.print("external ");
1593        p.print(getFExternalLanguage(), str, indent);
1594        str.print(" ");
1595        if (hasReturnVar()) {
1596            p.print(getReturnVar(), str, indent);
1597            str.print(" = ");
1598        }
1599        str.print(getName(), "(");
1600        getArgs().prettyPrintWithSep(p, str, indent, ", ");
1601        str.print(")");
1602    }
1603
1604    public void FInitArrayStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1605        str.print("init ");
1606        p.print(getFAccessExp(), str, indent);
1607        str.print(" as ");
1608        str.print(type());
1609    }
1610
1611    public void FExternalLanguage.prettyPrint(Printer p, CodeStream str, String indent) {
1612        str.print("\"", getLanguage(), "\"");
1613    }
1614
1615        public void InstExternal.prettyPrint(Printer p, CodeStream str, String indent) {
1616                str.print("external ");
1617                p.print(getFExternalLanguage(), str, indent);
1618                str.print(" ");
1619                p.print(getInstExternalCall(), str, indent);
1620        }
1621
1622    public void InstExternalCall.prettyPrint(Printer p, CodeStream str, String indent) {
1623        if (hasReturnVar()) {
1624            p.print(getReturnVar(), str, indent);
1625            str.print(" = ");
1626        }
1627        str.print(getName(), "(");
1628        getArgs().prettyPrintWithSep(p, str, indent, ", ");
1629        str.print(")");
1630    }
1631
1632        syn String FExternalLanguage.getLanguage() = null;
1633        eq FCExternalLanguage.getLanguage()         = LANGUAGE_STRING;
1634        eq FFortran77ExternalLanguage.getLanguage() = LANGUAGE_STRING;
1635        eq FBuiltinExternalLanguage.getLanguage()   = LANGUAGE_STRING;
1636       
1637       
1638        public final void FExp.prettyPrint(Printer p, CodeStream str, String indent) {
1639                boolean addParenthesis = addParenthesis(parentPrecedence());
1640                if (addParenthesis)
1641                        str.print('(');
1642                prettyPrintExp(p, str, indent);
1643                if (addParenthesis)
1644                        str.print(')');
1645        }
1646       
1647        protected abstract void FExp.prettyPrintExp(Printer p, CodeStream str, String indent);
1648       
1649        protected void FColonSizeExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1650                str.print(":");
1651        }
1652       
1653        protected void FNegExp.prettyPrintExp(Printer p,CodeStream str, String indent){
1654                str.print("- ");
1655                p.print(getFExp(),str,indent);
1656        }
1657       
1658        protected void FMatrix.prettyPrintExp(Printer p, CodeStream str, String indent) {
1659                str.print("[");
1660                getFExps().prettyPrintWithSep(p, str, indent, "; ");
1661                str.print("]");
1662        }
1663       
1664        protected void FMatrixRow.prettyPrintExp(Printer p, CodeStream str, String indent) {
1665                getFExps().prettyPrintWithSep(p, str, indent, ", ");
1666        }
1667       
1668        protected void FBinExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1669                p.print(getLeft(),str,indent);
1670                str.print(p.op(this));
1671                p.print(getRight(),str,indent);
1672        }
1673       
1674        syn String FBinExp.op();
1675        eq FLtExp.op()        = " < ";
1676        eq FLeqExp.op()       = " <= ";
1677        eq FGtExp .op()       = " > ";
1678        eq FGeqExp.op()       = " >= ";
1679        eq FEqExp.op()        = " == ";
1680        eq FNeqExp.op()       = " <> ";
1681        eq FOrExp.op()        = " or ";
1682        eq FAndExp.op()       = " and ";
1683        eq FAddExp.op()       = " + ";
1684        eq FSubExp.op()       = " - ";
1685        eq FMulExp.op()       = " * ";
1686        eq FDivExp.op()       = " / ";
1687        eq FPowExp.op()       = " ^ ";
1688        eq FDotAddExp.op()    = " .+ ";
1689        eq FDotSubExp.op()    = " .- ";
1690        eq FDotMulExp.op()    = " .* ";
1691        eq FDotDivExp.op()    = " ./ ";
1692        eq FDotPowExp.op()    = " .^ ";
1693        eq FStringAddExp.op() = " + ";
1694       
1695        protected void FNoExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1696                // Dummy node
1697        }
1698       
1699        protected void FUnsupportedExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1700        }
1701       
1702        protected void FNotExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1703                str.print("not ");
1704                p.print(getFExp(),str,indent);
1705        }
1706       
1707        protected void FIfExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1708                prettyPrintAsElseExp(p, str, indent);
1709        }
1710       
1711        public void FExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
1712                str.print(' ');
1713                p.print(this, str, indent);
1714        }
1715       
1716        public void FIfExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
1717                str.print("if ");
1718                p.print(getIfExp(), str, indent);
1719                str.print(" then ");
1720                p.print(getThenExp(), str, indent);
1721                str.print(" else");
1722                getElseExp().prettyPrintAsElseExp(p, str, indent);
1723        }
1724       
1725    protected void FLitExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1726        str.print(toString());
1727    }
1728
1729       
1730        protected void FTimeExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1731                str.print("time");
1732        }
1733
1734        protected void FEndExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1735                str.print("end");
1736        }
1737       
1738    protected void FInStreamEpsExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1739        str.print("_inStreamEpsilon");
1740    }
1741
1742        public abstract void CommonAccess.prettyPrint(Printer p, CodeStream str, String indent);
1743
1744        protected void CommonAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1745                p.print(getAccess(), str, indent);
1746        }
1747       
1748    protected void FGlobalAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1749        str.print("global(");
1750        super.prettyPrintExp(p, str, indent);
1751        str.print(")");
1752    }
1753       
1754        public void InstAccess.prettyPrint(Printer p, CodeStream str, String indent) {
1755                str.print(name());
1756                if (hasFArraySubscripts())
1757                        p.print(getFArraySubscripts(), str, indent);
1758        }
1759       
1760        public void InstDot.prettyPrint(Printer p, CodeStream str, String indent) {
1761                getInstAccesss().prettyPrintWithSep(p, str, indent, ".");
1762        }
1763       
1764        public void InstGlobalAccess.prettyPrint(Printer p, CodeStream str, String indent) {
1765                str.print(".");
1766                p.print(getInstAccess(), str, indent);
1767        }
1768       
1769        protected void FDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1770                str.print(name());
1771        }
1772
1773        protected void FDummyDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1774                str.print(derPrefixName());
1775        }
1776
1777        protected void FDynamicDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1778            str.print(dynDerName());
1779        }
1780       
1781        protected void FPreExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1782                str.print(name());
1783        }
1784       
1785        protected void InstDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1786                str.print("der(");
1787                p.print(getFExp(),str,indent);
1788                str.print(")");
1789        }
1790       
1791        protected void InstHDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1792                str.print("der(");
1793                p.print(getFExp(),str,indent);
1794                str.format(",%d)", getOrder());
1795        }
1796
1797        protected void InstPreExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1798                str.print("pre(");
1799                p.print(getFExp(),str,indent);
1800                str.format(")");
1801        }
1802       
1803    protected void FDSRefExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1804        str.format("ds(%d, ", getSetId());
1805        p.print(getOrg(), str, indent);
1806        str.print(")");
1807    }
1808
1809    protected void FDSDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1810        str.format("dsDer(%d, %d)", getSetId(), getNumber());
1811    }
1812
1813        protected void FSumExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1814                str.print("sum(");
1815                p.print(getFExp(), str, indent);
1816                str.print(")");
1817        }
1818       
1819        protected void FProductExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1820                str.print("product(");
1821                p.print(getFExp(), str, indent);
1822                str.print(")");
1823        }
1824
1825    protected void FFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1826        str.print(getName().name(), "(");
1827        getArgs().prettyPrintWithSep(p, str, "", ", ");
1828        str.print(")");
1829    }
1830
1831    protected void FPartialFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1832        str.print("function ");
1833        super.prettyPrintExp(p, str, indent);
1834    }
1835
1836    protected void InstFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1837        str.print(getName().name(), "(");
1838        getArgs().prettyPrintWithSep(p, str, "", ", ");
1839        str.print(")");
1840    }
1841
1842    protected void InstRecordConstructor.prettyPrintExp(Printer p, CodeStream str, String indent) {
1843        str.print(getRecord().name(), "(");
1844        getArgs().prettyPrintWithSep(p, str, "", ", ");
1845        str.print(")");
1846    }
1847
1848        public void InstDefaultArgument.prettyPrint(Printer p, CodeStream str, String indent) {
1849                p.print(getFExp(), str, indent);
1850        }
1851
1852    public void InstNamedArgument.prettyPrint(Printer p, CodeStream str, String indent) {
1853        str.print(getName().name(), "=");
1854        p.print(getFExp(), str, indent);
1855    }
1856
1857    protected void FBuiltInFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1858        str.print(builtInName(), "(");
1859        prettyPrintArguments(p, str, indent);
1860        str.print(")");
1861    }
1862
1863        protected static final String FBuiltInFunctionCall.SEP = ", ";
1864       
1865        /**
1866         * Pretty-print all arguments of function.
1867         *
1868         * Default implementation prints all direct FExp children (including those in Lists and Opts),
1869         * separated by {@link #SEP}.
1870         */
1871        protected void FBuiltInFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1872                String pre = "";
1873                for (FExp exp : myArgs()) {
1874                        str.print(pre);
1875                        p.print(exp, str, indent);
1876                        pre = SEP;
1877                }
1878        }
1879       
1880        protected void FInfArgsFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1881                getFExps().prettyPrintWithSep(p, str, indent, SEP);
1882        }
1883       
1884        protected void FFillExp.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1885                p.print(getFillExp(), str, indent);
1886                str.print(SEP);
1887                super.prettyPrintArguments(p, str, indent);
1888        }
1889       
1890        protected void FCatExp.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1891                p.print(getDim(), str, indent);
1892                str.print(SEP);
1893                super.prettyPrintArguments(p, str, indent);
1894        }
1895
1896    protected void FConnPotentialRoot.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1897        super.prettyPrintArguments(p, str, indent);
1898        if (hasPriority()) {
1899            str.print(SEP, "priority=");
1900            p.print(getPriority(), str, indent);
1901        }
1902    }
1903
1904    @Override
1905    protected void FDelayIndicator.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1906        myDelayExp().prettyPrintArguments(p, str, indent);
1907    }
1908
1909    @Override
1910    protected void FSpatialDistIndicator.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1911        mySpatialDistExp().prettyPrintArguments(p, str, indent);
1912    }
1913
1914        syn String FBuiltInFunctionCall.builtInName();
1915        eq FRecordConstructor.builtInName()  = getRecord().name();
1916        eq FUnsupportedBuiltIn.builtInName() = getName();
1917        eq FAbsExp.builtInName()             = "abs";
1918        eq FSignExp.builtInName()            = "sign";
1919        eq FSqrtExp.builtInName()            = "sqrt";
1920        eq FEnumIntegerExp.builtInName()     = "Integer";
1921        eq FStringExp.builtInName()          = "String";
1922        eq FDivFuncExp.builtInName()         = "div";
1923        eq FModFuncExp.builtInName()         = "mod";
1924        eq FRemFuncExp.builtInName()         = "rem";
1925        eq FCeilFuncExp.builtInName()        = "ceil";
1926        eq FFloorFuncExp.builtInName()       = "floor";
1927        eq FIntegerFuncExp.builtInName()     = "integer";
1928        eq FSinExp.builtInName()             = "sin";
1929        eq FCosExp.builtInName()             = "cos";
1930        eq FTanExp.builtInName()             = "tan";
1931        eq FAsinExp.builtInName()            = "asin";
1932        eq FAcosExp.builtInName()            = "acos";
1933        eq FAtanExp.builtInName()            = "atan";
1934        eq FAtan2Exp.builtInName()           = "atan2";
1935        eq FSinhExp.builtInName()            = "sinh";
1936        eq FCoshExp.builtInName()            = "cosh";
1937        eq FTanhExp.builtInName()            = "tanh";
1938        eq FExpExp.builtInName()             = "exp";
1939        eq FLogExp.builtInName()             = "log";
1940        eq FLog10Exp.builtInName()           = "log10";
1941        eq FScalarExp.builtInName()          = "scalar";
1942        eq FVectorExp.builtInName()          = "vector";
1943        eq FMatrixExp.builtInName()          = "matrix";
1944        eq FTranspose.builtInName()          = "transpose";
1945        eq FSymmetric.builtInName()          = "symmetric";
1946        eq FCross.builtInName()              = "cross";
1947        eq FSkew.builtInName()               = "skew";
1948        eq FOuterProduct.builtInName()       = "outerProduct";
1949        eq FNdimsExp.builtInName()           = "ndims";
1950        eq FSizeExp.builtInName()            = "size";
1951        eq FNoEventExp.builtInName()         = "noEvent";
1952        eq FSmoothExp.builtInName()          = "smooth";
1953        eq InstPreExp.builtInName()          = "pre";
1954        eq FEdgeExp.builtInName()            = "edge";
1955        eq FChangeExp.builtInName()          = "change";
1956    eq FLoadResource.builtInName()       = "loadResource";
1957        eq FSampleExp.builtInName()          = "sample";
1958        eq FInitialExp.builtInName()         = "initial";
1959        eq FTerminalExp.builtInName()        = "terminal";
1960        eq FTerminate.builtInName()          = "terminate";
1961    eq FReinit.builtInName()             = "reinit";
1962    eq FDelayExp.builtInName()           = "delay";
1963    eq FSpatialDistExp.builtInName()     = "spatialDistribution";
1964    eq FFirstDelayIndicator.builtInName()= "delayIndicatorFirst";
1965    eq FSecondDelayIndicator.builtInName()= "delayIndicatorSecond";
1966    eq FSpatialDistIndicator.builtInName()= "spatialDistIndicator";
1967        eq FAssert.builtInName()             = "assert";
1968        eq FIdentity.builtInName()           = "identity";
1969        eq FDiagonal.builtInName()           = "diagonal";
1970        eq FOnes.builtInName()               = "ones";
1971        eq FZeros.builtInName()              = "zeros";
1972        eq FFillExp.builtInName()            = "fill";
1973        eq FAbstractCat.builtInName()        = "cat";
1974        eq FParseArray.builtInName()         = "array";
1975        eq FMinExp.builtInName()             = "min";
1976        eq FMaxExp.builtInName()             = "max";
1977        eq FSumExp.builtInName()             = "sum";
1978        eq FProductExp.builtInName()         = "product";
1979        eq FLinspace.builtInName()           = "linspace";
1980        eq FHomotopyExp.builtInName()        = "homotopy";
1981    eq FCardinality.builtInName()        = "cardinality";
1982    eq FDecouple.builtInName()           = "Subtask.decouple";
1983        eq FSemiLinearExp.builtInName()      = "semiLinear";
1984        eq FInStream.builtInName()           = "inStream";
1985        eq FDerStream.builtInName()          = "derStream";
1986    eq FExInStream.builtInName()         = "inStreamExpansion";
1987        eq FActualStream.builtInName()       = "actualStream";
1988        eq FGetInstanceName.builtInName()    = "getInstanceName";
1989        eq FConnBranch.builtInName()         = "Connections.branch";
1990        eq FConnRoot.builtInName()           = "Connections.root";
1991        eq FConnPotentialRoot.builtInName()  = "Connections.potentialRoot";
1992        eq FConnIsRoot.builtInName()         = "Connections.isRoot";
1993        eq FConnRooted.builtInName()         = "Connections.rooted";
1994        eq FConnRootedDep.builtInName()      = "rooted";
1995
1996
1997    public void FForClauseE.prettyPrint(Printer p, CodeStream str, String indent) {
1998        str.print(indent, "for ");
1999        getFForIndexList().prettyPrintWithSep(p, str, indent, ", ");
2000        str.println(" loop");
2001        getFAbstractEquationList().prettyPrintWithFix(p, str, p.indent(indent), "", ";" + str.getLineEnder());
2002        str.print(indent, "end for");
2003    }
2004
2005    public void CommonForIndex.prettyPrint(Printer p, CodeStream str, String indent) {
2006        str.print(name(), " in ");
2007        p.print(getFExp(), str, indent);
2008    }
2009
2010    @Override
2011    public void InstForIndexNoExp.prettyPrint(Printer p, CodeStream str, String indent) {
2012        str.print(getInstPrimitive().name());
2013    }
2014
2015        protected void FArray.prettyPrintExp(Printer p, CodeStream str, String indent) {
2016                str.print("{");
2017                getFExps().prettyPrintWithSep(p, str, indent, ", ");
2018                str.print("}");
2019        }
2020       
2021        protected void FLongArray.prettyPrintExp(Printer p, CodeStream str, String indent) {
2022                str.print("array(");
2023                getFExps().prettyPrintWithSep(p, str, indent, ", ");
2024                str.print(")");
2025        }
2026       
2027        protected void FIterExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2028                p.print(getFExp(), str, indent);
2029                str.print(" for ");
2030                for (int i = getNumForIndex() - 1; i >= 0; i--) {
2031                        p.print(getForIndex(i), str, indent);
2032                        if (i > 0)
2033                                str.print(", ");
2034                }
2035        }
2036       
2037        protected void FSubscriptedExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2038                str.print("(");
2039                p.print(getFExp(), str, indent);
2040                str.print(")");
2041                p.print(getFArraySubscripts(), str, indent);
2042        }
2043       
2044    protected void FComponentExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2045        str.print("(");
2046        p.print(getFExp(), str, indent);
2047        str.print(").", getName());
2048    }
2049       
2050    protected void FDeferExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2051        p.print(getFExp(), str, indent);
2052    }
2053   
2054    public abstract String TypePrefixVariability.toString();
2055    public String Continuous.toString()            { return ""; }
2056    public String Discrete.toString()              { return "discrete "; }
2057    public String InitialParameter.toString()      { return "initial parameter "; }
2058    public String EvalFalseParameter.toString()    { return "parameter "; }
2059    public String FixedParameter.toString()        { return "parameter "; }
2060    public String IndexParameter.toString()        { return "index parameter"; }
2061    public String EvalTrueParameter.toString()     { return "eval parameter "; }
2062    public String FinalParameter.toString()        { return "final parameter "; }
2063    public String StructParameter.toString()       { return "structural parameter "; }
2064    public String LoadResourceParameter.toString() { return "structural (loadResource) parameter "; }
2065    public String Constant.toString()              { return "constant "; }
2066    public String CompositeVariability.toString()  { return combine().toString(); }
2067
2068    public abstract String TypePrefixVariability.toStringLiteral();
2069    public String Continuous.toStringLiteral()        { return "continuous-time"; }
2070    public String Discrete.toStringLiteral()          { return "discrete-time"; }
2071    public String InitialParameter.toStringLiteral()  { return "initial parameter"; }
2072    public String Parameter.toStringLiteral()         { return "parameter"; }
2073    public String EvalTrueParameter.toStringLiteral() { return "eval parameter"; }
2074    public String FinalParameter.toStringLiteral()    { return "final parameter"; }
2075    public String StructParameter.toStringLiteral()   { return "structural parameter"; }
2076    public String Constant.toStringLiteral()          { return "constant"; }
2077    public String CompositeVariability.toStringLiteral() { return combine().toStringLiteral(); }
2078
2079    syn String SrcRestriction.toString();
2080    eq SrcModel.toString()               = "model";
2081    eq SrcBlock.toString()               = "block";
2082    eq SrcClass.toString()              = "class";
2083    eq SrcConnector.toString()           = "connector";
2084    eq SrcExpandableConnector.toString() = "expandable connector";
2085    eq SrcType.toString()               = "type";
2086    eq SrcPackage.toString()            = "package";
2087    eq SrcFunction.toString()            = "function";
2088    eq SrcRecord.toString()              = "record";
2089    eq SrcOperator.toString()            = "operator";
2090    eq SrcOperatorRecord.toString()      = "operator record";
2091    eq SrcOperatorFunction.toString()    = "operator function";
2092
2093    syn String InstRestriction.toString();
2094    eq InstModel.toString()               = "model";
2095    eq InstBlock.toString()               = "block";
2096    eq InstMClass.toString()              = "class";
2097    eq InstConnector.toString()           = "connector";
2098    eq InstExpandableConnector.toString() = "expandable connector";
2099    eq InstMType.toString()               = "type";
2100    eq InstMPackage.toString()            = "package";
2101    eq InstFunction.toString()            = "function";
2102    eq InstMRecord.toString()             = "record";
2103    eq InstOperator.toString()            = "operator";
2104    eq InstOperatorRecord.toString()      = "operator record";
2105    eq InstOperatorFunction.toString()    = "operator function";
2106
2107    syn String SrcComponentDecl.toString() = prettyPrint("");
2108    syn String SrcAccess.toString()        = prettyPrint("");
2109    syn String SrcModification.toString()  = prettyPrint("");
2110}
2111
2112aspect PrettyPrint_MC {
2113
2114    /**
2115     * Static printer instance.
2116     */
2117    static MCPrettyPrinter ASTNode.printer_MC = new MCPrettyPrinter();
2118
2119    public class MCPrettyPrinter extends Printer {
2120
2121        public MCPrettyPrinter() {
2122            super("    ");
2123        }
2124
2125        public void print(ASTNode node, CodeStream str, String indent) {
2126            node.prettyPrint(this, str, indent); 
2127        }
2128
2129    }
2130
2131        public String ASTNode.prettyPrint_MC(String indent) {
2132                ByteArrayOutputStream os = new ByteArrayOutputStream();
2133                CodeStream str = new CodeStream(os);
2134                prettyPrint(str,indent);
2135                return os.toString();
2136        }
2137
2138    public static void List.prettyPrintFAttributeList_MC(Printer p, CodeStream str, String indent, List<FAttribute> l) {
2139        boolean firstAttr = true;
2140        for (FAttribute attr : l) {
2141            if (attr.getAttributeSet() && !attr.isAnnotation()) {
2142                if (firstAttr) {
2143                    str.print("(");
2144                } else {
2145                    str.print(", ");
2146                }
2147                p.print(attr, str, indent);
2148                firstAttr = false;
2149            }
2150        }
2151        if (!firstAttr) {
2152            str.print(")");
2153        }
2154    }
2155
2156    public void FVariable.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2157        str.print(indent, getTypePrefixVariability());
2158        if (!getCausalityConnectorPrefix().isNone()) {
2159            str.print(getCausalityConnectorPrefix(), " ");
2160        }
2161       
2162        str.print(prettyPrintType(), " ", nameUnderscore());
2163        List.prettyPrintFAttributeList_MC(p, str, indent, getFAttributeList());
2164       
2165        FExp bindingExp = null;
2166        if (hasBindingExp()) {
2167            bindingExp = getBindingExp();
2168        } else if (hasParameterEquation()) {
2169            bindingExp = ((FEquation) parameterEquation()).getRight();
2170        }
2171        if (bindingExp != null) {
2172            str.print(" = ");
2173            p.print(bindingExp,str,indent);
2174        }
2175       
2176        p.print(getFStringCommentOpt(), str, indent);
2177
2178        if (isIndependentParameter() && hasBindingExp()) {
2179            str.print(" /* ");
2180            try {
2181                str.print(getBindingExp().ceval());
2182            } catch (ConstantEvaluationException e){
2183                str.print("evaluation error");
2184            }
2185            str.print(" */");
2186        }
2187    }
2188
2189
2190    public void FClass.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2191        String nextInd = p.indent(indent);
2192   
2193        p.print(getFFunctionDecls(), str, indent);
2194        p.print(getFRecordDecls(), str, indent);
2195        p.print(getFEnumDecls(), str, indent);
2196        p.print(getFDerivedTypes(), str, indent);
2197   
2198        str.println(indent, "model ", nameUnderscore());
2199        for (FVariable fv : getFVariables()) {
2200            if (!fv.isDerivativeVariable() && !fv.isPreVariable()) {
2201                p.print(fv, str, nextInd);
2202                str.println(";");
2203            }
2204        }
2205
2206        if (getNumFInitialEquation() > 0) {
2207            str.println(indent, "initial equation");
2208        }
2209        getFInitialEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
2210
2211    /*
2212        if (getNumParameterEquation() > 0) {
2213            str.println(indent, "parameter equation");
2214        }
2215        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
2216    */
2217        prettyPrintEquations(p, str, indent);
2218               
2219        str.println(indent, "end ", nameUnderscore(), ";");
2220    }
2221
2222
2223        public void ASTNode.prettyPrint_MC(CodeStream str, String indent) {
2224                prettyPrint_MC(printer_MC, str, indent);
2225        }
2226
2227        public void ASTNode.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2228                prettyPrint(p, str, indent);
2229        }
2230       
2231        public void FAccessExp.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2232                str.print(nameUnderscore());
2233        }
2234
2235    public void FDerExp.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2236        str.print("der(", getFAccess().nameUnderscore(), ")");
2237    }
2238
2239}
2240
2241aspect AnnotationPrettyPrinting {
2242    /**
2243     * Used when prettyprinting FAttribute annotation nodes
2244     */
2245    public class AnnotationPrettyPrinter extends PrettyPrinter {
2246
2247        @Override
2248        public PrettyPrinter annotationPrinter() {
2249            return this;
2250        }
2251
2252        @Override
2253        public boolean inAnnotation() {
2254            return true;
2255        }
2256    }
2257   
2258    public static PrettyPrinter ASTNode.AnnotationPrettyPrinter = new AnnotationPrettyPrinter();
2259
2260    /**
2261     * Returns a string listing the annotations in this class declaration and any child class declarations, recursively.
2262     *
2263     * @param prefix
2264     *          The string to prefix the annotation string with.
2265     */
2266    syn String InstClassDecl.printClassAnnotations(String prefix) = "";
2267
2268    eq InstFullClassDecl.printClassAnnotations(String prefix) {
2269        SrcFullClassDecl myDecl = getSrcFullClassDecl();
2270        Opt<SrcAnnotation> myAnnotation = myDecl.getSrcAnnotationOpt();
2271        String myNode = (myAnnotation.numChildren() > 0 ? prefix + myAnnotation.getChild(0).toString() + "\n" : "");
2272        StringBuilder string = new StringBuilder(myNode.contains("__JModelica") ? "" : myNode);
2273        for (InstClassDecl decl : getInstClassDecls()) {
2274            string.append(decl.printClassAnnotations(prefix + "    "));
2275        }
2276        return string.toString();
2277    }
2278    eq InstAbstractShortClassDecl.printClassAnnotations(String prefix) = getSrcShortClassDecl().srcAnnotation().toString();
2279
2280    /**
2281     * Returns a string listing the annotations for components in this class.
2282     *
2283     * @param prefix
2284     *          The string to prefix the annotation string with.
2285     */
2286    syn String InstClassDecl.printComponentAnnotations() = "";
2287   
2288    eq InstFullClassDecl.printComponentAnnotations() {
2289        StringBuilder sb = new StringBuilder();
2290        for (InstComponentDecl decl : getInstComponentDecls()) {
2291            if (sb.length() > 0) {
2292                sb.append('\n');
2293            }
2294            sb.append(decl.srcAnnotation().toString());
2295        }
2296        return sb.toString();
2297    }
2298}
Note: See TracBrowser for help on using the repository browser.