source: trunk/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag @ 13586

Last change on this file since 13586 was 13586, checked in by molsson, 3 months ago

Merged revision(s) 13547-13576 from branches/dev-mo-2275:
#5843 Fixed a bug in TestAnnotationizer.jrag when regeneration method test cases without arguments.
........
#5843 Removed unused function FClass.nextTempFuncName().
........
#5843 Added inherited attribute myFClass() to FDerivedType.
........
#5843 Refactored prettyPrint for FDerivedType.
........

File size: 76.4 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                if (numSubscript()>0) {
1409                        str.print("[");
1410                        for (int i=0;i<numSubscript();i++) {
1411                                subscript(i).prettyPrint(p, str, indent);
1412                                if (i<numSubscript()-1)
1413                                        str.print(",");
1414                        }
1415                        str.print("]");
1416                }
1417        }
1418
1419        public void FColonSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1420                str.print(":");
1421        }
1422
1423        public void FIntegerSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1424                str.print(getValue());
1425        }
1426       
1427        public void FExpSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1428                p.print(getFExp(),str,indent);
1429        }
1430
1431    public void IntegerSubscript.prettyPrint(Printer p, CodeStream str, String indent) {
1432        str.print(value);
1433    }
1434
1435    public String IntegerSubscript.prettyPrint(String indent) {
1436        return String.valueOf(value);
1437    }
1438
1439        protected void FRangeExp.prettyPrintExp(Printer p, CodeStream str, String indent) { 
1440                for (int i=0;i<getNumFExp();i++) {
1441                        p.print(getFExp(i),str,indent);
1442                        if (i<getNumFExp()-1)
1443                                str.print(":");
1444                }
1445        }
1446
1447
1448        public void FEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1449                str.print(indent);
1450        p.print(getLeft(),str,indent);
1451                str.print(" = ");
1452                p.print(getRight(),str,indent);
1453        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p);
1454        }
1455
1456
1457        public void FIfWhenElseEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1458                str.print(indent);
1459                if (isElse())
1460                        str.print("else");
1461                prettyPrintHead(p, str, indent);
1462                getFAbstractEquations().prettyPrintWithFix(p, str, p.indent(indent), "", ";" + str.getLineEnder());
1463                prettyPrintTail(p, str, indent);
1464        }
1465
1466        protected void FIfWhenElseEquation.prettyPrintHead(Printer p, CodeStream str, String indent) {
1467                str.println();
1468        }
1469
1470        protected void FIfWhenElseEquation.prettyPrintTail(Printer p, CodeStream str, String indent) {
1471        }
1472
1473    protected void FIfWhenEquation.prettyPrintHead(Printer p, CodeStream str, String indent) {
1474        str.print(ifWhenType(), " ");
1475        p.print(getTest(), str, indent);
1476        str.println(" then");
1477    }
1478
1479    protected void FIfWhenEquation.prettyPrintTail(Printer p, CodeStream str, String indent) {
1480        if (hasElse()) 
1481            p.print(getElse(), str, indent);
1482        if (!isElse()) {
1483            str.print(indent, "end ", ifWhenType());
1484        }
1485    }
1486
1487        syn String FIfWhenEquation.ifWhenType();
1488        eq FIfEquation.ifWhenType()   = "if";
1489        eq FWhenEquation.ifWhenType() = "when";
1490       
1491
1492    public void FConnectClause.prettyPrint(Printer p, CodeStream str, String indent) {
1493        str.print(indent, "connect(");
1494        p.print(getConnector1(), str, indent);
1495        str.print(", ");
1496        p.print(getConnector2(), str, indent);
1497        str.print(")");
1498    }
1499
1500        public void FFunctionCallEquation.prettyPrint(Printer p, CodeStream str, String indent) {
1501                str.print(indent);
1502                if (getNumLeft() > 0) {
1503                        str.print("(");
1504                        getLefts().prettyPrintWithSep(p, str, indent, ", ");
1505                        str.print(") = ");
1506                }
1507                p.print(getCall(), str, indent);
1508        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p);
1509        }
1510       
1511        public void FAlgorithm.prettyPrint(Printer p, CodeStream str, String indent) {
1512                str.print(indent);
1513                str.println("algorithm");
1514                getFStatements().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1515        }
1516       
1517        public void FAssignStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1518                p.print(getLeft(), str, indent);
1519                str.print(" := ");
1520                p.print(getRight(), str, indent);
1521        }
1522       
1523        public void FFunctionCallStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1524                if (getNumLeft() > 0) {
1525                        str.print("(");
1526                        getLefts().prettyPrintWithSep(p, str, indent, ", ");
1527                        str.print(") := ");
1528                }
1529                p.print(getCall(), str, indent);
1530        }
1531       
1532        public void FBreakStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1533                str.print("break");
1534        }
1535       
1536        public void FReturnStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1537                str.print("return");
1538        }
1539
1540    public void FIfWhenStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1541        getFIfWhenClauses().prettyPrintWithSep(p, str, indent, indent + "else");
1542        prettyPrintElse(p, str, indent);
1543        str.print(indent, "end ", getKeyword());
1544    }
1545
1546    protected void FIfWhenStmt.prettyPrintElse(Printer p, CodeStream str, String indent) {}
1547
1548    protected void FIfStmt.prettyPrintElse(Printer p, CodeStream str, String indent) {
1549        if (getNumElseStmt() > 0) {
1550            str.println(indent, "else");
1551            getElseStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1552        }
1553    }
1554
1555    public void FIfWhenClause.prettyPrint(Printer p, CodeStream str, String indent) {
1556        str.print(getKeyword(), " ");
1557        p.print(getTest(), str, indent);
1558        str.println(" then");
1559        getFStatements().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1560    }
1561
1562        syn String FIfWhenStmt.getKeyword() = null;
1563        eq FIfStmt.getKeyword() = "if";
1564        eq FWhenStmt.getKeyword() = "when";
1565        inh String FIfWhenClause.getKeyword();
1566        eq FIfWhenStmt.getFIfWhenClause(int i).getKeyword() = getKeyword();
1567
1568    public void FForStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1569        str.print("for ");
1570        p.print(getIndex(), str, indent);
1571        str.println(" loop");
1572        getForStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1573        str.print(indent, "end for");
1574    }
1575
1576    public void InstForStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1577        str.print("for ");
1578        getInstForIndexList().prettyPrintWithSep(p, str, indent, ", ");
1579        str.println(" loop");
1580        getForStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1581        str.print(indent, "end for");
1582    }
1583
1584    public void FWhileStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1585        str.print("while ");
1586        p.print(getTest(), str, indent);
1587        str.println(" loop");
1588        getWhileStmts().prettyPrintWithIndent(p, str, p.indent(indent), ";");
1589        str.print(indent, "end while");
1590    }
1591
1592    public void FExternalStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1593        str.print("external ");
1594        p.print(getFExternalLanguage(), str, indent);
1595        str.print(" ");
1596        if (hasReturnVar()) {
1597            p.print(getReturnVar(), str, indent);
1598            str.print(" = ");
1599        }
1600        str.print(getName(), "(");
1601        getArgs().prettyPrintWithSep(p, str, indent, ", ");
1602        str.print(")");
1603    }
1604
1605    public void FInitArrayStmt.prettyPrint(Printer p, CodeStream str, String indent) {
1606        str.print("init ");
1607        p.print(getFAccessExp(), str, indent);
1608        str.print(" as ");
1609        str.print(type());
1610    }
1611
1612    public void FExternalLanguage.prettyPrint(Printer p, CodeStream str, String indent) {
1613        str.print("\"", getLanguage(), "\"");
1614    }
1615
1616        public void InstExternal.prettyPrint(Printer p, CodeStream str, String indent) {
1617                str.print("external ");
1618                p.print(getFExternalLanguage(), str, indent);
1619                str.print(" ");
1620                p.print(getInstExternalCall(), str, indent);
1621        }
1622
1623    public void InstExternalCall.prettyPrint(Printer p, CodeStream str, String indent) {
1624        if (hasReturnVar()) {
1625            p.print(getReturnVar(), str, indent);
1626            str.print(" = ");
1627        }
1628        str.print(getName(), "(");
1629        getArgs().prettyPrintWithSep(p, str, indent, ", ");
1630        str.print(")");
1631    }
1632
1633        syn String FExternalLanguage.getLanguage() = null;
1634        eq FCExternalLanguage.getLanguage()         = LANGUAGE_STRING;
1635        eq FFortran77ExternalLanguage.getLanguage() = LANGUAGE_STRING;
1636        eq FBuiltinExternalLanguage.getLanguage()   = LANGUAGE_STRING;
1637       
1638       
1639        public final void FExp.prettyPrint(Printer p, CodeStream str, String indent) {
1640                boolean addParenthesis = addParenthesis(parentPrecedence());
1641                if (addParenthesis)
1642                        str.print('(');
1643                prettyPrintExp(p, str, indent);
1644                if (addParenthesis)
1645                        str.print(')');
1646        }
1647       
1648        protected abstract void FExp.prettyPrintExp(Printer p, CodeStream str, String indent);
1649       
1650        protected void FColonSizeExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1651                str.print(":");
1652        }
1653       
1654        protected void FNegExp.prettyPrintExp(Printer p,CodeStream str, String indent){
1655                str.print("- ");
1656                p.print(getFExp(),str,indent);
1657        }
1658       
1659        protected void FMatrix.prettyPrintExp(Printer p, CodeStream str, String indent) {
1660                str.print("[");
1661                getFExps().prettyPrintWithSep(p, str, indent, "; ");
1662                str.print("]");
1663        }
1664       
1665        protected void FMatrixRow.prettyPrintExp(Printer p, CodeStream str, String indent) {
1666                getFExps().prettyPrintWithSep(p, str, indent, ", ");
1667        }
1668       
1669        protected void FBinExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1670                p.print(getLeft(),str,indent);
1671                str.print(p.op(this));
1672                p.print(getRight(),str,indent);
1673        }
1674       
1675        syn String FBinExp.op();
1676        eq FLtExp.op()        = " < ";
1677        eq FLeqExp.op()       = " <= ";
1678        eq FGtExp .op()       = " > ";
1679        eq FGeqExp.op()       = " >= ";
1680        eq FEqExp.op()        = " == ";
1681        eq FNeqExp.op()       = " <> ";
1682        eq FOrExp.op()        = " or ";
1683        eq FAndExp.op()       = " and ";
1684        eq FAddExp.op()       = " + ";
1685        eq FSubExp.op()       = " - ";
1686        eq FMulExp.op()       = " * ";
1687        eq FDivExp.op()       = " / ";
1688        eq FPowExp.op()       = " ^ ";
1689        eq FDotAddExp.op()    = " .+ ";
1690        eq FDotSubExp.op()    = " .- ";
1691        eq FDotMulExp.op()    = " .* ";
1692        eq FDotDivExp.op()    = " ./ ";
1693        eq FDotPowExp.op()    = " .^ ";
1694        eq FStringAddExp.op() = " + ";
1695       
1696        protected void FNoExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1697                // Dummy node
1698        }
1699       
1700        protected void FUnsupportedExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1701        }
1702       
1703        protected void FNotExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1704                str.print("not ");
1705                p.print(getFExp(),str,indent);
1706        }
1707       
1708        protected void FIfExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1709                prettyPrintAsElseExp(p, str, indent);
1710        }
1711       
1712        public void FExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
1713                str.print(' ');
1714                p.print(this, str, indent);
1715        }
1716       
1717        public void FIfExp.prettyPrintAsElseExp(Printer p, CodeStream str, String indent) {
1718                str.print("if ");
1719                p.print(getIfExp(), str, indent);
1720                str.print(" then ");
1721                p.print(getThenExp(), str, indent);
1722                str.print(" else");
1723                getElseExp().prettyPrintAsElseExp(p, str, indent);
1724        }
1725       
1726    protected void FLitExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1727        str.print(toString());
1728    }
1729
1730       
1731        protected void FTimeExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1732                str.print("time");
1733        }
1734
1735        protected void FEndExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1736                str.print("end");
1737        }
1738       
1739    protected void FInStreamEpsExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1740        str.print("_inStreamEpsilon");
1741    }
1742
1743        public abstract void CommonAccess.prettyPrint(Printer p, CodeStream str, String indent);
1744
1745        protected void CommonAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1746                p.print(getAccess(), str, indent);
1747        }
1748       
1749    protected void FGlobalAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1750        str.print("global(");
1751        super.prettyPrintExp(p, str, indent);
1752        str.print(")");
1753    }
1754       
1755        public void InstAccess.prettyPrint(Printer p, CodeStream str, String indent) {
1756                str.print(name());
1757                if (hasFArraySubscripts())
1758                        p.print(getFArraySubscripts(), str, indent);
1759        }
1760       
1761        public void InstDot.prettyPrint(Printer p, CodeStream str, String indent) {
1762                getInstAccesss().prettyPrintWithSep(p, str, indent, ".");
1763        }
1764       
1765        public void InstGlobalAccess.prettyPrint(Printer p, CodeStream str, String indent) {
1766                str.print(".");
1767                p.print(getInstAccess(), str, indent);
1768        }
1769       
1770        protected void FDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1771                str.print(name());
1772        }
1773
1774        protected void FDummyDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1775                str.print(derPrefixName());
1776        }
1777
1778        protected void FDynamicDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1779            str.print(dynDerName());
1780        }
1781       
1782        protected void FPreExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1783                str.print(name());
1784        }
1785       
1786        protected void InstDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1787                str.print("der(");
1788                p.print(getFExp(),str,indent);
1789                str.print(")");
1790        }
1791       
1792        protected void InstHDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1793                str.print("der(");
1794                p.print(getFExp(),str,indent);
1795                str.format(",%d)", getOrder());
1796        }
1797
1798        protected void InstPreExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1799                str.print("pre(");
1800                p.print(getFExp(),str,indent);
1801                str.format(")");
1802        }
1803       
1804    protected void FDSRefExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1805        str.format("ds(%d, ", getSetId());
1806        p.print(getOrg(), str, indent);
1807        str.print(")");
1808    }
1809
1810    protected void FDSDerExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1811        str.format("dsDer(%d, %d)", getSetId(), getNumber());
1812    }
1813
1814        protected void FSumExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1815                str.print("sum(");
1816                p.print(getFExp(), str, indent);
1817                str.print(")");
1818        }
1819       
1820        protected void FProductExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
1821                str.print("product(");
1822                p.print(getFExp(), str, indent);
1823                str.print(")");
1824        }
1825
1826    protected void FFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1827        str.print(getName().name(), "(");
1828        getArgs().prettyPrintWithSep(p, str, "", ", ");
1829        str.print(")");
1830    }
1831
1832    protected void FPartialFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1833        str.print("function ");
1834        super.prettyPrintExp(p, str, indent);
1835    }
1836
1837    protected void InstFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1838        str.print(getName().name(), "(");
1839        getArgs().prettyPrintWithSep(p, str, "", ", ");
1840        str.print(")");
1841    }
1842
1843    protected void InstRecordConstructor.prettyPrintExp(Printer p, CodeStream str, String indent) {
1844        str.print(getRecord().name(), "(");
1845        getArgs().prettyPrintWithSep(p, str, "", ", ");
1846        str.print(")");
1847    }
1848
1849        public void InstDefaultArgument.prettyPrint(Printer p, CodeStream str, String indent) {
1850                p.print(getFExp(), str, indent);
1851        }
1852
1853    public void InstNamedArgument.prettyPrint(Printer p, CodeStream str, String indent) {
1854        str.print(getName().name(), "=");
1855        p.print(getFExp(), str, indent);
1856    }
1857
1858    protected void FBuiltInFunctionCall.prettyPrintExp(Printer p, CodeStream str, String indent) {
1859        str.print(builtInName(), "(");
1860        prettyPrintArguments(p, str, indent);
1861        str.print(")");
1862    }
1863
1864        protected static final String FBuiltInFunctionCall.SEP = ", ";
1865       
1866        /**
1867         * Pretty-print all arguments of function.
1868         *
1869         * Default implementation prints all direct FExp children (including those in Lists and Opts),
1870         * separated by {@link #SEP}.
1871         */
1872        protected void FBuiltInFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1873                String pre = "";
1874                for (FExp exp : myArgs()) {
1875                        str.print(pre);
1876                        p.print(exp, str, indent);
1877                        pre = SEP;
1878                }
1879        }
1880       
1881        protected void FInfArgsFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1882                getFExps().prettyPrintWithSep(p, str, indent, SEP);
1883        }
1884       
1885        protected void FFillExp.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1886                p.print(getFillExp(), str, indent);
1887                str.print(SEP);
1888                super.prettyPrintArguments(p, str, indent);
1889        }
1890       
1891        protected void FCatExp.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1892                p.print(getDim(), str, indent);
1893                str.print(SEP);
1894                super.prettyPrintArguments(p, str, indent);
1895        }
1896
1897    protected void FConnPotentialRoot.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1898        super.prettyPrintArguments(p, str, indent);
1899        if (hasPriority()) {
1900            str.print(SEP, "priority=");
1901            p.print(getPriority(), str, indent);
1902        }
1903    }
1904
1905    @Override
1906    protected void FDelayIndicator.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1907        myDelayExp().prettyPrintArguments(p, str, indent);
1908    }
1909
1910    @Override
1911    protected void FSpatialDistIndicator.prettyPrintArguments(Printer p, CodeStream str, String indent) {
1912        mySpatialDistExp().prettyPrintArguments(p, str, indent);
1913    }
1914
1915        syn String FBuiltInFunctionCall.builtInName();
1916        eq FRecordConstructor.builtInName()  = getRecord().name();
1917        eq FUnsupportedBuiltIn.builtInName() = getName();
1918        eq FAbsExp.builtInName()             = "abs";
1919        eq FSignExp.builtInName()            = "sign";
1920        eq FSqrtExp.builtInName()            = "sqrt";
1921        eq FEnumIntegerExp.builtInName()     = "Integer";
1922        eq FStringExp.builtInName()          = "String";
1923        eq FDivFuncExp.builtInName()         = "div";
1924        eq FModFuncExp.builtInName()         = "mod";
1925        eq FRemFuncExp.builtInName()         = "rem";
1926        eq FCeilFuncExp.builtInName()        = "ceil";
1927        eq FFloorFuncExp.builtInName()       = "floor";
1928        eq FIntegerFuncExp.builtInName()     = "integer";
1929        eq FSinExp.builtInName()             = "sin";
1930        eq FCosExp.builtInName()             = "cos";
1931        eq FTanExp.builtInName()             = "tan";
1932        eq FAsinExp.builtInName()            = "asin";
1933        eq FAcosExp.builtInName()            = "acos";
1934        eq FAtanExp.builtInName()            = "atan";
1935        eq FAtan2Exp.builtInName()           = "atan2";
1936        eq FSinhExp.builtInName()            = "sinh";
1937        eq FCoshExp.builtInName()            = "cosh";
1938        eq FTanhExp.builtInName()            = "tanh";
1939        eq FExpExp.builtInName()             = "exp";
1940        eq FLogExp.builtInName()             = "log";
1941        eq FLog10Exp.builtInName()           = "log10";
1942        eq FScalarExp.builtInName()          = "scalar";
1943        eq FVectorExp.builtInName()          = "vector";
1944        eq FMatrixExp.builtInName()          = "matrix";
1945        eq FTranspose.builtInName()          = "transpose";
1946        eq FSymmetric.builtInName()          = "symmetric";
1947        eq FCross.builtInName()              = "cross";
1948        eq FSkew.builtInName()               = "skew";
1949        eq FOuterProduct.builtInName()       = "outerProduct";
1950        eq FNdimsExp.builtInName()           = "ndims";
1951        eq FSizeExp.builtInName()            = "size";
1952        eq FNoEventExp.builtInName()         = "noEvent";
1953        eq FSmoothExp.builtInName()          = "smooth";
1954        eq InstPreExp.builtInName()          = "pre";
1955        eq FEdgeExp.builtInName()            = "edge";
1956        eq FChangeExp.builtInName()          = "change";
1957    eq FLoadResource.builtInName()       = "loadResource";
1958        eq FSampleExp.builtInName()          = "sample";
1959        eq FInitialExp.builtInName()         = "initial";
1960        eq FTerminalExp.builtInName()        = "terminal";
1961        eq FTerminate.builtInName()          = "terminate";
1962    eq FReinit.builtInName()             = "reinit";
1963    eq FDelayExp.builtInName()           = "delay";
1964    eq FSpatialDistExp.builtInName()     = "spatialDistribution";
1965    eq FFirstDelayIndicator.builtInName()= "delayIndicatorFirst";
1966    eq FSecondDelayIndicator.builtInName()= "delayIndicatorSecond";
1967    eq FSpatialDistIndicator.builtInName()= "spatialDistIndicator";
1968        eq FAssert.builtInName()             = "assert";
1969        eq FIdentity.builtInName()           = "identity";
1970        eq FDiagonal.builtInName()           = "diagonal";
1971        eq FOnes.builtInName()               = "ones";
1972        eq FZeros.builtInName()              = "zeros";
1973        eq FFillExp.builtInName()            = "fill";
1974        eq FAbstractCat.builtInName()        = "cat";
1975        eq FParseArray.builtInName()         = "array";
1976        eq FMinExp.builtInName()             = "min";
1977        eq FMaxExp.builtInName()             = "max";
1978        eq FSumExp.builtInName()             = "sum";
1979        eq FProductExp.builtInName()         = "product";
1980        eq FLinspace.builtInName()           = "linspace";
1981        eq FHomotopyExp.builtInName()        = "homotopy";
1982    eq FCardinality.builtInName()        = "cardinality";
1983    eq FDecouple.builtInName()           = "Subtask.decouple";
1984        eq FSemiLinearExp.builtInName()      = "semiLinear";
1985        eq FInStream.builtInName()           = "inStream";
1986        eq FDerStream.builtInName()          = "derStream";
1987    eq FExInStream.builtInName()         = "inStreamExpansion";
1988        eq FActualStream.builtInName()       = "actualStream";
1989        eq FGetInstanceName.builtInName()    = "getInstanceName";
1990        eq FConnBranch.builtInName()         = "Connections.branch";
1991        eq FConnRoot.builtInName()           = "Connections.root";
1992        eq FConnPotentialRoot.builtInName()  = "Connections.potentialRoot";
1993        eq FConnIsRoot.builtInName()         = "Connections.isRoot";
1994        eq FConnRooted.builtInName()         = "Connections.rooted";
1995        eq FConnRootedDep.builtInName()      = "rooted";
1996
1997
1998    public void FForClauseE.prettyPrint(Printer p, CodeStream str, String indent) {
1999        str.print(indent, "for ");
2000        getFForIndexList().prettyPrintWithSep(p, str, indent, ", ");
2001        str.println(" loop");
2002        getFAbstractEquationList().prettyPrintWithFix(p, str, p.indent(indent), "", ";" + str.getLineEnder());
2003        str.print(indent, "end for");
2004    }
2005
2006    public void CommonForIndex.prettyPrint(Printer p, CodeStream str, String indent) {
2007        str.print(name(), " in ");
2008        p.print(getFExp(), str, indent);
2009    }
2010
2011    @Override
2012    public void InstForIndexNoExp.prettyPrint(Printer p, CodeStream str, String indent) {
2013        str.print(getInstPrimitive().name());
2014    }
2015
2016        protected void FArray.prettyPrintExp(Printer p, CodeStream str, String indent) {
2017                str.print("{");
2018                getFExps().prettyPrintWithSep(p, str, indent, ", ");
2019                str.print("}");
2020        }
2021       
2022        protected void FLongArray.prettyPrintExp(Printer p, CodeStream str, String indent) {
2023                str.print("array(");
2024                getFExps().prettyPrintWithSep(p, str, indent, ", ");
2025                str.print(")");
2026        }
2027       
2028        protected void FIterExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2029                p.print(getFExp(), str, indent);
2030                str.print(" for ");
2031                for (int i = getNumForIndex() - 1; i >= 0; i--) {
2032                        p.print(getForIndex(i), str, indent);
2033                        if (i > 0)
2034                                str.print(", ");
2035                }
2036        }
2037       
2038        protected void FSubscriptedExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2039                str.print("(");
2040                p.print(getFExp(), str, indent);
2041                str.print(")");
2042                p.print(getFArraySubscripts(), str, indent);
2043        }
2044       
2045    protected void FComponentExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2046        str.print("(");
2047        p.print(getFExp(), str, indent);
2048        str.print(").", getName());
2049    }
2050       
2051    protected void FDeferExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
2052        p.print(getFExp(), str, indent);
2053    }
2054   
2055    public abstract String TypePrefixVariability.toString();
2056    public String Continuous.toString()            { return ""; }
2057    public String Discrete.toString()              { return "discrete "; }
2058    public String InitialParameter.toString()      { return "initial parameter "; }
2059    public String EvalFalseParameter.toString()    { return "parameter "; }
2060    public String FixedParameter.toString()        { return "parameter "; }
2061    public String IndexParameter.toString()        { return "index parameter"; }
2062    public String EvalTrueParameter.toString()     { return "eval parameter "; }
2063    public String FinalParameter.toString()        { return "final parameter "; }
2064    public String StructParameter.toString()       { return "structural parameter "; }
2065    public String LoadResourceParameter.toString() { return "structural (loadResource) parameter "; }
2066    public String Constant.toString()              { return "constant "; }
2067    public String CompositeVariability.toString()  { return combine().toString(); }
2068
2069    public abstract String TypePrefixVariability.toStringLiteral();
2070    public String Continuous.toStringLiteral()        { return "continuous-time"; }
2071    public String Discrete.toStringLiteral()          { return "discrete-time"; }
2072    public String InitialParameter.toStringLiteral()  { return "initial parameter"; }
2073    public String Parameter.toStringLiteral()         { return "parameter"; }
2074    public String EvalTrueParameter.toStringLiteral() { return "eval parameter"; }
2075    public String FinalParameter.toStringLiteral()    { return "final parameter"; }
2076    public String StructParameter.toStringLiteral()   { return "structural parameter"; }
2077    public String Constant.toStringLiteral()          { return "constant"; }
2078    public String CompositeVariability.toStringLiteral() { return combine().toStringLiteral(); }
2079
2080    syn String SrcRestriction.toString();
2081    eq SrcModel.toString()               = "model";
2082    eq SrcBlock.toString()               = "block";
2083    eq SrcClass.toString()              = "class";
2084    eq SrcConnector.toString()           = "connector";
2085    eq SrcExpandableConnector.toString() = "expandable connector";
2086    eq SrcType.toString()               = "type";
2087    eq SrcPackage.toString()            = "package";
2088    eq SrcFunction.toString()            = "function";
2089    eq SrcRecord.toString()              = "record";
2090    eq SrcOperator.toString()            = "operator";
2091    eq SrcOperatorRecord.toString()      = "operator record";
2092    eq SrcOperatorFunction.toString()    = "operator function";
2093
2094    syn String InstRestriction.toString();
2095    eq InstModel.toString()               = "model";
2096    eq InstBlock.toString()               = "block";
2097    eq InstMClass.toString()              = "class";
2098    eq InstConnector.toString()           = "connector";
2099    eq InstExpandableConnector.toString() = "expandable connector";
2100    eq InstMType.toString()               = "type";
2101    eq InstMPackage.toString()            = "package";
2102    eq InstFunction.toString()            = "function";
2103    eq InstMRecord.toString()             = "record";
2104    eq InstOperator.toString()            = "operator";
2105    eq InstOperatorRecord.toString()      = "operator record";
2106    eq InstOperatorFunction.toString()    = "operator function";
2107
2108    syn String SrcComponentDecl.toString() = prettyPrint("");
2109    syn String SrcAccess.toString()        = prettyPrint("");
2110    syn String SrcModification.toString()  = prettyPrint("");
2111}
2112
2113aspect PrettyPrint_MC {
2114
2115    /**
2116     * Static printer instance.
2117     */
2118    static MCPrettyPrinter ASTNode.printer_MC = new MCPrettyPrinter();
2119
2120    public class MCPrettyPrinter extends Printer {
2121
2122        public MCPrettyPrinter() {
2123            super("    ");
2124        }
2125
2126        public void print(ASTNode node, CodeStream str, String indent) {
2127            node.prettyPrint(this, str, indent); 
2128        }
2129
2130    }
2131
2132        public String ASTNode.prettyPrint_MC(String indent) {
2133                ByteArrayOutputStream os = new ByteArrayOutputStream();
2134                CodeStream str = new CodeStream(os);
2135                prettyPrint(str,indent);
2136                return os.toString();
2137        }
2138
2139    public static void List.prettyPrintFAttributeList_MC(Printer p, CodeStream str, String indent, List<FAttribute> l) {
2140        boolean firstAttr = true;
2141        for (FAttribute attr : l) {
2142            if (attr.getAttributeSet() && !attr.isAnnotation()) {
2143                if (firstAttr) {
2144                    str.print("(");
2145                } else {
2146                    str.print(", ");
2147                }
2148                p.print(attr, str, indent);
2149                firstAttr = false;
2150            }
2151        }
2152        if (!firstAttr) {
2153            str.print(")");
2154        }
2155    }
2156
2157    public void FVariable.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2158        str.print(indent, getTypePrefixVariability());
2159        if (!getCausalityConnectorPrefix().isNone()) {
2160            str.print(getCausalityConnectorPrefix(), " ");
2161        }
2162       
2163        str.print(prettyPrintType(), " ", nameUnderscore());
2164        List.prettyPrintFAttributeList_MC(p, str, indent, getFAttributeList());
2165       
2166        FExp bindingExp = null;
2167        if (hasBindingExp()) {
2168            bindingExp = getBindingExp();
2169        } else if (hasParameterEquation()) {
2170            bindingExp = ((FEquation) parameterEquation()).getRight();
2171        }
2172        if (bindingExp != null) {
2173            str.print(" = ");
2174            p.print(bindingExp,str,indent);
2175        }
2176       
2177        p.print(getFStringCommentOpt(), str, indent);
2178
2179        if (isIndependentParameter() && hasBindingExp()) {
2180            str.print(" /* ");
2181            try {
2182                str.print(getBindingExp().ceval());
2183            } catch (ConstantEvaluationException e){
2184                str.print("evaluation error");
2185            }
2186            str.print(" */");
2187        }
2188    }
2189
2190
2191    public void FClass.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2192        String nextInd = p.indent(indent);
2193   
2194        p.print(getFFunctionDecls(), str, indent);
2195        p.print(getFRecordDecls(), str, indent);
2196        p.print(getFEnumDecls(), str, indent);
2197        p.print(getFDerivedTypes(), str, indent);
2198   
2199        str.println(indent, "model ", nameUnderscore());
2200        for (FVariable fv : getFVariables()) {
2201            if (!fv.isDerivativeVariable() && !fv.isPreVariable()) {
2202                p.print(fv, str, nextInd);
2203                str.println(";");
2204            }
2205        }
2206
2207        if (getNumFInitialEquation() > 0) {
2208            str.println(indent, "initial equation");
2209        }
2210        getFInitialEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
2211
2212    /*
2213        if (getNumParameterEquation() > 0) {
2214            str.println(indent, "parameter equation");
2215        }
2216        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
2217    */
2218        prettyPrintEquations(p, str, indent);
2219               
2220        str.println(indent, "end ", nameUnderscore(), ";");
2221    }
2222
2223
2224        public void ASTNode.prettyPrint_MC(CodeStream str, String indent) {
2225                prettyPrint_MC(printer_MC, str, indent);
2226        }
2227
2228        public void ASTNode.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2229                prettyPrint(p, str, indent);
2230        }
2231       
2232        public void FAccessExp.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2233                str.print(nameUnderscore());
2234        }
2235
2236    public void FDerExp.prettyPrint_MC(Printer p, CodeStream str, String indent) {
2237        str.print("der(", getFAccess().nameUnderscore(), ")");
2238    }
2239
2240}
2241
2242aspect AnnotationPrettyPrinting {
2243    /**
2244     * Used when prettyprinting FAttribute annotation nodes
2245     */
2246    public class AnnotationPrettyPrinter extends PrettyPrinter {
2247
2248        @Override
2249        public PrettyPrinter annotationPrinter() {
2250            return this;
2251        }
2252
2253        @Override
2254        public boolean inAnnotation() {
2255            return true;
2256        }
2257    }
2258   
2259    public static PrettyPrinter ASTNode.AnnotationPrettyPrinter = new AnnotationPrettyPrinter();
2260
2261    /**
2262     * Returns a string listing the annotations in this class declaration and any child class declarations, recursively.
2263     *
2264     * @param prefix
2265     *          The string to prefix the annotation string with.
2266     */
2267    syn String InstClassDecl.printClassAnnotations(String prefix) = "";
2268
2269    eq InstFullClassDecl.printClassAnnotations(String prefix) {
2270        SrcFullClassDecl myDecl = getSrcFullClassDecl();
2271        Opt<SrcAnnotation> myAnnotation = myDecl.getSrcAnnotationOpt();
2272        String myNode = (myAnnotation.numChildren() > 0 ? prefix + myAnnotation.getChild(0).toString() + "\n" : "");
2273        StringBuilder string = new StringBuilder(myNode.contains("__JModelica") ? "" : myNode);
2274        for (InstClassDecl decl : getInstClassDecls()) {
2275            string.append(decl.printClassAnnotations(prefix + "    "));
2276        }
2277        return string.toString();
2278    }
2279    eq InstAbstractShortClassDecl.printClassAnnotations(String prefix) = getSrcShortClassDecl().srcAnnotation().toString();
2280
2281    /**
2282     * Returns a string listing the annotations for components in this class.
2283     *
2284     * @param prefix
2285     *          The string to prefix the annotation string with.
2286     */
2287    syn String InstClassDecl.printComponentAnnotations() = "";
2288   
2289    eq InstFullClassDecl.printComponentAnnotations() {
2290        StringBuilder sb = new StringBuilder();
2291        for (InstComponentDecl decl : getInstComponentDecls()) {
2292            if (sb.length() > 0) {
2293                sb.append('\n');
2294            }
2295            sb.append(decl.srcAnnotation().toString());
2296        }
2297        return sb.toString();
2298    }
2299}
Note: See TracBrowser for help on using the repository browser.