1 /*
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.codemodel.internal;
27
28 import java.io.PrintWriter;
29 import java.io.Writer;
30 import java.util.ArrayList;
31 import java.util.Arrays;
32 import java.util.Collection;
33 import java.util.HashMap;
34 import java.util.HashSet;
35 import java.util.Iterator;
36 import java.util.List;
37
38
39 /**
40 * This is a utility class for managing indentation and other basic
41 * formatting for PrintWriter.
42 */
43 public final class JFormatter {
44 /** all classes and ids encountered during the collection mode **/
45 /** map from short type name to ReferenceList (list of JClass and ids sharing that name) **/
46 private HashMap<String,ReferenceList> collectedReferences;
47
48 /** set of imported types (including package java types, eventhough we won't generate imports for them) */
49 private HashSet<JClass> importedClasses;
50
51 private static enum Mode {
52 /**
53 * Collect all the type names and identifiers.
54 * In this mode we don't actually generate anything.
55 */
56 COLLECTING,
57 /**
58 * Print the actual source code.
59 */
60 PRINTING
61 }
62
63 /**
64 * The current running mode.
65 * Set to PRINTING so that a casual client can use a formatter just like before.
66 */
67 private Mode mode = Mode.PRINTING;
68
69 /**
70 * Current number of indentation strings to print
71 */
72 private int indentLevel;
73
74 /**
75 * String to be used for each indentation.
76 * Defaults to four spaces.
77 */
78 private final String indentSpace;
79
80 /**
81 * Stream associated with this JFormatter
82 */
83 private final PrintWriter pw;
84
85 /**
86 * Creates a JFormatter.
87 *
88 * @param s
89 * PrintWriter to JFormatter to use.
90 *
91 * @param space
92 * Incremental indentation string, similar to tab value.
93 */
94 public JFormatter(PrintWriter s, String space) {
95 pw = s;
96 indentSpace = space;
97 collectedReferences = new HashMap<String,ReferenceList>();
98 //ids = new HashSet<String>();
99 importedClasses = new HashSet<JClass>();
100 }
101
102 /**
103 * Creates a formatter with default incremental indentations of
104 * four spaces.
105 */
106 public JFormatter(PrintWriter s) {
107 this(s, " ");
108 }
109
110 /**
111 * Creates a formatter with default incremental indentations of
112 * four spaces.
113 */
114 public JFormatter(Writer w) {
115 this(new PrintWriter(w));
116 }
117
118 /**
119 * Closes this formatter.
120 */
121 public void close() {
122 pw.close();
123 }
124
125 /**
126 * Returns true if we are in the printing mode,
127 * where we actually produce text.
128 *
129 * The other mode is the "collecting mode'
130 */
131 public boolean isPrinting() {
132 return mode == Mode.PRINTING;
133 }
134
135 /**
136 * Decrement the indentation level.
137 */
138 public JFormatter o() {
139 indentLevel--;
140 return this;
141 }
142
143 /**
144 * Increment the indentation level.
145 */
146 public JFormatter i() {
147 indentLevel++;
148 return this;
149 }
150
151 private boolean needSpace(char c1, char c2) {
152 if ((c1 == ']') && (c2 == '{')) return true;
153 if (c1 == ';') return true;
154 if (c1 == CLOSE_TYPE_ARGS) {
155 // e.g., "public Foo<Bar> test;"
156 if(c2=='(') // but not "new Foo<Bar>()"
157 return false;
158 return true;
159 }
160 if ((c1 == ')') && (c2 == '{')) return true;
161 if ((c1 == ',') || (c1 == '=')) return true;
162 if (c2 == '=') return true;
163 if (Character.isDigit(c1)) {
164 if ((c2 == '(') || (c2 == ')') || (c2 == ';') || (c2 == ','))
165 return false;
166 return true;
167 }
168 if (Character.isJavaIdentifierPart(c1)) {
169 switch (c2) {
170 case '{':
171 case '}':
172 case '+':
173 case '>':
174 case '@':
175 return true;
176 default:
177 return Character.isJavaIdentifierStart(c2);
178 }
179 }
180 if (Character.isJavaIdentifierStart(c2)) {
181 switch (c1) {
182 case ']':
183 case ')':
184 case '}':
185 case '+':
186 return true;
187 default:
188 return false;
189 }
190 }
191 if (Character.isDigit(c2)) {
192 if (c1 == '(') return false;
193 return true;
194 }
195 return false;
196 }
197
198 private char lastChar = 0;
199 private boolean atBeginningOfLine = true;
200
201 private void spaceIfNeeded(char c) {
202 if (atBeginningOfLine) {
203 for (int i = 0; i < indentLevel; i++)
204 pw.print(indentSpace);
205 atBeginningOfLine = false;
206 } else if ((lastChar != 0) && needSpace(lastChar, c))
207 pw.print(' ');
208 }
209
210 /**
211 * Print a char into the stream
212 *
213 * @param c the char
214 */
215 public JFormatter p(char c) {
216 if(mode==Mode.PRINTING) {
217 if(c==CLOSE_TYPE_ARGS) {
218 pw.print('>');
219 } else {
220 spaceIfNeeded(c);
221 pw.print(c);
222 }
223 lastChar = c;
224 }
225 return this;
226 }
227
228 /**
229 * Print a String into the stream
230 *
231 * @param s the String
232 */
233 public JFormatter p(String s) {
234 if(mode==Mode.PRINTING) {
235 spaceIfNeeded(s.charAt(0));
236 pw.print(s);
237 lastChar = s.charAt(s.length() - 1);
238 }
239 return this;
240 }
241
242 public JFormatter t(JType type) {
243 if(type.isReference()) {
244 return t((JClass)type);
245 } else {
246 return g(type);
247 }
248 }
249
250 /**
251 * Print a type name.
252 *
253 * <p>
254 * In the collecting mode we use this information to
255 * decide what types to import and what not to.
256 */
257 public JFormatter t(JClass type) {
258 switch(mode) {
259 case PRINTING:
260 // many of the JTypes in this list are either primitive or belong to package java
261 // so we don't need a FQCN
262 if(importedClasses.contains(type)) {
263 p(type.name()); // FQCN imported or not necessary, so generate short name
264 } else {
265 if(type.outer()!=null)
266 t(type.outer()).p('.').p(type.name());
267 else
268 p(type.fullName()); // collision was detected, so generate FQCN
269 }
270 break;
271 case COLLECTING:
272 final String shortName = type.name();
273 if(collectedReferences.containsKey(shortName)) {
274 collectedReferences.get(shortName).add(type);
275 } else {
276 ReferenceList tl = new ReferenceList();
277 tl.add(type);
278 collectedReferences.put(shortName, tl);
279 }
280 break;
281 }
282 return this;
283 }
284
285 /**
286 * Print an identifier
287 */
288 public JFormatter id(String id) {
289 switch(mode) {
290 case PRINTING:
291 p(id);
292 break;
293 case COLLECTING:
294 // see if there is a type name that collides with this id
295 if(collectedReferences.containsKey(id)) {
296 if( !collectedReferences.get(id).getClasses().isEmpty() ) {
297 for( JClass type : collectedReferences.get(id).getClasses() ) {
298 if (type.outer()!=null) {
299 collectedReferences.get(id).setId(false);
300 return this;
301 }
302 }
303 }
304 collectedReferences.get(id).setId(true);
305 } else {
306 // not a type, but we need to create a place holder to
307 // see if there might be a collision with a type
308 ReferenceList tl = new ReferenceList();
309 tl.setId(true);
310 collectedReferences.put(id, tl);
311 }
312 break;
313 }
314 return this;
315 }
316
317 /**
318 * Print a new line into the stream
319 */
320 public JFormatter nl() {
321 if(mode==Mode.PRINTING) {
322 pw.println();
323 lastChar = 0;
324 atBeginningOfLine = true;
325 }
326 return this;
327 }
328
329 /**
330 * Cause the JGenerable object to generate source for iteself
331 *
332 * @param g the JGenerable object
333 */
334 public JFormatter g(JGenerable g) {
335 g.generate(this);
336 return this;
337 }
338
339 /**
340 * Produces {@link JGenerable}s separated by ','
341 */
342 public JFormatter g(Collection<? extends JGenerable> list) {
343 boolean first = true;
344 if(!list.isEmpty()) {
345 for (JGenerable item : list) {
346 if (!first)
347 p(',');
348 g(item);
349 first = false;
350 }
351 }
352 return this;
353 }
354
355 /**
356 * Cause the JDeclaration to generate source for itself
357 *
358 * @param d the JDeclaration object
359 */
360 public JFormatter d(JDeclaration d) {
361 d.declare(this);
362 return this;
363 }
364
365 /**
366 * Cause the JStatement to generate source for itself
367 *
368 * @param s the JStatement object
369 */
370 public JFormatter s(JStatement s) {
371 s.state(this);
372 return this;
373 }
374
375 /**
376 * Cause the JVar to generate source for itself
377 *
378 * @param v the JVar object
379 */
380 public JFormatter b(JVar v) {
381 v.bind(this);
382 return this;
383 }
384
385 /**
386 * Generates the whole source code out of the specified class.
387 */
388 void write(JDefinedClass c) {
389 // first collect all the types and identifiers
390 mode = Mode.COLLECTING;
391 d(c);
392
393 javaLang = c.owner()._package("java.lang");
394
395 // collate type names and identifiers to determine which types can be imported
396 for( ReferenceList tl : collectedReferences.values() ) {
397 if(!tl.collisions(c) && !tl.isId()) {
398 assert tl.getClasses().size() == 1;
399
400 // add to list of collected types
401 importedClasses.add(tl.getClasses().get(0));
402 }
403 }
404
405 // the class itself that we will be generating is always accessible
406 importedClasses.add(c);
407
408 // then print the declaration
409 mode = Mode.PRINTING;
410
411 assert c.parentContainer().isPackage() : "this method is only for a pacakge-level class";
412 JPackage pkg = (JPackage) c.parentContainer();
413 if (!pkg.isUnnamed()) {
414 nl().d(pkg);
415 nl();
416 }
417
418 // generate import statements
419 JClass[] imports = importedClasses.toArray(new JClass[importedClasses.size()]);
420 Arrays.sort(imports);
421 for (JClass clazz : imports) {
422 // suppress import statements for primitive types, built-in types,
423 // types in the root package, and types in
424 // the same package as the current type
425 if(!supressImport(clazz, c)) {
426 if (clazz instanceof JNarrowedClass) {
427 clazz = clazz.erasure();
428 }
429
430 p("import").p(clazz.fullName()).p(';').nl();
431 }
432 }
433 nl();
434
435 d(c);
436 }
437
438 /**
439 * determine if an import statement should be supressed
440 *
441 * @param clazz JType that may or may not have an import
442 * @param c JType that is the current class being processed
443 * @return true if an import statement should be suppressed, false otherwise
444 */
445 private boolean supressImport(JClass clazz, JClass c) {
446 if (clazz instanceof JNarrowedClass) {
447 clazz = clazz.erasure();
448 }
449 if (clazz instanceof JAnonymousClass) {
450 clazz = clazz._extends();
451 }
452
453 if(clazz._package().isUnnamed())
454 return true;
455
456 final String packageName = clazz._package().name();
457 if(packageName.equals("java.lang"))
458 return true; // no need to explicitly import java.lang classes
459
460 if (clazz._package() == c._package()){
461 // inner classes require an import stmt.
462 // All other pkg local classes do not need an
463 // import stmt for ref.
464 if(clazz.outer()==null) {
465 return true; // no need to explicitly import a class into itself
466 }
467 }
468 return false;
469 }
470
471 private JPackage javaLang;
472
473
474
475 /**
476 * Special character token we use to differenciate '>' as an operator and
477 * '>' as the end of the type arguments. The former uses '>' and it requires
478 * a preceding whitespace. The latter uses this, and it does not have a preceding
479 * whitespace.
480 */
481 /*package*/ static final char CLOSE_TYPE_ARGS = '\uFFFF';
482
483 /**
484 * Used during the optimization of class imports.
485 *
486 * List of {@link JClass}es whose short name is the same.
487 *
488 * @author Ryan.Shoemaker@Sun.COM
489 */
490 final class ReferenceList {
491 private final ArrayList<JClass> classes = new ArrayList<JClass>();
492
493 /** true if this name is used as an identifier (like a variable name.) **/
494 private boolean id;
495
496 /**
497 * Returns true if the symbol represented by the short name
498 * is "importable".
499 */
500 public boolean collisions(JDefinedClass enclosingClass) {
501 // special case where a generated type collides with a type in package java
502
503 // more than one type with the same name
504 if(classes.size() > 1)
505 return true;
506
507 // an id and (at least one) type with the same name
508 if(id && classes.size() != 0)
509 return true;
510
511 for(JClass c : classes) {
512 if (c instanceof JAnonymousClass) {
513 c = c._extends();
514 }
515 if(c._package()==javaLang) {
516 // make sure that there's no other class with this name within the same package
517 Iterator<JDefinedClass> itr = enclosingClass._package().classes();
518 while(itr.hasNext()) {
519 // even if this is the only "String" class we use,
520 // if the class called "String" is in the same package,
521 // we still need to import it.
522 JDefinedClass n = itr.next();
523 if(n.name().equals(c.name()))
524 return true; //collision
525 }
526 }
527 if(c.outer()!=null)
528 return true; // avoid importing inner class to work around 6431987. Also see jaxb issue 166
529 }
530
531 return false;
532 }
533
534 public void add(JClass clazz) {
535 if(!classes.contains(clazz))
536 classes.add(clazz);
537 }
538
539 public List<JClass> getClasses() {
540 return classes;
541 }
542
543 public void setId(boolean value) {
544 id = value;
545 }
546
547 /**
548 * Return true iff this is strictly an id, meaning that there
549 * are no collisions with type names.
550 */
551 public boolean isId() {
552 return id && classes.size() == 0;
553 }
554 }
555 }