|
1
19
20 package gcc.generator;
21
22 import gcc.generator.Generator;
23 import gcc.generator.GenOptions;
24
25 import java.util.Vector;
26 import java.util.Date;
27 import java.text.SimpleDateFormat;
28 import java.lang.reflect.Modifier;
29 import java.io.File;
30
31 public class JavaGenerator implements Generator
32 {
33 protected GenOptions _genOptions;
34
35 public JavaGenerator(GenOptions genOptions)
36 {
37 _genOptions = genOptions;
38 }
39
40 public GenOptions getGenOptions()
41 {
42 return _genOptions;
43 }
44
45 public void setGenOptions(GenOptions genOptions)
46 {
47 _genOptions = genOptions;
48 }
49
50 public void generate( JEntity e )
51 {
52 }
54
55 public void generate( JPackage p )
56 throws GenException
57 {
58 if (p == null)
59 {
60 return;
61 }
62
63 Vector v = p.getClasses();
64
65 if (v != null && v.size() > 0)
66 {
67 int i;
68 for( i=0; i<v.size(); i++ )
69 {
70 generate( (JClass)v.elementAt(i) );
71 }
72 }
73 }
74
75 public void generate( JClass c )
76 throws GenException
77 {
78 if (c == null)
79 {
80 return;
81 }
82
83 String className = c.getName();
84 String pkgName = c.getPackage().getName();
85
86 pkgName = pkgName.replace( '.', File.separatorChar );
87
88 String fullName = pkgName + "/" + className;
89
90 JavaWriter jw = new JavaWriter( _genOptions, fullName, ".java" );
91
92 jw.openFile();
93 writeClass( jw, c );
94 jw.closeFile();
95 }
96
97 protected void writeClass( JavaWriter jw, JClass c )
98 {
99 writeClassPackage( jw, c );
100 writeClassImports( jw, c);
101
102 writeClassClassDefn( jw, c);
103 jw.begin();
104 writeClassFields( jw, c);
105 writeClassConstructors( jw, c );
106 writeClassMethods( jw, c);
107 jw.end();
108 }
109
110 protected void writeClassPackage( JavaWriter jw, JClass c )
111 {
112 if (c.getPackage().getName().length() > 0)
113 {
114 jw.newln();
115 jw.println( "package " + c.getPackage().getName() + ";" );
116 }
117 }
118
119 protected void writeClassImports( JavaWriter jw, JClass c )
120 {
121 Vector v = c.getImports();
122 if (v != null && v.size() > 0)
123 {
124 int i;
125
126 jw.newln();
127
128 for( i=0; i<v.size(); i++ )
129 {
130 jw.println( "import " + v.elementAt(i) + ";" );
131 }
132 }
133 }
134
135 protected void writeClassClassDefn( JavaWriter jw, JClass c )
136 {
137 jw.newln();
138
139 writeModifiers( jw, c.getModifiers() );
140 jw.println( "class " + c.getName() );
141
142 if (c.getExtends() != null && c.getExtends().length() > 0)
143 {
144 jw.indent();
145 jw.println( "extends " + c.getBaseClassName() );
146 jw.outdent();
147 }
148
149 Vector v = c.getImplements();
150 if (v != null && v.size() > 0)
151 {
152 int i;
153
154 jw.indent();
155 jw.print( "implements ");
156 jw.outdent();
157
158 for( i=0; i<v.size(); i++ )
159 {
160 jw.print( "" + v.elementAt(i) );
161
162 if ( i+1 != v.size() )
163 {
164 jw.print( ", " );
165 }
166 }
167 jw.println( "" );
168 }
169 }
170
171 protected void writeClassFields( JavaWriter jw, JClass c )
172 {
173 Vector v = c.getFields();
174 if (v != null && v.size() > 0)
175 {
176 jw.comment( "" );
177 jw.comment( "Fields" );
178 jw.comment( "" );
179
180 int i;
181 JField f;
182 for( i=0; i<v.size(); i++ )
183 {
184 f = (JField) v.elementAt(i);
185 writeClassField( jw, c, f );
186 }
187 }
188 }
189
190 protected void writeClassField( JavaWriter jw, JClass c, JField f )
191 {
192 writeModifiers( jw, f.getModifiers() );
193 jw.print( f.getTypeDecl() + " " + f.getName() );
194
195 if (f.getInitExpression() != null)
196 {
197 jw.print( " = " );
198 writeExpression( jw, f.getInitExpression() );
199 }
200
201 jw.println( ";" );
202 }
203
204 protected void writeClassConstructors( JavaWriter jw, JClass c )
205 {
206 Vector v = c.getConstructors();
207 if (v != null && v.size() > 0)
208 {
209 int i;
210 JMethod m;
211
212 jw.newln();
213
214 jw.comment( "" );
215 jw.comment( "Constructors" );
216 jw.comment( "" );
217
218 for( i=0; i<v.size(); i++ )
219 {
220 m = (JMethod) v.elementAt(i);
221 writeClassMethod( jw, c, m );
222 }
223 }
224 }
225
226 protected void writeClassMethods( JavaWriter jw, JClass c )
227 {
228 Vector v = c.getMethods();
229 if (v != null && v.size() > 0)
230 {
231 int i;
232 JMethod m;
233
234 jw.newln();
235
236 jw.comment( "" );
237 jw.comment( "Methods" );
238 jw.comment( "" );
239
240 for( i=0; i<v.size(); i++ )
241 {
242 jw.newln();
243 m = (JMethod) v.elementAt(i);
244 writeClassMethod( jw, c, m );
245 }
246 }
247 }
248
249 protected void writeClassMethod( JavaWriter jw, JClass c, JMethod m )
250 {
251 writeModifiers( jw, m.getModifiers() );
252
253 if (m instanceof JConstructor)
254 {
255 jw.print( c.getName() );
256 }
257 else
258 {
259 jw.print( m.getRT().getTypeName() );
261
262 if (m.getRT().isArray())
263 {
264 jw.print( "[]" );
265 }
266
267 jw.print( " " + m.getName() );
268 }
269 jw.print( "(" );
270
271 JParameter p[] = m.getParms();
272 if (p != null && p.length > 0)
273 {
274 int i;
275 for( i=0; i<p.length; i++ )
276 {
277 jw.print( " " + p[i].getTypeDecl() + " " + p[i].getName() );
278
279 if (i+1 != p.length)
280 {
281 jw.print( "," );
282 }
283 }
284 }
285
286 jw.print( " )" );
287
288 Class s[] = m.getThrown();
290 if (s != null && s.length > 0)
291 {
292 int i;
293
294 jw.print( " throws " );
295
296 for( i=0; i<s.length; i++ )
297 {
298 jw.print( s[i].getName() );
299
300 if (i+1 != s.length)
301 {
302 jw.print( ", " );
303 }
304 }
305 }
306 jw.println( "" );
307
308 jw.begin();
309 writeLocalVariables( jw, m.getLocalVariables() );
310 writeStatements( jw, m.getStatements() );
311
312 if (m.getBody() != null && m.getBody().length() > 0)
313 {
314 jw.println( m.getBody() );
315 }
316 jw.end();
317 }
318
319 protected void writeLocalVariables( JavaWriter jw, Vector lv )
320 {
321 if (lv != null && lv.size() > 0)
322 {
323 int i;
324 for( i=0; i<lv.size(); i++ )
325 {
326 writeLocalVariable( jw, (JLocalVariable)lv.elementAt(i) );
327 }
328 }
329 }
330
331 protected void writeLocalVariable( JavaWriter jw, JLocalVariable lv )
332 {
333 jw.print( lv.getTypeDecl() + " " + lv.getName() );
334
335 if (lv.getInitExpression() != null)
336 {
337 jw.print( " = " );
338 writeExpression( jw, lv.getInitExpression() );
339 }
340
341 jw.println( ";" );
342 }
343
344 protected void writeStatements( JavaWriter jw, Vector sv )
345 {
346 if (sv != null && sv.size() > 0)
347 {
348 int i;
349 for( i=0; i<sv.size(); i++ )
350 {
351 writeStatement( jw, (JStatement)sv.elementAt(i) );
352 }
353 }
354 }
355
356 protected void writeModifiers( JavaWriter jw, int m )
357 {
358 String s = Modifier.toString( m );
359
360 if (s != null && s.length() > 0)
361 {
362 jw.print( s + " " );
363 }
364 }
365
366 protected void writeStatement( JavaWriter jw, JStatement s )
367 {
368 if (s instanceof JCaseStatement)
369 {
370 writeCaseStatement( jw, (JCaseStatement)s );
371 }
372 else if (s instanceof JCatchStatement)
373 {
374 writeCatchStatement( jw, (JCatchStatement)s );
375 }
376 else if (s instanceof JCodeStatement)
377 {
378 writeCodeStatement( jw, (JCodeStatement)s, true );
379 }
380 else if (s instanceof JDeclareStatement)
381 {
382 writeDeclareStatement( jw, (JDeclareStatement)s );
383 }
384 else if (s instanceof JElseStatement)
385 {
386 writeElseStatement( jw, (JElseStatement)s );
387 }
388 else if (s instanceof JElseIfStatement)
389 {
390 writeElseIfStatement( jw, (JElseIfStatement)s );
391 }
392 else if (s instanceof JIfElseIfElseStatement)
393 {
394 writeIfElseIfElseStatement( jw, (JIfElseIfElseStatement)s );
395 }
396 else if (s instanceof JFinallyStatement)
397 {
398 writeFinallyStatement( jw, (JFinallyStatement)s );
399 }
400 else if (s instanceof JForStatement)
401 {
402 writeForStatement( jw, (JForStatement)s );
403 }
404 else if (s instanceof JIfStatement)
405 {
406 writeIfStatement( jw, (JIfStatement)s );
407 }
408 else if (s instanceof JTryCatchFinallyStatement)
409 {
410 writeTryCatchFinallyStatement( jw, (JTryCatchFinallyStatement)s );
411 }
412 else if (s instanceof JSwitchStatement)
413 {
414 writeSwitchStatement( jw, (JSwitchStatement)s );
415 }
416 else if (s instanceof JTryStatement)
417 {
418 writeTryStatement( jw, (JTryStatement)s );
419 }
420 else if (s instanceof JBlockStatement)
421 {
422 writeBlockStatement( jw, (JBlockStatement)s );
424 }
425 else
426 {
427 jw.comment( "" );
428 jw.comment( "Error: Unknown statement: " + s );
429 jw.comment( "" );
430 }
431 }
432
433 protected void writeBlockStatement( JavaWriter jw, JBlockStatement bs )
434 {
435 jw.begin();
436 writeLocalVariables( jw, bs.getLocalVariables() );
437 writeStatements( jw, bs.getStatements() );
438 jw.end();
439 }
440
441 protected void writeCaseStatement( JavaWriter jw, JCaseStatement cs )
442 {
443 jw.print( "case " );
444 writeExpression( jw, cs.getExpression() );
445 jw.println( ":" );
446 writeStatement( jw, cs.getStatement() );
447 jw.println( "break;" );
448 }
449
450 protected void writeCatchStatement( JavaWriter jw, JCatchStatement cs )
451 {
452 jw.println( "catch( " + cs.getVariable().getTypeDecl() + " " + cs.getVariable().getName() + " )" );
453 writeBlockStatement( jw, cs );
454 }
456
457 protected void writeCodeStatement( JavaWriter jw, JCodeStatement cs, boolean newLine )
458 {
459 jw.print( cs.getCode() );
460
461 if (newLine)
462 {
463 jw.newln();
464 }
465
466 }
469
470 protected void writeDeclareStatement( JavaWriter jw, JDeclareStatement ds )
471 {
472 JVariable v = ds.getVariable();
473 jw.print( v.getTypeDecl() + " " + v.getName() );
474
475 JExpression e = ds.getInitExpression();
476 if (e != null)
477 {
478 jw.print( " = " );
479 writeExpression( jw, e );
480 }
481
482 jw.println( ";" );
483 }
484
485 protected void writeElseStatement( JavaWriter jw, JElseStatement es )
486 {
487 if (es.hasStatements())
488 {
489 jw.println( "else" );
490 writeBlockStatement( jw, es );
491 }
492 }
493
494 protected void writeElseIfStatement( JavaWriter jw, JElseIfStatement eis )
495 {
496 if (eis.hasStatements())
497 {
498 jw.print( "else " );
499 writeIfStatement( jw, eis );
500 }
501 }
502
503 protected void writeIfElseIfElseStatement( JavaWriter jw, JIfElseIfElseStatement ies )
504 {
505 writeIfStatement( jw, ies.getIfStatement() );
506 }
507
508 protected void writeExpression( JavaWriter jw, JExpression e )
509 {
510
512 if (e.getStatement() instanceof JCodeStatement)
513 {
514 JCodeStatement cs = (JCodeStatement)e.getStatement();
515 writeCodeStatement( jw, cs, false );
516 }
518 else
519 {
520 writeStatement( jw, e.getStatement() );
521 }
522 }
523
524 protected void writeFinallyStatement( JavaWriter jw, JFinallyStatement fs )
525 {
526 if (fs.hasStatements())
527 {
528 jw.println( "finally" );
529 writeStatement( jw, fs.getStatement() );
530 }
531 }
532
533 protected void writeForStatement( JavaWriter jw, JForStatement fs )
534 {
535 jw.newln();
536 jw.print( "for (" );
537 writeStatement( jw, fs.getInitStatement() );
538 jw.print( ";" );
539 writeExpression( jw, fs.getLoopExpression() );
540 writeStatement( jw, fs.getIterStatement() );
541 jw.println( ")" );
542 writeBlockStatement( jw, fs );
543 }
545
546 protected void writeIfStatement( JavaWriter jw, JIfStatement is )
547 {
548 jw.newln();
549 jw.print( "if (" );
550 writeExpression( jw, is.getExpression() );
551 jw.println( ")" );
552 writeBlockStatement( jw, is );
553 }
554
555 protected void writeSwitchStatement( JavaWriter jw, JSwitchStatement ss )
556 {
557 jw.newln();
558 jw.print( "switch (" );
559 writeExpression( jw, ss.getExpression() );
560 jw.println( ")" );
561 jw.begin();
562 writeStatements( jw, ss.getCases() );
563 jw.end();
564 }
565
566 protected void writeTryCatchFinallyStatement( JavaWriter jw, JTryCatchFinallyStatement tcfs )
567 {
568 writeStatement( jw, tcfs.getTryStatement() );
569 writeStatements( jw, tcfs.getCatches() );
570 writeStatement( jw, tcfs.getFinallyStatement() );
571 }
572
573 protected void writeTryStatement( JavaWriter jw, JTryStatement ts )
574 {
575 jw.println( "" );
576 jw.println( "try" );
577 writeBlockStatement( jw, ts );
578 }
580
581 }
582 |
Popular Tags |
Java API By Example, From Geeks To Geeks.