← Back to branch summary

~ubuntu-branches/ubuntu/raring/babel/raring-proposed

« back to all changes in this revision

Viewing changes to compiler/gov/llnl/babel/visitor/DumpVisitor.java

  • Committer: Bazaar Package Importer
  • Author(s): Adam C. Powell, IV
  • Date: 2008-08-01 07:56:58 UTC
  • mfrom: (3.1.2 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080801075658-9ezcrbh8dcs8lg70
Tags: 1.2.0.dfsg-6
http://bugs.debian.org/483324
Added libparsifal-dev as dependency to libsidl-dev (closes: #483324).

Show diffs side-by-side

added added

removed removed

Lines of Context:
compiler/gov/llnl/babel/visitor/DumpVisitor.java
 
1
package gov.llnl.babel.visitor;
 
2
 
 
3
import gov.llnl.babel.ast.ASTNode;
 
4
import gov.llnl.babel.ast.Argument;
 
5
import gov.llnl.babel.ast.ArgumentList;
 
6
import gov.llnl.babel.ast.ArrayType;
 
7
import gov.llnl.babel.ast.Assertion;
 
8
import gov.llnl.babel.ast.Attribute;
 
9
import gov.llnl.babel.ast.AttributeList;
 
10
import gov.llnl.babel.ast.BinaryExpr;
 
11
import gov.llnl.babel.ast.BooleanLiteral;
 
12
import gov.llnl.babel.ast.CharacterLiteral;
 
13
import gov.llnl.babel.ast.ClassType;
 
14
import gov.llnl.babel.ast.DComplexLiteral;
 
15
import gov.llnl.babel.ast.DoubleLiteral;
 
16
import gov.llnl.babel.ast.Ensures;
 
17
import gov.llnl.babel.ast.EnumItem;
 
18
import gov.llnl.babel.ast.Enumeration;
 
19
import gov.llnl.babel.ast.Extents;
 
20
import gov.llnl.babel.ast.FComplexLiteral;
 
21
import gov.llnl.babel.ast.FixedType;
 
22
import gov.llnl.babel.ast.FloatLiteral;
 
23
import gov.llnl.babel.ast.FromClause;
 
24
import gov.llnl.babel.ast.FuncExpr;
 
25
import gov.llnl.babel.ast.ImportClause;
 
26
import gov.llnl.babel.ast.IntLiteral;
 
27
import gov.llnl.babel.ast.InterfaceType;
 
28
import gov.llnl.babel.ast.Method;
 
29
import gov.llnl.babel.ast.Name;
 
30
import gov.llnl.babel.ast.Package;
 
31
import gov.llnl.babel.ast.RArrayType;
 
32
import gov.llnl.babel.ast.RequireClause;
 
33
import gov.llnl.babel.ast.Requires;
 
34
import gov.llnl.babel.ast.SIDLFile;
 
35
import gov.llnl.babel.ast.ScopedID;
 
36
import gov.llnl.babel.ast.SplicerBlock;
 
37
import gov.llnl.babel.ast.SplicerImpl;
 
38
import gov.llnl.babel.ast.SplicerImplList;
 
39
import gov.llnl.babel.ast.SplicerList;
 
40
import gov.llnl.babel.ast.StringLiteral;
 
41
import gov.llnl.babel.ast.StructItem;
 
42
import gov.llnl.babel.ast.StructType;
 
43
import gov.llnl.babel.ast.ThrowsList;
 
44
import gov.llnl.babel.ast.UnaryExpr;
 
45
 
 
46
import java.io.PrintStream;
 
47
import java.util.Iterator;
 
48
 
 
49
/**
 
50
 * PrettyPrints a SIDL AST to a PrintStream (useful for development and
 
51
 * debugging)
 
52
 */
 
53
public class DumpVisitor extends Visitor {
 
54
 
 
55
  protected PrintStream d_out;
 
56
 
 
57
  private int d_indent = 0;
 
58
 
 
59
  public DumpVisitor(PrintStream ps) {
 
60
    super();
 
61
    d_out = ps;
 
62
  }
 
63
 
 
64
  private String indentString() {
 
65
    StringBuffer sb = new StringBuffer();
 
66
    for (int i = 0; i < d_indent; ++i) {
 
67
      sb.append("    ");
 
68
    }
 
69
    return sb.toString();
 
70
  }
 
71
 
 
72
  private void printAttributes(AttributeList attrs, boolean withIndent) { 
 
73
    if ( attrs == null ) { return; }
 
74
    if ( withIndent) { 
 
75
      d_out.print(indentString());
 
76
    }
 
77
    boolean inAttribRun = false;
 
78
    for( Iterator i = attrs.iterator(); i.hasNext(); ) {
 
79
      Attribute a = (Attribute) i.next();
 
80
      if ( a.isBuiltin() ) { 
 
81
        if ( inAttribRun ) { 
 
82
          d_out.print(" }");
 
83
        }
 
84
        inAttribRun = false;
 
85
      } else { 
 
86
        if ( inAttribRun ) { 
 
87
          d_out.print(",");
 
88
        } else {
 
89
          d_out.print(" %attrib{");
 
90
        }
 
91
        inAttribRun = true;
 
92
      }
 
93
      d_out.print(" " + a);
 
94
    }
 
95
    if ( inAttribRun ) { 
 
96
      d_out.print(" } ");
 
97
    } else { 
 
98
      d_out.print(" ");
 
99
    }
 
100
  }
 
101
  
 
102
  public Object visitSIDLFile(SIDLFile node, Object data) {
 
103
    d_out.println(indentString() + "-------------- begin ("
 
104
                  + node.getFilename() + ")-----------");
 
105
    super.visitSIDLFile(node, data);
 
106
    d_out.println(indentString() + "---------------end file--------------");
 
107
    return data;
 
108
  }
 
109
 
 
110
  public Object visitImportClause(ImportClause node, Object data) {
 
111
    d_out.print(indentString() + "import " + node.getScopedID());
 
112
    if ((node.getVersion() != null)
 
113
        && (node.getVersion().toString().length() > 0)) {
 
114
      d_out.print(" version " + node.getVersion());
 
115
    }
 
116
    d_out.println(";");
 
117
    return data;
 
118
  }
 
119
 
 
120
  public Object visitRequireClause(RequireClause node, Object data) {
 
121
    d_out.print(indentString() + "require " + node.getScopedID());
 
122
    if (node.getVersion().toString().length() > 0) {
 
123
      d_out.print(" version " + node.getVersion());
 
124
    }
 
125
    d_out.println(";");
 
126
    return data;
 
127
  }
 
128
 
 
129
  public Object visitPackage(Package node, Object data) {
 
130
    if (node.hasDocComment()) { 
 
131
      d_out.println("/** " + node.getDocComment() +  "*/");
 
132
    }
 
133
    if ( node.getAttributeList() != null ) { 
 
134
      final boolean withIndent = true;
 
135
      printAttributes( node.getAttributeList(), withIndent );
 
136
    }
 
137
    d_out.print("package " + node.getName());
 
138
    if (node.getVersion() != null
 
139
        && node.getVersion().toString().length() > 0) {
 
140
      d_out.print(" version " + node.getVersion());
 
141
    }
 
142
    d_out.println(" {");
 
143
    d_indent++;
 
144
    super.visitPackage(node, data);
 
145
    d_indent--;
 
146
    d_out.println(indentString() + "}");
 
147
    return data;
 
148
  }
 
149
  
 
150
  public Object visitEnumeration( Enumeration node, Object data ) {
 
151
    if (node.hasDocComment()) { 
 
152
      d_out.println("/** " +node.getDocComment()+  "*/");
 
153
    }
 
154
    printAttributes( node.getAttributeList(), true );
 
155
    d_out.println("enum " + node.getName() + " {");
 
156
    d_indent++;
 
157
    super.visitEnumeration(node, data);
 
158
    d_indent--;
 
159
    d_out.println(indentString() + "}");
 
160
    return data;
 
161
  }
 
162
  
 
163
  public Object visitEnumItem( EnumItem node, Object data ) { 
 
164
    d_out.println( indentString() + node.toString() + ", ");
 
165
    return data;
 
166
  }
 
167
 
 
168
  public Object visitStructType( StructType node, Object data ) { 
 
169
    if (node.hasDocComment()) { 
 
170
      d_out.println("/** " +node.getDocComment()+  "*/");
 
171
    }
 
172
    d_out.println(indentString() + "struct " + node.getName() + " {");
 
173
    d_indent++;
 
174
    super.visitStructType(node,data);
 
175
    d_indent--;
 
176
    d_out.println(indentString() + "}");
 
177
    return data;
 
178
  }
 
179
  
 
180
  public Object visitStructItem( StructItem node, Object data) { 
 
181
    d_out.println(indentString() + node.getType() + " " + node.getName() + ";");
 
182
    return data;
 
183
  }
 
184
  
 
185
  public Object visitInterfaceType(InterfaceType node, Object data) {
 
186
    if (node.hasDocComment()) { 
 
187
      d_out.println("/** " +node.getDocComment()+  "*/");
 
188
    }
 
189
    final boolean withIndent = true;
 
190
    printAttributes( node.getAttributeList(), withIndent );
 
191
    d_out.print("interface " + node.getName());
 
192
    if ( node.getExtends().size() > 0 ) { 
 
193
      d_out.print(" extends");
 
194
      for( Iterator it = node.getExtends().iterator(); it.hasNext(); ) { 
 
195
        d_out.print( " " + (ScopedID) it.next() );
 
196
      }
 
197
    }
 
198
    d_out.println(" {");
 
199
    d_indent++;
 
200
    super.visitInterfaceType(node, data);
 
201
    d_indent--;
 
202
    d_out.println(indentString() + "}");
 
203
    return data;
 
204
  }
 
205
 
 
206
  public Object visitClassType(ClassType node, Object data) {
 
207
    if (node.hasDocComment()) { 
 
208
      d_out.println("/** " +node.getDocComment()+  "*/");
 
209
    }
 
210
    final boolean withIndent = true;
 
211
    printAttributes( node.getAttributeList(), withIndent );
 
212
    d_out.print("class " + node.getName());
 
213
    if ( node.getExtends() != null ) {
 
214
      d_out.print(" extends " + node.getExtends() );
 
215
    }
 
216
    if ( node.getImplementsList() != null && node.getImplementsList().size() > 0 ) { 
 
217
      Iterator it = node.getImplementsList().iterator();
 
218
      int state=2;
 
219
      while( it.hasNext() ) { 
 
220
        ScopedID iface = (ScopedID) it.next();
 
221
        if ( node.getImplementsList().isImplementsAll(iface) ) { 
 
222
          if (state==1) { 
 
223
            d_out.print(", ");
 
224
          } else { 
 
225
            d_out.print(" implements-all ");
 
226
          }
 
227
          state=1;
 
228
        } else { 
 
229
          if (state==0) { 
 
230
            d_out.print(", ");
 
231
          } else { 
 
232
            d_out.print(" implements ");
 
233
          }
 
234
          state=0;
 
235
        }
 
236
        d_out.print( iface.toString() );
 
237
      } // end while
 
238
    }
 
239
    d_out.println(" {");
 
240
    d_indent++;
 
241
    super.visitClassType(node, data);
 
242
    d_indent--;
 
243
    d_out.println(indentString() + "}");
 
244
    return data;
 
245
  }
 
246
  
 
247
  public Object visitMethod(Method node, Object data) {
 
248
    if (node.hasDocComment()) { 
 
249
      d_out.println("/** " +node.getDocComment()+  "*/");
 
250
    }
 
251
    final boolean withIndent = true;
 
252
    printAttributes( node.getAttributeList(), withIndent);
 
253
    if (node.getReturnType() == null) { 
 
254
      d_out.print("void ");
 
255
    } else { 
 
256
      d_out.print(node.getReturnType().toString() + " ");
 
257
    }
 
258
    d_out.print(node.getMethodName().toString());
 
259
    node.getArgumentList().accept(this,data);
 
260
    node.getThrowsList().accept(this,data);
 
261
    if ( node.getFromClause() != null ) { 
 
262
      node.getFromClause().accept(this,data);
 
263
    }
 
264
    if (node.getRequires() != null) {
 
265
      d_out.println();
 
266
      node.getRequires().accept(this, data);
 
267
    }
 
268
    if (node.getEnsures() != null ) {
 
269
      d_out.println();
 
270
      node.getEnsures().accept(this, data);
 
271
    }
 
272
    if ((node.getRequires() != null) || (node.getEnsures() != null)) {
 
273
      d_out.println(indentString() + ";");
 
274
    }
 
275
    else{
 
276
      d_out.println(";");
 
277
    }
 
278
    if (node.getSplicerList() != null) {
 
279
      node.getSplicerList().accept(this, data);
 
280
    }
 
281
    return data;
 
282
  }
 
283
  
 
284
  public Object visitArgumentList(ArgumentList node, Object data ) { 
 
285
    d_out.print("(");
 
286
    for(Iterator it = node.iterator(); it.hasNext(); ) { 
 
287
      Argument arg = (Argument) it.next();
 
288
      arg.accept(this,data);
 
289
      if (it.hasNext()) { 
 
290
        d_out.print(", ");
 
291
      }
 
292
    }
 
293
    d_out.print(")");
 
294
    return data;
 
295
  }
 
296
 
 
297
  public Object visitArgument(Argument node, Object data) { 
 
298
    if (node.hasDocComment()) { 
 
299
      d_out.println("/** " +node.getDocComment()+  "*/");
 
300
    }
 
301
    if ( node.getAttributeList() != null ) { 
 
302
      final boolean withIndent=false;
 
303
      printAttributes( node.getAttributeList(), withIndent );
 
304
    }
 
305
    d_out.print( node.getMode() + " ");
 
306
    node.getType().accept(this,data);
 
307
    d_out.print(" " + node.getName() );
 
308
    if ( node.getType() instanceof RArrayType) { 
 
309
      RArrayType t = (RArrayType) node.getType();
 
310
      d_out.print("(");
 
311
      t.getExtents().accept(this,data);
 
312
      d_out.print(")");
 
313
    }
 
314
    return data;
 
315
  }
 
316
 
 
317
  public Object visitBinaryExpr(BinaryExpr be, Object data) {
 
318
    d_out.print("(");
 
319
    be.getLHS().accept(this, data);
 
320
    d_out.print(")" + BinaryExpr.getOpSIDL(be.getOperator()));
 
321
    d_out.print("(");
 
322
    be.getRHS().accept(this, data);
 
323
    d_out.print(")");
 
324
    return data;
 
325
  }
 
326
 
 
327
  public Object visitUnaryExpr(UnaryExpr ue, Object data) {
 
328
    d_out.print(UnaryExpr.getOpSIDL(ue.getOperator()));
 
329
    d_out.print("(");
 
330
    ue.getOperand().accept(this, data);
 
331
    d_out.print(")");
 
332
    return data;
 
333
  }
 
334
 
 
335
  
 
336
  public Object visitExtents(Extents node, Object data) { 
 
337
    for(Iterator it = node.getExtents().iterator(); it.hasNext(); ) { 
 
338
      ASTNode n = (ASTNode) it.next();
 
339
      n.accept(this, data);
 
340
      if (it.hasNext()) { 
 
341
        d_out.print(", ");
 
342
      }
 
343
    }
 
344
    return data;
 
345
  }
 
346
  
 
347
  public Object visitFixedType(FixedType node, Object data) { 
 
348
    d_out.print(node.toString());
 
349
    return data;
 
350
  }
 
351
  
 
352
  public Object visitArrayType(ArrayType node, Object data) { 
 
353
    d_out.print(node.toString());
 
354
    return data;
 
355
  }
 
356
  
 
357
  public Object visitRArrayType(RArrayType node, Object data) {
 
358
    d_out.print(node.toString());
 
359
    return data;
 
360
  }
 
361
  
 
362
  public Object visitScopedID(ScopedID node, Object data) { 
 
363
    d_out.print(node.toString());
 
364
    return data;
 
365
  }
 
366
  
 
367
  public Object visitThrowsList(ThrowsList node, Object data) { 
 
368
    if (node.size() > 0) { 
 
369
      d_out.print(" throws ");
 
370
      for(Iterator it = node.iterator(); it.hasNext(); ) { 
 
371
        ScopedID id = (ScopedID) it.next();
 
372
        id.accept(this,data);
 
373
        if (it.hasNext()) { 
 
374
          d_out.print(", ");
 
375
        }
 
376
      }
 
377
    }
 
378
    return data;
 
379
  }
 
380
  
 
381
  public Object visitFromClause(FromClause node, Object data) { 
 
382
    if (node != null) { 
 
383
      d_out.print(" from " + node.getScopedID() + "." + node.getMethodName() );        
 
384
    }
 
385
    return data;
 
386
  }
 
387
 
 
388
  public Object visitIntLiteral(IntLiteral il, Object data) {
 
389
    d_out.print(Integer.toString(il.getInt()));
 
390
    return data;
 
391
  }
 
392
 
 
393
  public Object visitBooleanLiteral(BooleanLiteral bl, Object data)
 
394
  {
 
395
    d_out.print(bl.getBoolean() ? "true" : "false");
 
396
    return data;
 
397
  }
 
398
 
 
399
  public Object visitCharacterLiteral(CharacterLiteral cl, Object data)
 
400
  {
 
401
    char ch = cl.getChar();
 
402
    if (Character.isISOControl(ch) || (ch == '\'') || (ch == '\\')) {
 
403
      d_out.print("'\\" + Integer.toOctalString(Character.getNumericValue(ch))
 
404
                  + "'");
 
405
    }
 
406
    else {
 
407
      d_out.print("'" + ch + "'");
 
408
    }
 
409
    return data;
 
410
  }
 
411
 
 
412
  public Object visitStringLiteral(StringLiteral sl, Object data)
 
413
  {
 
414
    d_out.print("\"" + sl.getString() + "\"");
 
415
    return data;
 
416
  }
 
417
 
 
418
  public Object visitFComplexLiteral(FComplexLiteral dl, Object data)
 
419
  {
 
420
    d_out.print(dl.toString());
 
421
    return data;
 
422
  }
 
423
 
 
424
  public Object visitDComplexLiteral(DComplexLiteral dl, Object data)
 
425
  {
 
426
    d_out.print(dl.toString());
 
427
    return data;
 
428
  }
 
429
 
 
430
  public Object visitFloatLiteral(FloatLiteral dl, Object data)
 
431
  {
 
432
    d_out.print(dl.toString());
 
433
    return data;
 
434
  }
 
435
 
 
436
  public Object visitDoubleLiteral(DoubleLiteral dl, Object data)
 
437
  {
 
438
    d_out.print(dl.toString());
 
439
    return data;
 
440
  }
 
441
 
 
442
  public Object visitEnsures(Ensures r, Object data) {
 
443
    d_out.println(indentString() + "ensures");
 
444
    try {
 
445
      ++d_indent;
 
446
      return super.visitEnsures(r, data);
 
447
    }
 
448
    finally {
 
449
      --d_indent;
 
450
    }
 
451
  }
 
452
 
 
453
  public Object visitRequires(Requires r, Object data) {
 
454
    d_out.println(indentString() + "requires");
 
455
    try {
 
456
      ++d_indent;
 
457
      return super.visitRequires(r, data);
 
458
    }
 
459
    finally {
 
460
      --d_indent;
 
461
    }
 
462
  }
 
463
 
 
464
  public Object visitFuncExpr(FuncExpr fe, Object data) {
 
465
    d_out.print(fe.getName() + "(");
 
466
    Iterator i = fe.getArguments().iterator();
 
467
    while(i.hasNext()) {
 
468
      ((ASTNode)i.next()).accept(this, data);
 
469
      if (i.hasNext()) {
 
470
        d_out.print(", ");
 
471
      }
 
472
    }
 
473
    d_out.print(")");
 
474
    return data;
 
475
  }
 
476
 
 
477
  public Object visitName(Name n, Object data) {
 
478
    d_out.print(n.toString());
 
479
    return data;
 
480
  }
 
481
 
 
482
  public Object visitAssertion(Assertion a, Object data)
 
483
  {
 
484
    d_out.print(indentString());
 
485
    if (a.getName() != null) {
 
486
      a.getName().accept(this, data);
 
487
      d_out.print(":");
 
488
    }
 
489
    Object retval = a.getExpr().accept(this, data);
 
490
    d_out.println(";");
 
491
    return retval;
 
492
  }
 
493
 
 
494
  public Object visitSplicerList(SplicerList sl, Object data) 
 
495
  {
 
496
    d_indent++;
 
497
    for (Iterator i = sl.getList().iterator(); i.hasNext();) {
 
498
      SplicerBlock sb = (SplicerBlock) i.next();
 
499
      sb.accept(this, data);
 
500
    }
 
501
    d_indent--;
 
502
    return data;
 
503
  }
 
504
  
 
505
  public Object visitSplicerBlock(SplicerBlock sb, Object data) 
 
506
  {
 
507
    d_out.print(indentString() + "/** Splicer Block (tagged " + sb.getName());
 
508
    d_out.println(" in " + sb.getLocation() + ") */");
 
509
    if (sb.getSplicerImplList() != null) {
 
510
      sb.getSplicerImplList().accept(this, data);
 
511
    }
 
512
    d_out.println();
 
513
    return data;
 
514
  }
 
515
 
 
516
  public Object visitSplicerImplList(SplicerImplList sil, Object data) 
 
517
  {
 
518
    for (Iterator i = sil.getList().iterator(); i.hasNext();) {
 
519
      SplicerImpl si = (SplicerImpl) i.next();
 
520
      si.accept(this, data);
 
521
    }
 
522
    return data;
 
523
  }
 
524
  
 
525
  public Object visitSplicerImpl(SplicerImpl impl, Object data) 
 
526
  {
 
527
    d_out.println(indentString() + impl.toString());
 
528
    return data;
 
529
  }
 
530
 
 
531
}