root/trunk/ProjectFortress/src/com/sun/fortress/tools/FortressAstToConcrete.java @ 2405

Revision 2405, 72.5 KB (checked in by sukyoungryu, 16 months ago)

[tool] Fixed arrays and also do.
Line 
1/*******************************************************************************
2    Copyright 2008 Sun Microsystems, Inc.,
3    4150 Network Circle, Santa Clara, California 95054, U.S.A.
4    All rights reserved.
5
6    U.S. Government Rights - Commercial software.
7    Government users are subject to the Sun Microsystems, Inc. standard
8    license agreement and applicable provisions of the FAR and its supplements.
9
10    Use is subject to license terms.
11
12    This distribution may include materials developed by third parties.
13
14    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
15    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
16 ******************************************************************************/
17
18package com.sun.fortress.tools;
19
20import java.util.List;
21import com.sun.fortress.nodes.*;
22import edu.rice.cs.plt.tuple.Option;
23import edu.rice.cs.plt.tuple.OptionUnwrapException;
24import edu.rice.cs.plt.iter.IterUtil;
25
26import static com.sun.fortress.exceptions.InterpreterBug.bug;
27
28public class FortressAstToConcrete extends NodeDepthFirstVisitor<String> {
29
30    /* Possible improvements **************************************************/
31    /* 1. Add newlines and indentation
32       2. Handle "parenthesized" field
33       3. Handle syntax abstraction nodes.
34     */
35
36    /* indentation utilities *************************************************/
37    private int indent = 0;
38
39    private void increaseIndent(){
40        indent += 1;
41    }
42
43    private void decreaseIndent(){
44        indent -= 1;
45    }
46
47    private String getIndent(){
48        StringBuilder s = new StringBuilder();
49
50        for ( int i = 0; i < indent; i++ ){
51            s.append( "    " );
52        }
53
54        return s.toString();
55    }
56
57    private String indent( String stuff ){
58        return getIndent() + stuff.replaceAll("\n", "\n" + getIndent() );
59    }
60
61    /* utility methods ********************************************************/
62    /* returns number copies of s */
63    private String makeCopies(int number, String s) {
64        String result = s;
65        for (int index = 1; index < number; index++) {
66            result += s;
67        }
68        return result;
69    }
70
71    /* returns a string beginning with 'kind' followed by a sequence of elements
72       in 'list' separated by commas and  enclosed by '{' and '}'
73     */
74    private String inCurlyBraces(String kind, List<String> list) {
75        StringBuilder s = new StringBuilder();
76        s.append( kind );
77        s.append( "{ " );
78        for ( String elem : IterUtil.skipLast(list) ){
79            s.append( elem ).append( ", " );
80        }
81        if ( ! list.isEmpty() ){
82            s.append( IterUtil.last(list) );
83        }
84        s.append( " }" );
85        return s.toString();
86    }
87
88    /* returns a string of a sequence of elements
89       in 'list' separated by commas and  enclosed by '[\' and '\]'
90     */
91    private String inOxfordBrackets(List<String> list) {
92        if ( list.isEmpty() ){
93            return "";
94        }
95        StringBuilder s = new StringBuilder();
96        s.append( "[\\ " );
97        for ( String elem : IterUtil.skipLast(list) ){
98            s.append( elem ).append( ", " );
99        }
100        if ( ! list.isEmpty() ){
101                s.append( IterUtil.last(list) );
102        }
103        s.append( " \\]" );
104        return s.toString();
105    }
106
107    /* returns a string of a sequence of elements
108       in 'list' separated by commas and  enclosed by '(' and ')'
109     */
110    private String inParentheses(List<String> list) {
111        if ( list.size() == 1) {
112            return list.get(0);
113        } else {
114            StringBuilder s = new StringBuilder();
115            s.append( "(" );
116            for ( String elem : IterUtil.skipLast(list) ){
117                s.append( elem ).append( ", " );
118            }
119            if ( ! list.isEmpty() ){
120                s.append( IterUtil.last(list) );
121            }
122            s.append( ")" );
123            return s.toString();
124        }
125    }
126
127    /*  make sure it is parenthesized */
128    private String inParentheses(String str) {
129        if ( str.startsWith("(") && str.endsWith(")") )
130            return str;
131        else
132            return "(" + str + ")";
133    }
134
135    private String join( List<String> all, String sep ){
136        StringBuilder s = new StringBuilder();
137
138        int index = 0;
139        for ( String element : all ){
140            s.append( element );
141            if ( index < all.size() - 1 ){
142                s.append( sep );
143            }
144            index += 1;
145        }
146
147        return s.toString();
148    }
149
150    /* visit nodes ************************************************************/
151    @Override public String forComponentOnly(Component that, String name_result,
152                                             List<String> imports_result,
153                                             List<String> exports_result,
154                                             List<String> decls_result) {
155        StringBuilder s = new StringBuilder();
156        if (that.is_native())
157            s.append( "native " );
158        s.append( "component " ).append( name_result ).append( "\n" );
159        for ( String import_ : imports_result ){
160            s.append( import_ ).append( "\n" );
161        }
162        for ( String export_ : exports_result ){
163            s.append( export_ ).append( "\n" );
164        }
165        for ( String decl_ : decls_result ){
166            s.append( decl_ ).append( "\n" );
167        }
168        s.append( "end" );
169        return s.toString();
170    }
171
172    @Override public String forApiOnly(Api that, String name_result,
173                                       List<String> imports_result,
174                                       List<String> decls_result) {
175        StringBuilder s = new StringBuilder();
176        s.append( "api " ).append( name_result ).append( "\n" );
177        for ( String import_ : imports_result ){
178            s.append( import_ ).append( "\n" );
179        }
180        for ( String decl_ : decls_result ){
181            s.append( decl_ ).append( "\n" );
182        }
183        s.append( "end" );
184        return s.toString();
185    }
186
187    @Override public String forImportStarOnly(ImportStar that,
188                                              String api_result,
189                                              List<String> except_result) {
190        StringBuilder s = new StringBuilder();
191        s.append( "import " ).append( api_result ).append( ".{...}" );
192        if ( ! except_result.isEmpty() ) {
193            s.append(inCurlyBraces(" except ", except_result));
194        }
195        return s.toString();
196    }
197
198    @Override public String forImportNamesOnly(ImportNames that,
199                                               String api_result,
200                                               List<String> aliasedNames_result) {
201        StringBuilder s = new StringBuilder();
202        s.append( "import " ).append( api_result );
203        if ( aliasedNames_result.isEmpty() ) {
204            return bug(that, "Import statement should have at least one name.");
205        } else {
206            s.append(inCurlyBraces(".", aliasedNames_result));
207        }
208        return s.toString();
209    }
210
211    @Override public String forImportApiOnly(ImportApi that,
212                                             List<String> apis_result) {
213        StringBuilder s = new StringBuilder();
214        if ( apis_result.isEmpty() ) {
215            return bug(that, "Import statement should have at least one name.");
216        } else {
217            s.append(inCurlyBraces("import api ", apis_result));
218        }
219        return s.toString();
220    }
221
222    @Override public String forAliasedSimpleNameOnly(AliasedSimpleName that,
223                                                     String name_result,
224                                                     Option<String> alias_result) {
225        StringBuilder s = new StringBuilder();
226        s.append( name_result );
227        if ( alias_result.isSome() ) {
228            s.append( " as " ).append(alias_result.unwrap());
229        }
230        return s.toString();
231    }
232
233    @Override public String forAliasedAPINameOnly(AliasedAPIName that,
234                                                  String api_result,
235                                                  Option<String> alias_result) {
236        StringBuilder s = new StringBuilder();
237        s.append( api_result );
238        if ( alias_result.isSome() ) {
239            s.append( " as " ).append(alias_result.unwrap());
240        }
241        return s.toString();
242    }
243
244    @Override public String forExportOnly(Export that, List<String> apis_result) {
245        StringBuilder s = new StringBuilder();
246        if (apis_result.size() == 0)
247            return bug(that, "An export statement should have at least one API name.");
248        else
249            return inCurlyBraces("export ", apis_result);
250    }
251
252    @Override public String forAbsTraitDeclOnly(AbsTraitDecl that,
253                                                List<String> mods_result,
254                                                String name_result,
255                                                List<String> staticParams_result,
256                                                List<String> extendsClause_result,
257                                                String where_result,
258                                                List<String> excludes_result,
259                                                Option<List<String>> comprises_result,
260                                                List<String> decls_result) {
261        StringBuilder s = new StringBuilder();
262
263        s.append( join(mods_result, " ") );
264        s.append( "trait " ).append( name_result );
265        if ( ! staticParams_result.isEmpty() ) {
266            s.append( inOxfordBrackets(staticParams_result) );
267        }
268        if ( ! extendsClause_result.isEmpty() ) {
269            s.append( inCurlyBraces("extends ", extendsClause_result) );
270        }
271        s.append( where_result );
272        if ( ! excludes_result.isEmpty() ) {
273            s.append( inCurlyBraces("excludes ", excludes_result) );
274        }
275        if ( comprises_result.isSome() ){
276            List<String> throws_ = comprises_result.unwrap();
277            if ( ! throws_.isEmpty() )
278                s.append( inCurlyBraces("comprises ", throws_) );
279        }
280        s.append( "\n" );
281        s.append( join(decls_result,"\n") );
282        s.append( "\nend" ).append( "\n" );
283
284        return s.toString();
285    }
286
287    @Override public String forTraitDeclOnly(TraitDecl that,
288                                             List<String> mods_result,
289                                             String name_result,
290                                             List<String> staticParams_result,
291                                             List<String> extendsClause_result,
292                                             String where_result,
293                                             List<String> excludes_result,
294                                             Option<List<String>> comprises_result,
295                                             List<String> decls_result) {
296        StringBuilder s = new StringBuilder();
297
298        s.append( join(mods_result, " ") );
299        s.append( "trait " ).append( name_result );
300        if ( ! staticParams_result.isEmpty() ) {
301            s.append( inOxfordBrackets(staticParams_result) );
302        }
303        if ( ! extendsClause_result.isEmpty() ) {
304            s.append( inCurlyBraces("extends ", extendsClause_result) );
305        }
306        s.append( where_result );
307        if ( ! excludes_result.isEmpty() ) {
308            s.append( inCurlyBraces("excludes ", excludes_result) );
309        }
310        if ( comprises_result.isSome() ){
311            List<String> throws_ = comprises_result.unwrap();
312            if ( ! throws_.isEmpty() )
313                s.append( inCurlyBraces("comprises ", throws_) );
314        }
315        s.append( "\n" );
316        s.append( join(decls_result,"\n") );
317        s.append( "\nend" ).append( "\n" );
318
319        return s.toString();
320    }
321
322    @Override public String forAbsObjectDeclOnly(AbsObjectDecl that,
323                                                 List<String> mods_result,
324                                                 String name_result,
325                                                 List<String> staticParams_result,
326                                                 List<String> extendsClause_result,
327                                                 String where_result,
328                                                 Option<List<String>> params_result,
329                                                 Option<List<String>> throwsClause_result,
330                                                 String contract_result,
331                                                 List<String> decls_result) {
332        StringBuilder s = new StringBuilder();
333
334        increaseIndent();
335
336        s.append( join(mods_result, " ") );
337        s.append( "object " ).append( name_result );
338        if ( ! staticParams_result.isEmpty() ) {
339            s.append( inOxfordBrackets(staticParams_result) );
340        }
341        if ( ! extendsClause_result.isEmpty() ) {
342            s.append( inCurlyBraces("extends ", extendsClause_result) );
343        }
344        s.append( where_result );
345        if ( params_result.isSome() ){
346            s.append( inParentheses(params_result.unwrap()) );
347        }
348        if ( throwsClause_result.isSome() ){
349            List<String> throws_ = throwsClause_result.unwrap();
350            if ( ! throws_.isEmpty() )
351                s.append( inCurlyBraces("throws ", throws_) );
352        }
353        s.append( contract_result );
354        s.append( "\n" );
355        s.append( indent(join(decls_result,"\n")) );
356        s.append( "\nend" ).append( "\n" );
357
358        decreaseIndent();
359
360        return s.toString();
361    }
362
363    @Override public String forObjectDeclOnly(ObjectDecl that,
364                                              List<String> mods_result,
365                                              String name_result,
366                                              List<String> staticParams_result,
367                                              List<String> extendsClause_result,
368                                              String where_result,
369                                              Option<List<String>> params_result,
370                                              Option<List<String>> throwsClause_result,
371                                              String contract_result,
372                                              List<String> decls_result) {
373        StringBuilder s = new StringBuilder();
374
375        increaseIndent();
376
377        s.append( join(mods_result, " ") );
378        s.append( "object " ).append( name_result );
379        if ( ! staticParams_result.isEmpty() ) {
380            s.append( inOxfordBrackets(staticParams_result) );
381        }
382        if ( ! extendsClause_result.isEmpty() ) {
383            s.append( inCurlyBraces("extends ", extendsClause_result) );
384        }
385        s.append( where_result );
386        if ( params_result.isSome() ){
387            s.append( inParentheses(params_result.unwrap()) );
388        }
389        if ( throwsClause_result.isSome() ){
390            List<String> throws_ = throwsClause_result.unwrap();
391            if ( ! throws_.isEmpty() )
392                s.append( inCurlyBraces("throws ", throws_) );
393        }
394        s.append( contract_result );
395        s.append( "\n" );
396        s.append( indent(join(decls_result,"\n")) );
397        s.append( "\nend" ).append( "\n" );
398
399        decreaseIndent();
400
401        return s.toString();
402    }
403
404    @Override public String forAbsVarDeclOnly(AbsVarDecl that,
405                                              List<String> lhs_result) {
406        return inParentheses(lhs_result);
407    }
408
409    @Override public String forVarDeclOnly(VarDecl that,
410                                           List<String> lhs_result,
411                                           String init_result) {
412        StringBuilder s = new StringBuilder();
413
414        s.append( inParentheses(lhs_result) );
415        s.append( " = " );
416        s.append( init_result );
417
418        return s.toString();
419    }
420
421    @Override public String forLValueBindOnly(LValueBind that,
422                                              String name_result,
423                                              Option<String> type_result,
424                                              List<String> mods_result) {
425        StringBuilder s = new StringBuilder();
426
427        s.append( join(mods_result, " ") );
428        s.append( name_result );
429        if ( type_result.isSome() ){
430            s.append( ": " );
431            s.append( type_result.unwrap() );
432        }
433
434        return s.toString();
435    }
436
437//    @Override public String forUnpastingBindOnly( that,
438//    @Override public String forUnpastingSplitOnly( that,
439
440    @Override public String forAbsFnDeclOnly(AbsFnDecl that,
441                                             List<String> mods_result,
442                                             String name_result,
443                                             List<String> staticParams_result,
444                                             List<String> params_result,
445                                             Option<String> returnType_result,
446                                             Option<List<String>> throwsClause_result,
447                                             String where_result,
448                                             String contract_result) {
449        StringBuilder s = new StringBuilder();
450        for ( String mod : mods_result ){
451            s.append( mod ).append( " " );
452        }
453        s.append( name_result );
454        if ( ! staticParams_result.isEmpty() )
455            s.append( inOxfordBrackets(staticParams_result) );
456        s.append( inParentheses(inParentheses(params_result)) );
457        if (returnType_result.isSome())
458            s.append( ": " ).append( returnType_result.unwrap() );
459        if (throwsClause_result.isSome()) {
460            List<String> throws_ = throwsClause_result.unwrap();
461            if ( ! throws_.isEmpty() )
462                s.append( inCurlyBraces("throws ", throws_) );
463        }
464        s.append( where_result );
465        s.append( contract_result );
466        return s.toString();
467    }
468
469
470    @Override public String forFnDefOnly(FnDef that,
471                                         List<String> mods_result,
472                                         String name_result,
473                                         List<String> staticParams_result,
474                                         List<String> params_result,
475                                         Option<String> returnType_result,
476                                         Option<List<String>> throwsClause_result,
477                                         String where_result,
478                                         String contract_result,
479                                         String body_result) {
480        StringBuilder s = new StringBuilder();
481        for ( String mod : mods_result ){
482            s.append( mod ).append( " " );
483        }
484        s.append( name_result );
485        if ( ! staticParams_result.isEmpty() )
486            s.append( inOxfordBrackets(staticParams_result) );
487        s.append( inParentheses(inParentheses(params_result)) );
488        if ( returnType_result.isSome() )
489            s.append( ": " ).append( returnType_result.unwrap() );
490        if ( throwsClause_result.isSome() ) {
491            List<String> throws_ = throwsClause_result.unwrap();
492            if ( ! throws_.isEmpty() )
493                s.append( inCurlyBraces("throws ", throws_) );
494        }
495        s.append( where_result );
496        s.append( contract_result );
497        s.append( " = " );
498        s.append( body_result );
499        return s.toString();
500    }
501
502    @Override public String forNormalParamOnly(NormalParam that,
503                                               List<String> mods_result,
504                                               String name_result,
505                                               Option<String> type_result,
506                                               Option<String> defaultExpr_result) {
507        StringBuilder s = new StringBuilder();
508        for ( String mod : mods_result ){
509            s.append( mod ).append( " " );
510        }
511        s.append( name_result );
512        if (type_result.isSome())
513            s.append( ": " ).append( type_result.unwrap() );
514        if (defaultExpr_result.isSome())
515            s.append( "=").append( defaultExpr_result );
516        return s.toString();
517    }
518
519    @Override public String forVarargsParamOnly(VarargsParam that,
520                                                List<String> mods_result,
521                                                String name_result,
522                                                String type_result) {
523        StringBuilder s = new StringBuilder();
524        for ( String mod : mods_result ){
525            s.append( mod ).append( " " );
526        }
527        s.append( name_result );
528        s.append( ": " );
529        s.append( type_result );
530        s.append( "..." );
531        return s.toString();
532    }
533
534    @Override public String forDimDeclOnly(DimDecl that,
535                                           String dim_result,
536                                           Option<String> derived_result,
537                                           Option<String> default_result) {
538        StringBuilder s = new StringBuilder();
539
540        s.append( "dim " ).append( dim_result ).append( " " );
541        if ( derived_result.isSome() ) {
542            s.append( "= " ).append( derived_result.unwrap() );
543        }
544        if ( default_result.isSome() ) {
545            s.append( "default " ).append( default_result.unwrap() );
546        }
547
548        return s.toString();
549    }
550
551    @Override public String forUnitDeclOnly(UnitDecl that,
552                                            List<String> units_result,
553                                            Option<String> dim_result,
554                                            Option<String> def_result) {
555        StringBuilder s = new StringBuilder();
556
557        if ( that.isSi_unit() ) {
558            s.append( "SI_" );
559        }
560        s.append( "unit " );
561        s.append( join(units_result, " ") );
562        if ( dim_result.isSome() ) {
563            s.append( ": " ).append( dim_result.unwrap() );
564        }
565        if ( def_result.isSome() ) {
566            s.append( "= " ).append( def_result.unwrap() );
567        }
568
569        return s.toString();
570    }
571
572    @Override public String forTestDeclOnly(TestDecl that,
573                                            String name_result,
574                                            List<String> gens_result,
575                                            String expr_result) {
576        StringBuilder s = new StringBuilder();
577
578        s.append( "test " ).append( name_result).append( " [ " );
579        s.append( join(gens_result, ", ") );
580        s.append( " ] = " );
581        s.append( expr_result );
582
583        return s.toString();
584    }
585
586    @Override public String forPropertyDeclOnly(PropertyDecl that,
587                                                Option<String> name_result,
588                                                List<String> params_result,
589                                                String expr_result) {
590        StringBuilder s = new StringBuilder();
591
592        s.append( "property " );
593        if ( name_result.isSome() ) {
594            s.append( name_result.unwrap() ).append( " = " );
595        }
596        if ( ! params_result.isEmpty() ) {
597            s.append( "FORALL " );
598            s.append( inParentheses(params_result) );
599            s.append( " " );
600        }
601        s.append(expr_result);
602
603        return s.toString();
604    }
605
606    @Override public String forAsExprOnly(AsExpr that,
607                                          String expr_result,
608                                          String type_result) {
609        return expr_result + " as " + type_result;
610    }
611
612    @Override public String forAsIfExprOnly(AsIfExpr that,
613                                            String expr_result,
614                                            String type_result) {
615        return expr_result + " asif " + type_result;
616    }
617
618    @Override public String forAssignmentOnly(Assignment that,
619                                              List<String> lhs_result,
620                                              Option<String> opr_result,
621                                              String rhs_result) {
622        StringBuilder s = new StringBuilder();
623
624        s.append( inParentheses(lhs_result) ).append( " " );
625        if ( opr_result.isSome() ){
626            s.append( opr_result.unwrap() ).append( "= " );
627        } else {
628            s.append( ":= " );
629        }
630        s.append( rhs_result );
631
632        return s.toString();
633    }
634
635    @Override public String forBlockOnly(Block that,
636                                         List<String> exprs_result) {
637        StringBuilder s = new StringBuilder();
638        s.append( join( exprs_result, "\n" ) );
639        return s.toString();
640    }
641
642    @Override public String forCaseExprOnly(CaseExpr that,
643                                            Option<String> param_result,
644                                            Option<String> compare_result,
645                                            String equalsOp_result,
646                                            String inOp_result,
647                                            List<String> clauses_result,
648                                            Option<String> elseClause_result) {
649        StringBuilder s = new StringBuilder();
650        s.append( "case " );
651        if ( param_result.isSome() )
652            s.append( param_result.unwrap() ).append( " " );
653        else s.append( "most " );
654        if ( compare_result.isSome() )
655            s.append( compare_result.unwrap() ).append( " " );
656        s.append( "of\n" );
657        s.append( join(clauses_result, "\n") );
658        if ( elseClause_result.isSome() )
659            s.append( elseClause_result.unwrap() ).append( "\n" );
660        s.append( "end" );
661        return s.toString();
662    }
663
664    @Override public String forDoOnly(Do that,
665                                      List<String> fronts_result) {
666        StringBuilder s = new StringBuilder();
667        s.append( indent(join(fronts_result, " also\n")) );
668        s.append( "\nend" );
669        return s.toString();
670    }
671
672    @Override public String forForOnly(For that,
673                                       List<String> gens_result,
674                                       String body_result) {
675        StringBuilder s = new StringBuilder();
676
677        s.append( "for " );
678        s.append( join(gens_result, ", \n") );
679        s.append( "\n" ).append( body_result );
680        s.append( "\nend" );
681
682        return s.toString();
683    }
684
685    @Override public String forIfOnly(If that,
686                                      List<String> clauses_result,
687                                      Option<String> elseClause_result) {
688        StringBuilder s = new StringBuilder();
689
690        s.append( "if " );
691        if ( clauses_result.isEmpty() ) {
692            return bug(that, "An if expression should have at least " +
693                       "one then branch.");
694        } else {
695            s.append( IterUtil.first(clauses_result) );
696            for (String ifclause : IterUtil.skipFirst(clauses_result) ) {
697                s.append( "elif " );
698                s.append( ifclause );
699            }
700        }
701        if ( elseClause_result.isSome() ) {
702            s.append("\nelse ");
703            s.append( elseClause_result.unwrap() );
704        }
705        s.append( "\nend" );
706
707        return s.toString();
708    }
709
710    @Override public String forLabelOnly(Label that,
711                                         String name_result,
712                                         String body_result) {
713        StringBuilder s = new StringBuilder();
714
715        s.append( "label " ).append( name_result ).append( " " );
716        s.append( body_result );
717        s.append( "\nend " ).append( name_result );
718
719        return  s.toString();
720    }
721
722
723    @Override public String forObjectExprOnly(ObjectExpr that,
724                                              List<String> extendsClause_result,
725                                              List<String> decls_result) {
726        StringBuilder s = new StringBuilder();
727
728        s.append( "object " );
729        if ( ! extendsClause_result.isEmpty() ) {
730            s.append( inCurlyBraces("extends ", extendsClause_result) );
731            s.append( "\n" );
732        }
733        s.append( join(decls_result, "\n") );
734        s.append( "\nend" );
735
736        return s.toString();
737    }
738
739
740    @Override public String for_RewriteObjectExprOnly(_RewriteObjectExpr that,
741                                                      List<String> extendsClause_result,
742                                                      List<String> decls_result,
743                                                      List<String> staticParams_result,
744                                                      List<String> staticArgs_result,
745                                                      Option<List<String>> params_result) {
746        StringBuilder s = new StringBuilder();
747
748        s.append( "object " );
749        if ( ! extendsClause_result.isEmpty() ) {
750            s.append( inCurlyBraces("extends ", extendsClause_result) );
751            s.append( "\n" );
752        }
753        s.append( join(decls_result, "\n") );
754        s.append( "\nend" );
755
756        return s.toString();
757    }
758
759    @Override public String forTryOnly(Try that,
760                                       String body_result,
761                                       Option<String> catchClause_result,
762                                       List<String> forbid_result,
763                                       Option<String> finallyClause_result) {
764        StringBuilder s = new StringBuilder();
765
766        s.append( "try " ).append( body_result ).append( "\n" );
767        if ( catchClause_result.isSome() ) {
768            s.append( catchClause_result.unwrap() ).append( "\n" );
769        }
770        if ( ! forbid_result.isEmpty() ) {
771            s.append( inCurlyBraces("forbid ", forbid_result) ).append( "\n" );
772        }
773        if ( finallyClause_result.isSome() ) {
774            s.append( "finally " );
775            s.append( finallyClause_result.unwrap() ).append( "\n" );
776        }
777        s.append("end");
778
779        return s.toString();
780    }
781
782    @Override public String forTupleExprOnly(TupleExpr that,
783                                             List<String> exprs_result) {
784        if ( exprs_result.size() == 1 )
785            return exprs_result.get(0);
786        else {
787            StringBuilder s = new StringBuilder();
788            s.append( "(" );
789            s.append( join(exprs_result, ", ") );
790            s.append( ")" );
791            return s.toString();
792        }
793    }
794
795//    @Override public String forArgExprOnly( that,
796//    @Override public String forTypecaseOnly( that,
797//    @Override public String forWhileOnly( that,
798//    @Override public String forAccumulatorOnly( that,
799//    @Override public String forArrayComprehensionOnly( that,
800
801    @Override public String forAtomicExprOnly(AtomicExpr that,
802                                              String expr_result) {
803        StringBuilder s = new StringBuilder();
804        s.append( "atomic " ).append( expr_result );
805        return s.toString();
806    }
807
808    @Override public String forExitOnly(Exit that,
809                                        Option<String> target_result,
810                                        Option<String> returnExpr_result) {
811        StringBuilder s = new StringBuilder();
812
813        s.append( "exit " );
814        if ( target_result.isSome() ) {
815            s.append( target_result ).append( " " );
816        }
817        if ( returnExpr_result.isSome() ) {
818            s.append( "with " ).append( returnExpr_result.unwrap() );
819        }
820
821        return s.toString();
822    }
823
824    @Override public String forSpawnOnly(Spawn that,
825                                         String body_result) {
826        return "spawn " + body_result;
827    }
828
829    @Override public String forThrowOnly(Throw that,
830                                         String expr_result) {
831        return "throw " + expr_result;
832    }
833
834    @Override public String forTryAtomicExprOnly(TryAtomicExpr that,
835                                                 String expr_result) {
836        return "tryatomic " + expr_result;
837    }
838
839    @Override public String forFnExprOnly(FnExpr that,
840                                          String name_result,
841                                          List<String> staticParams_result,
842                                          List<String> params_result,
843                                          Option<String> returnType_result,
844                                          String where_result,
845                                          Option<List<String>> throwsClause_result,
846                                          String body_result) {
847        StringBuilder s = new StringBuilder();
848
849        s.append( "fn " );
850        s.append( inParentheses(params_result) );
851        if ( returnType_result.isSome() ) {
852            s.append( ": " ).append( returnType_result.unwrap() );
853        }
854        if ( throwsClause_result.isSome() ) {
855            List<String> throws_ = throwsClause_result.unwrap();
856            if ( ! throws_.isEmpty() )
857                s.append( inCurlyBraces("throws ", throws_) );
858        }
859        s.append( " => ").append(body_result);
860
861        return s.toString();
862    }
863
864    @Override public String forLetFnOnly(LetFn that,
865                                         List<String> body_result,
866                                         List<String> fns_result) {
867        StringBuilder s = new StringBuilder();
868
869        s.append( join( fns_result, "\n" ) );
870        s.append( join( body_result, "\n" ) );
871
872        return s.toString();
873    }
874
875    @Override public String forLocalVarDeclOnly(LocalVarDecl that,
876                                                List<String> body_result,
877                                                List<String> lhs_result,
878                                                Option<String> rhs_result) {
879        StringBuilder s = new StringBuilder();
880
881        s.append( inParentheses(lhs_result) );
882        if ( rhs_result.isSome() ){
883            s.append( " = " );
884            s.append( rhs_result.unwrap() );
885        }
886        s.append("\n");
887        s.append( join( body_result, "\n" ) );
888
889        return s.toString();
890    }
891
892    @Override public String forGeneratedExprOnly(GeneratedExpr that,
893                                                 String expr_result,
894                                                 List<String> gens_result) {
895        StringBuilder s = new StringBuilder();
896
897        s.append( expr_result );
898        if ( ! gens_result.isEmpty() ) {
899            s.append( ", " );
900            s.append( join(gens_result, ", ") );
901        }
902
903        return s.toString();
904    }
905
906    @Override public String forSubscriptExprOnly(SubscriptExpr that,
907                                                 String obj_result,
908                                                 List<String> subs_result,
909                                                 Option<String> op_result,
910                                                 List<String> staticArgs_result) {
911        StringBuilder s = new StringBuilder();
912        String left;
913        String right;
914
915        s.append( obj_result );
916        if ( op_result.isSome() ) {
917            String enclosing = op_result.unwrap();
918            int size = enclosing.length();
919            left = enclosing.substring(0, size/2);
920            right = enclosing.substring(size/2+1, size);
921        } else {
922            left = "[";
923            right = "]";
924        }
925        s.append( left );
926        if ( ! staticArgs_result.isEmpty() ) {
927            s.append( inOxfordBrackets(staticArgs_result) );
928        }
929        s.append( " " );
930        s.append( join(subs_result, ", ") );
931        s.append( " " ).append( right );
932
933        return s.toString();
934    }
935
936    @Override public String forFloatLiteralExprOnly(FloatLiteralExpr that) {
937        return that.getText();
938    }
939
940    @Override public String forIntLiteralExprOnly(IntLiteralExpr that) {
941        return that.getVal().toString();
942    }
943
944    @Override public String forCharLiteralExprOnly(CharLiteralExpr that) {
945        return "'" + that.getText() + "'";
946    }
947
948    @Override public String forStringLiteralExprOnly(StringLiteralExpr that) {
949        return "\"" + that.getText() + "\"";
950    }
951
952    @Override public String forVoidLiteralExprOnly(VoidLiteralExpr that) {
953        return "()";
954    }
955
956    @Override public String forVarRefOnly(VarRef that,
957                                          String var_result) {
958        return var_result;
959    }
960
961//    @Override public String for_RewriteObjectRefOnly( that,
962//    @Override public String forFieldRefOnly( that,
963//    @Override public String for_RewriteFieldRefOnly( that,
964
965    @Override public String forFnRefOnly(FnRef that,
966                                         String originalName_result,
967                                         List<String> fns_result,
968                                         List<String> staticArgs_result) {
969        StringBuilder s = new StringBuilder();
970
971        s.append( originalName_result );
972        if ( ! staticArgs_result.isEmpty() ) {
973            s.append( inOxfordBrackets(staticArgs_result) );
974        }
975
976        return s.toString();
977    }
978
979//    @Override public String for_RewriteFnRefOnly( that,
980
981//    @Override public String forOpRefOnly( that,
982    /* TODO: BIG Op StaticArgs
983             LeftEncloser StaticArgs ExprList RightEncloser
984     */
985    @Override public String forOpRefOnly(OpRef that,
986                                         String originalName_result,
987                                         List<String> ops_result,
988                                         List<String> staticArgs_result) {
989        StringBuilder s = new StringBuilder();
990
991        s.append( originalName_result );
992
993        return s.toString();
994    }
995
996    @Override public String forLooseJuxtOnly(LooseJuxt that,
997                                             String multiJuxt_result,
998                                             String infixJuxt_result,
999                                             List<String> exprs_result) {
1000        StringBuilder s = new StringBuilder();
1001        for ( String expr : exprs_result ){
1002            s.append( expr );
1003            s.append( " " );
1004        }
1005        return s.toString();
1006    }
1007
1008    @Override public String forTightJuxtOnly(TightJuxt that,
1009                                             String multiJuxt_result,
1010                                             String infixJuxt_result,
1011                                             List<String> exprs_result) {
1012        StringBuilder s = new StringBuilder();
1013        if ( exprs_result.isEmpty() )
1014            return bug(that, "A tight juxtaposition expression should have " +
1015                       "at least two subexpressions.");
1016        s.append(IterUtil.first(exprs_result));
1017        for ( String expr : IterUtil.skipFirst(exprs_result) ){
1018            s.append( inParentheses(expr) );
1019        }
1020        return s.toString();
1021    }
1022
1023    @Override public String for_RewriteFnAppOnly(_RewriteFnApp that,
1024                                                 String function_result,
1025                                                 String argument_result) {
1026        StringBuilder s = new StringBuilder();
1027
1028        s.append( function_result );
1029        s.append( inParentheses(argument_result) );
1030
1031        return s.toString();
1032    }
1033
1034    //    @Override public String forOpExprOnly( that,
1035    /* TODO: operator fixity
1036     */
1037    @Override public String forOpExprOnly(OpExpr that,
1038                                          String op_result,
1039                                          List<String> args_result) {
1040        StringBuilder s = new StringBuilder();
1041
1042        s.append( join(args_result, " " + op_result + " ") );
1043
1044        return s.toString();
1045    }
1046
1047    @Override public String forAmbiguousMultifixOpExprOnly(AmbiguousMultifixOpExpr that,
1048                                                           String infix_op_result,
1049                                                           String multifix_op_result,
1050                                                           List<String> args_result) {
1051        StringBuilder s = new StringBuilder();
1052        s.append( join( args_result, " "+infix_op_result+" " ) );
1053        return s.toString();
1054    }
1055
1056    @Override public String forChainExprOnly(ChainExpr that,
1057                                             String first_result,
1058                                             List<String> links_result) {
1059        StringBuilder s = new StringBuilder();
1060
1061        s.append( first_result );
1062        s.append( join(links_result, " ") );
1063
1064        return s.toString();
1065    }
1066
1067    @Override public String forCoercionInvocationOnly(CoercionInvocation that,
1068                                                      String type_result,
1069                                                      List<String> staticArgs_result,
1070                                                      String arg_result) {
1071        /*
1072        StringBuilder s = new StringBuilder();
1073
1074        s.append( type_result );
1075        if ( ! staticArgs_result.isEmpty() ) {
1076            s.append( inOxfordBrackets(staticArgs_result) );
1077        }
1078        s.append( ".coercion" );
1079        s.append( inParentheses(arg_result) );
1080
1081        return s.toString();
1082        */
1083        return bug(that, "Explicit coercion invocation is not supported " +
1084                   "in Fortress concrete syntax.");
1085    }
1086
1087    @Override public String forMethodInvocationOnly(MethodInvocation that,
1088                                                    String obj_result,
1089                                                    String method_result,
1090                                                    List<String> staticArgs_result,
1091                                                    String arg_result) {
1092        StringBuilder s = new StringBuilder();
1093
1094        s.append( obj_result ).append( "." ).append( method_result );
1095        if ( ! staticArgs_result.isEmpty() ) {
1096            s.append( inOxfordBrackets(staticArgs_result ) );
1097        }
1098        s.append( inParentheses(arg_result) );
1099
1100        return s.toString();
1101    }
1102
1103//    @Override public String forMathPrimaryOnly( that,
1104
1105    @Override public String forArrayElementOnly(ArrayElement that,
1106                                                List<String> staticArgs_result,
1107                                                String element_result) {
1108        return element_result;
1109    }
1110
1111    @Override public String forArrayElementsOnly(ArrayElements that,
1112                                                 List<String> staticArgs_result,
1113                                                 List<String> elements_result) {
1114        StringBuilder s = new StringBuilder();
1115
1116        if ( that.isOutermost() ) {
1117            s.append( "[" );
1118            s.append( inOxfordBrackets( staticArgs_result ) );
1119            s.append( " " );
1120        }
1121        String separator;
1122        if ( that.getDimension() == 1 )
1123            separator = " ";
1124        else
1125            separator = makeCopies(that.getDimension()-1, ";");
1126        s.append( join(elements_result, separator) );
1127        if ( that.isOutermost() )
1128            s.append( " ]" );
1129
1130        return s.toString();
1131    }
1132
1133//    @Override public String forExponentTypeOnly( that,
1134//    @Override public String forBaseDimOnly( that,
1135//    @Override public String forDimRefOnly( that,
1136//    @Override public String forProductDimOnly( that,
1137//    @Override public String forQuotientDimOnly( that,
1138//    @Override public String forExponentDimOnly( that,
1139//    @Override public String forOpDimOnly( that,
1140//    @Override public String forAnyTypeOnly( that,
1141//    @Override public String forBottomTypeOnly( that,
1142
1143    @Override public String forVarTypeOnly(VarType that, String name_result) {
1144        return name_result;
1145    }
1146
1147//    @Override public String forTraitTypeOnly( that,
1148//    @Override public String for_RewriteGenericSingletonTypeOnly( that,
1149
1150    @Override public String forArrayTypeOnly(ArrayType that,
1151                                             String type_result,
1152                                             String indices_result) {
1153        StringBuilder s = new StringBuilder();
1154
1155        s.append( type_result );
1156        s.append( "[" );
1157        s.append( indices_result );
1158        s.append( "]" );
1159
1160        return s.toString();
1161    }
1162
1163//    @Override public String forMatrixTypeOnly( that,
1164//    @Override public String forTaggedDimTypeOnly( that,
1165//    @Override public String forTaggedUnitTypeOnly( that,
1166//    @Override public String forTupleTypeOnly( that,
1167//    @Override public String forVarargTupleTypeOnly( that,
1168
1169    @Override public String forVoidTypeOnly(VoidType that) {
1170        return "()";
1171    }
1172
1173    @Override public String forArrowTypeOnly(ArrowType that,
1174                                             String domain_result,
1175                                             String range_result,
1176                                             String effect_result) {
1177        StringBuilder s = new StringBuilder();
1178        s.append( domain_result );
1179        s.append( " -> " );
1180        s.append( range_result );
1181        s.append( effect_result );
1182        return s.toString();
1183    }
1184
1185    @Override public String for_RewriteGenericArrowTypeOnly(_RewriteGenericArrowType that,
1186                                                            List<String> staticParams_result,
1187                                                            String domain_result,
1188                                                            String range_result,
1189                                                            String effect_result,
1190                                                            String where_result) {
1191        return bug(that, "Generic arrow types are not supported " +
1192                   "in Fortress concrete syntax.");
1193    }
1194
1195    @Override public String for_InferenceVarTypeOnly(_InferenceVarType that) {
1196        return bug(that, "Inference variable types are not supported " +
1197                   "in Fortress concrete syntax.");
1198    }
1199
1200    @Override public String forIntersectionTypeOnly(IntersectionType that,
1201                                                    List<String> elements_result) {
1202        return bug(that, "Intersection types are not supported " +
1203                   "in Fortress concrete syntax.");
1204    }
1205
1206    @Override public String forUnionTypeOnly(UnionType that,
1207                                             List<String> elements_result) {
1208        return bug(that, "Union types are not supported " +
1209                   "in Fortress concrete syntax.");
1210    }
1211
1212    @Override public String forFixedPointTypeOnly(FixedPointType that,
1213                                                  String name_result,
1214                                                  String body_result) {
1215        return bug(that, "Fixed point types are not supported " +
1216                   "in Fortress concrete syntax.");
1217    }
1218
1219    @Override public String forLabelTypeOnly(LabelType that) {
1220        return bug(that, "Label types are not supported " +
1221                   "in Fortress concrete syntax.");
1222    }
1223
1224    @Override public String forDomainOnly(Domain that,
1225                                          List<String> args_result,
1226                                          Option<String> varargs_result,
1227                                          List<String> keywords_result) {
1228        int args_size = args_result.size();
1229        int varargs_size = (varargs_result.isSome()) ? 1 : 0;
1230        int keywords_size = keywords_result.size();
1231        boolean inParen = ( args_size + varargs_size + keywords_size > 1 ||
1232                            varargs_size > 0 || keywords_size > 0);
1233        StringBuilder s = new StringBuilder();
1234        s.append( join(args_result, ", " ) );
1235        if ( varargs_size == 1 ) {
1236            if ( args_size > 0 )
1237                s.append( ", " );
1238            s.append( varargs_result.unwrap() );
1239        }
1240        if ( keywords_size > 0 ) {
1241            if ( args_size + varargs_size > 0)
1242                s.append( ", " );
1243            s.append( join(keywords_result, ", ") );
1244        }
1245        if ( inParen )
1246            return inParentheses( s.toString() );
1247        else return s.toString();
1248    }
1249
1250    @Override public String forEffectOnly(Effect that,
1251                                          Option<List<String>> throwsClause_result) {
1252        if ( throwsClause_result.isSome() )
1253            return inCurlyBraces(" throws ", throwsClause_result.unwrap());
1254        else return "";
1255    }
1256
1257    @Override public String forTypeArgOnly(TypeArg that,
1258                                           String type_result) {
1259        return type_result;
1260    }
1261
1262    @Override public String forIntArgOnly(IntArg that,
1263                                          String val_result) {
1264        return val_result;
1265    }
1266
1267    @Override public String forBoolArgOnly(BoolArg that,
1268                                           String bool_result) {
1269        return bool_result;
1270    }
1271
1272    @Override public String forOpArgOnly(OpArg that,
1273                                         String name_result) {
1274        return name_result;
1275    }
1276
1277    @Override public String forDimArgOnly(DimArg that,
1278                                          String dim_result) {
1279        return dim_result;
1280    }
1281
1282    @Override public String forUnitArgOnly(UnitArg that,
1283                                           String unit_result) {
1284        return unit_result;
1285    }
1286
1287    @Override public String forNumberConstraintOnly(NumberConstraint that,
1288                                                    String val_result) {
1289        return val_result;
1290    }
1291
1292    @Override public String forIntRefOnly(IntRef that,
1293                                          String name_result) {
1294        return name_result;
1295    }
1296
1297    @Override public String forSumConstraintOnly(SumConstraint that,
1298                                                 String left_result,
1299                                                 String right_result) {
1300        return left_result + " + " + right_result;
1301    }
1302
1303    @Override public String forMinusConstraintOnly(MinusConstraint that,
1304                                                   String left_result,
1305                                                   String right_result) {
1306        return left_result + " - " + right_result;
1307    }
1308
1309    @Override public String forProductConstraintOnly(ProductConstraint that,
1310                                                     String left_result,
1311                                                     String right_result) {
1312        return left_result + " " + right_result;
1313    }
1314
1315    @Override public String forExponentConstraintOnly(ExponentConstraint that,
1316                                                      String left_result,
1317                                                      String right_result) {
1318        return left_result + "^" + right_result;
1319    }
1320
1321    @Override public String forBoolConstantOnly(BoolConstant that) {
1322        if ( that.isBool() ) return "true";
1323        else return "false";
1324    }
1325
1326    @Override public String forBoolRefOnly(BoolRef that,
1327                                           String name_result) {
1328        return name_result;
1329    }
1330
1331    @Override public String forNotConstraintOnly(NotConstraint that,
1332                                                 String bool_result) {
1333        return "NOT " + bool_result;
1334    }
1335
1336    @Override public String forOrConstraintOnly(OrConstraint that,
1337                                                String left_result,
1338                                                String right_result) {
1339        return left_result + " OR " + right_result;
1340    }
1341
1342    @Override public String forAndConstraintOnly(AndConstraint that,
1343                                                 String left_result,
1344                                                 String right_result) {
1345        return left_result + " AND " + right_result;
1346    }
1347
1348    @Override public String forImpliesConstraintOnly(ImpliesConstraint that,
1349                                                     String left_result,
1350                                                     String right_result) {
1351        return left_result + " IMPLIES " + right_result;
1352    }
1353
1354    @Override public String forBEConstraintOnly(BEConstraint that,
1355                                                String left_result,
1356                                                String right_result) {
1357        return left_result + " = " + right_result;
1358    }
1359
1360    @Override public String forUnitRefOnly(UnitRef that,
1361                                           String name_result) {
1362        return name_result;
1363    }
1364
1365    @Override public String forProductUnitOnly(ProductUnit that,
1366                                               String left_result,
1367                                               String right_result) {
1368        return left_result + " " + right_result;
1369    }
1370
1371    @Override public String forQuotientUnitOnly(QuotientUnit that,
1372                                                String left_result,
1373                                                String right_result) {
1374        return left_result + "/" + right_result;
1375    }
1376
1377    @Override public String forExponentUnitOnly(ExponentUnit that,
1378                                                String left_result,
1379                                                String right_result) {
1380        return left_result + "^" + right_result;
1381    }
1382
1383    @Override public String forWhereClauseOnly(WhereClause that,
1384                                               List<String> bindings_result,
1385                                               List<String> constraints_result) {
1386        if ( bindings_result.isEmpty() && constraints_result.isEmpty() )
1387            return "";
1388        StringBuilder s = new StringBuilder();
1389        s.append( "where " );
1390        if ( ! bindings_result.isEmpty() )
1391            s.append( inOxfordBrackets(bindings_result) );
1392        if ( ! constraints_result.isEmpty() )
1393            s.append( inCurlyBraces("", constraints_result) );
1394        return s.toString();
1395    }
1396
1397    @Override public String forWhereTypeOnly(WhereType that,
1398                                             String name_result,
1399                                             List<String> supers_result) {
1400        StringBuilder s = new StringBuilder();
1401        s.append( name_result );
1402        if ( ! supers_result.isEmpty() ) {
1403            s.append( inCurlyBraces("extends ", supers_result) );
1404        }
1405        return s.toString();
1406    }
1407
1408    @Override public String forWhereNatOnly(WhereNat that,
1409                                            String name_result) {
1410        return "nat " + name_result;
1411    }
1412
1413    @Override public String forWhereIntOnly(WhereInt that,
1414                                            String name_result) {
1415        return "int " + name_result;
1416    }
1417
1418    @Override public String forWhereBoolOnly(WhereBool that,
1419                                             String name_result) {
1420        return "bool " + name_result;
1421    }
1422
1423    @Override public String forWhereUnitOnly(WhereUnit that,
1424                                             String name_result) {
1425        return "unit " + name_result;
1426    }
1427
1428    @Override public String forWhereExtendsOnly(WhereExtends that,
1429                                                String name_result,
1430                                                List<String> supers_result) {
1431        StringBuilder s = new StringBuilder();
1432        s.append( name_result );
1433        if ( supers_result.isEmpty() ) {
1434            return bug(that, "A type variable constraint declared in " +
1435                       "a where clause should have its bound.");
1436        } else {
1437            s.append( inCurlyBraces("extends ", supers_result) );
1438        }
1439        return s.toString();
1440    }
1441
1442    @Override public String forTypeAliasOnly(TypeAlias that,
1443                                             String name_result,
1444                                             List<String> staticParams_result,
1445                                             String type_result) {
1446        StringBuilder s = new StringBuilder();
1447        s.append( "type " ).append( name_result );
1448        if ( ! staticParams_result.isEmpty() ) {
1449            s.append ( inOxfordBrackets(staticParams_result) );
1450        }
1451        s.append( " = " ).append( type_result );
1452        return s.toString();
1453    }
1454
1455    @Override public String forWhereCoercesOnly(WhereCoerces that,
1456                                                String left_result,
1457                                                String right_result) {
1458        StringBuilder s = new StringBuilder();
1459        s.append( left_result ).append( " coerces " ).append( right_result );
1460        return s.toString();
1461    }
1462
1463    @Override public String forWhereWidensOnly(WhereWidens that,
1464                                               String left_result,
1465                                               String right_result) {
1466        StringBuilder s = new StringBuilder();
1467        s.append( left_result ).append( " widens " ).append( right_result );
1468        return s.toString();
1469    }
1470
1471    @Override public String forWhereWidensCoercesOnly(WhereWidensCoerces that,
1472                                                      String left_result,
1473                                                      String right_result) {
1474        StringBuilder s = new StringBuilder();
1475        s.append( left_result ).append( " widens or coerces " ).append( right_result );
1476        return s.toString();
1477    }
1478
1479    @Override public String forWhereEqualsOnly(WhereEquals that,
1480                                               String left_result,
1481                                               String right_result) {
1482        StringBuilder s = new StringBuilder();
1483        s.append( left_result ).append( " = " ).append( right_result );
1484        return s.toString();
1485    }
1486
1487    @Override public String forUnitConstraintOnly(UnitConstraint that,
1488                                                  String name_result) {
1489        StringBuilder s = new StringBuilder();
1490        s.append( name_result ).append( " = dimensionless" );
1491        return s.toString();
1492    }
1493
1494    @Override public String forLEConstraintOnly(LEConstraint that,
1495                                                String left_result,
1496                                                String right_result) {
1497        StringBuilder s = new StringBuilder();
1498        s.append( left_result ).append( " <= " ).append( right_result );
1499        return s.toString();
1500    }
1501
1502    @Override public String forLTConstraintOnly(LTConstraint that,
1503                                                String left_result,
1504                                                String right_result) {
1505        StringBuilder s = new StringBuilder();
1506        s.append( left_result ).append( " < " ).append( right_result );
1507        return s.toString();
1508    }
1509
1510    @Override public String forGEConstraintOnly(GEConstraint that,
1511                                                String left_result,
1512                                                String right_result) {
1513        StringBuilder s = new StringBuilder();
1514        s.append( left_result ).append( " >= " ).append( right_result );
1515        return s.toString();
1516    }
1517
1518    @Override public String forGTConstraintOnly(GTConstraint that,
1519                                                String left_result,
1520                                                String right_result) {
1521        StringBuilder s = new StringBuilder();
1522        s.append( left_result ).append( " > " ).append( right_result );
1523        return s.toString();
1524    }
1525
1526    @Override public String forIEConstraintOnly(IEConstraint that,
1527                                                String left_result,
1528                                                String right_result) {
1529        StringBuilder s = new StringBuilder();
1530        s.append( left_result ).append( " = " ).append( right_result );
1531        return s.toString();
1532    }
1533
1534    @Override public String forBoolConstraintExprOnly(BoolConstraintExpr that,
1535                                                      String constraint_result) {
1536        return constraint_result;
1537    }
1538
1539    @Override public String forContractOnly(Contract that,
1540                                            Option<List<String>> requires_result,
1541                                            Option<List<String>> ensures_result,
1542                                            Option<List<String>> invariants_result) {
1543        StringBuilder s = new StringBuilder();
1544
1545        if (requires_result.isSome()) {
1546            List<String> requires = requires_result.unwrap();
1547            if ( ! requires.isEmpty() )
1548                s.append( inCurlyBraces("requires ", requires) ).append( "\n" );
1549        }
1550
1551        if (ensures_result.isSome()) {
1552            List<String> ensures = ensures_result.unwrap();
1553            if ( ! ensures.isEmpty() )
1554                s.append( inCurlyBraces("ensures ", ensures) ).append( "\n" );
1555        }
1556
1557        if (invariants_result.isSome()) {
1558            List<String> invariants = invariants_result.unwrap();
1559            if ( ! invariants.isEmpty() )
1560                s.append( inCurlyBraces("invariant ", invariants) ).append( "\n" );
1561        }
1562
1563        return s.toString();
1564    }
1565
1566    @Override public String forEnsuresClauseOnly(EnsuresClause that,
1567                                                 String post_result,
1568                                                 Option<String> pre_result) {
1569        StringBuilder s = new StringBuilder();
1570        s.append( post_result );
1571        if ( pre_result.isSome() ) {
1572            s.append( " provided " ).append( pre_result );
1573        }
1574        return s.toString();
1575    }
1576
1577    @Override public String forModifierAbstractOnly(ModifierAbstract that) {
1578        return "abstract";
1579    }
1580
1581    @Override public String forModifierAtomicOnly(ModifierAtomic that) {
1582        return "atomic";
1583    }
1584
1585    @Override public String forModifierGetterOnly(ModifierGetter that) {
1586        return "getter";
1587    }
1588
1589    @Override public String forModifierHiddenOnly(ModifierHidden that) {
1590        return "hidden";
1591    }
1592
1593    @Override public String forModifierIOOnly(ModifierIO that) {
1594        return "io";
1595    }
1596
1597    @Override public String forModifierOverrideOnly(ModifierOverride that) {
1598        return "override";
1599    }
1600
1601    @Override public String forModifierPrivateOnly(ModifierPrivate that) {
1602        return "private";
1603    }
1604
1605    @Override public String forModifierSettableOnly(ModifierSettable that) {
1606        return "settable";
1607    }
1608
1609    @Override public String forModifierSetterOnly(ModifierSetter that) {
1610        return "setter";
1611    }
1612
1613    @Override public String forModifierTestOnly(ModifierTest that) {
1614        return "test";
1615    }
1616
1617    @Override public String forModifierTransientOnly(ModifierTransient that) {
1618        return "transient";
1619    }
1620
1621    @Override public String forModifierValueOnly(ModifierValue that) {
1622        return "value";
1623    }
1624
1625    @Override public String forModifierVarOnly(ModifierVar that) {
1626        return "var";
1627    }
1628
1629    @Override public String forModifierWidensOnly(ModifierWidens that) {
1630        return "widens";
1631    }
1632
1633    @Override public String forModifierWrappedOnly(ModifierWrapped that) {
1634        return "wrapped";
1635    }
1636
1637    @Override public String forOpParamOnly(OpParam that,
1638                                           String name_result) {
1639        return "opr " + name_result;
1640    }
1641
1642    @Override public String forBoolParamOnly(BoolParam that,
1643                                             String name_result) {
1644        return "bool " + name_result;
1645    }
1646
1647    @Override public String forDimParamOnly(DimParam that,
1648                                            String name_result) {
1649        return "dim " + name_result;
1650    }
1651
1652    @Override public String forIntParamOnly(IntParam that,
1653                                            String name_result) {
1654        return "int " + name_result;
1655    }
1656
1657    @Override public String forNatParamOnly(NatParam that,
1658                                            String name_result) {
1659        return "nat " + name_result;
1660    }
1661
1662    @Override public String forTypeParamOnly(TypeParam that,
1663                                             String name_result,
1664                                             List<String> extendsClause_result) {
1665        StringBuilder s = new StringBuilder();
1666        s.append( name_result );
1667        if ( ! extendsClause_result.isEmpty() ) {
1668            s.append( inCurlyBraces("extends ", extendsClause_result) );
1669        }
1670        if ( that.isAbsorbs() ) {
1671            s.append( " absorbs unit" );
1672        }
1673        return s.toString();
1674    }
1675
1676    @Override public String forUnitParamOnly(UnitParam that,
1677                                             String name_result,
1678                                             Option<String> dim_result) {
1679        StringBuilder s = new StringBuilder();
1680        s.append( "unit " ).append( name_result );
1681        if ( dim_result.isSome() ) {
1682            s.append( ": " ).append( dim_result.unwrap() );
1683        }
1684        if ( that.isAbsorbs() ) {
1685            s.append( " absorbs unit" );
1686        }
1687        return s.toString();
1688    }
1689
1690    @Override public String forAPINameOnly(APIName that, List<String> ids_result) {
1691        StringBuilder s = new StringBuilder();
1692        if (IterUtil.isEmpty(ids_result))
1693            return s.toString();
1694        else {
1695            for ( String id : IterUtil.skipLast(ids_result) ){
1696                s.append( id ).append( "." );
1697            }
1698            s.append( IterUtil.last(ids_result) );
1699            return s.toString();
1700        }
1701    }
1702
1703    @Override public String forIdOnly(Id that, Option<String> api_result) {
1704        StringBuilder s = new StringBuilder();
1705        if ( api_result.isSome() )
1706            s.append( api_result.unwrap() ).append( "." );
1707        s.append( that.getText() );
1708        return s.toString();
1709    }
1710
1711    @Override public String forOpOnly(Op that,
1712                                      Option<String> api_result,
1713                                      Option<String> fixity_result) {
1714        return that.getText();
1715    }
1716
1717    @Override public String forEnclosingOnly(Enclosing that,
1718                                             Option<String> api_result,
1719                                             String open_result,
1720                                             String close_result) {
1721        StringBuilder s = new StringBuilder();
1722
1723        s.append( open_result );
1724        s.append( " " );
1725        s.append( close_result );
1726
1727        return s.toString();
1728    }
1729
1730    @Override public String forAnonymousFnNameOnly(AnonymousFnName that,
1731                                                   Option<String> api_result) {
1732        return "";
1733    }
1734
1735    @Override public String forConstructorFnNameOnly(ConstructorFnName that,
1736                                                     Option<String> api_result,
1737                                                     String def_result) {
1738        return bug(that, "Anonymous constructor names are not supported " +
1739                   "in Fortress concrete syntax.");
1740    }
1741
1742    @Override public String forArrayComprehensionClauseOnly(ArrayComprehensionClause that,
1743                                                            List<String> bind_result,
1744                                                            String init_result,
1745                                                            List<String> gens_result) {
1746        StringBuilder s = new StringBuilder();
1747        s.append( inParentheses(bind_result) );
1748        s.append( " |-> " );
1749        s.append( join(gens_result, "\n") );
1750        return s.toString();
1751    }
1752
1753    @Override public String forKeywordExprOnly(KeywordExpr that,
1754                                               String name_result,
1755                                               String init_result) {
1756        return name_result + " = " + init_result;
1757    }
1758
1759    @Override public String forCaseClauseOnly(CaseClause that,
1760                                              String match_result,
1761                                              String body_result) {
1762        return match_result + " => " + body_result;
1763    }
1764
1765    @Override public String forCatchOnly(Catch that,
1766                                         String name_result,
1767                                         List<String> clauses_result) {
1768        StringBuilder s = new StringBuilder();
1769        s.append( name_result ).append( " " );
1770        s.append( join(clauses_result, "\n") );
1771        return s.toString();
1772    }
1773
1774    @Override public String forCatchClauseOnly(CatchClause that,
1775                                               String match_result,
1776                                               String body_result) {
1777        StringBuilder s = new StringBuilder();
1778        s.append( match_result );
1779        s.append( " => " );
1780        s.append( body_result );
1781        return s.toString();
1782    }
1783
1784    @Override public String forDoFrontOnly(DoFront that,
1785                                           Option<String> loc_result,
1786                                           String expr_result) {
1787        StringBuilder s = new StringBuilder();
1788        increaseIndent();
1789
1790        if ( loc_result.isSome() ) {
1791            s.append( "at " ).append( loc_result.unwrap() ).append( " " );
1792        }
1793        if ( that.isAtomic() ) {
1794            s.append( "atomic " );
1795        }
1796        s.append( "do\n" ).append( indent(expr_result) );
1797
1798        decreaseIndent();
1799
1800        return s.toString();
1801    }
1802
1803    @Override public String forIfClauseOnly(IfClause that,
1804                                            String test_result,
1805                                            String body_result) {
1806        StringBuilder s = new StringBuilder();
1807
1808        s.append( test_result );
1809        s.append( " then\n" );
1810        increaseIndent();
1811        s.append( indent(body_result) ).append( "\n" );
1812        decreaseIndent();
1813
1814        return s.toString();
1815    }
1816
1817    @Override public String forTypecaseClauseOnly(TypecaseClause that,
1818                                                  List<String> match_result,
1819                                                  String body_result) {
1820        StringBuilder s = new StringBuilder();
1821        s.append( inParentheses(match_result) );
1822        s.append( " => " );
1823        s.append( body_result );
1824        return s.toString();
1825    }
1826
1827    /* Possible differences in the original Fortress program and
1828       the unparsed program.
1829       In the Fortress source program, either "#" or ":" may be used.
1830       In AST, only "#" is used.
1831       In the Fortress source program, either "#size" or "size" may be used.
1832       In AST, only "#size" is used.
1833     */
1834    @Override public String forExtentRangeOnly(ExtentRange that,
1835                                               Option<String> base_result,
1836                                               Option<String> size_result) {
1837        StringBuilder s = new StringBuilder();
1838
1839        if ( base_result.isSome() ){
1840            s.append( base_result.unwrap() );
1841        }
1842        s.append( "#" );
1843        if ( size_result.isSome() ){
1844            s.append( size_result.unwrap() );
1845        }
1846
1847        return s.toString();
1848    }
1849
1850    @Override public String forGeneratorClauseOnly(GeneratorClause that,
1851                                                   List<String> bind_result,
1852                                                   String init_result) {
1853        StringBuilder s = new StringBuilder();
1854
1855        if ( ! bind_result.isEmpty() ) {
1856            if ( bind_result.size() == 1 ) {
1857                s.append( bind_result.get(0) );
1858            } else {
1859                s.append( inParentheses(bind_result) );
1860            }
1861            s.append( " <- " );
1862        }
1863        s.append( init_result );
1864
1865        return s.toString();
1866    }
1867
1868    @Override public String forVarargsExprOnly(VarargsExpr that,
1869                                               String varargs_result) {
1870        return varargs_result + "...";
1871    }
1872
1873    @Override public String forKeywordTypeOnly(KeywordType that,
1874                                               String name_result,
1875                                               String type_result) {
1876        return name_result + " = " + type_result;
1877    }
1878
1879//    @Override public String forTraitTypeWhereOnly( that,
1880
1881    @Override public String forIndicesOnly(Indices that,
1882                                           List<String> extents_result) {
1883        StringBuilder s = new StringBuilder();
1884
1885        s.append( join(extents_result, ", ") );
1886
1887        return s.toString();
1888    }
1889
1890//    @Override public String forParenthesisDelimitedMIOnly( that,
1891//    @Override public String forNonParenthesisDelimitedMIOnly( that,
1892//    @Override public String forExponentiationMIOnly( that,
1893//    @Override public String forSubscriptingMIOnly( that,
1894
1895    @Override public String forInFixityOnly(InFixity that) {
1896        return "";
1897    }
1898
1899    @Override public String forPreFixityOnly(PreFixity that) {
1900        return "";
1901    }
1902
1903    @Override public String forPostFixityOnly(PostFixity that) {
1904        return "";
1905    }
1906
1907    @Override public String forNoFixityOnly(NoFixity that) {
1908        return "";
1909    }
1910
1911    @Override public String forMultiFixityOnly(MultiFixity that) {
1912        return "";
1913    }
1914
1915    @Override public String forEnclosingFixityOnly(EnclosingFixity that) {
1916        return "";
1917    }
1918
1919    @Override public String forBigFixityOnly(BigFixity that) {
1920        return "";
1921    }
1922
1923    @Override public String forLinkOnly(Link that,
1924                                        String op_result,
1925                                        String expr_result) {
1926        StringBuilder s = new StringBuilder();
1927        s.append( " " ).append( op_result ).append( " " ).append( expr_result );
1928        return s.toString();
1929    }
1930}
Note: See TracBrowser for help on using the browser.