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

Revision 2402, 71.6 KB (checked in by jon, 16 months ago)

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