1 /*
2 * Copyright (c) 1994, 2014, 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 sun.tools.javac;
27
28 import sun.tools.java.*;
29 import sun.tools.tree.*;
30 import sun.tools.tree.CompoundStatement;
31 import sun.tools.asm.Assembler;
32 import sun.tools.asm.ConstantPool;
33 import java.util.Vector;
34 import java.util.Enumeration;
35 import java.util.Hashtable;
36 import java.util.Iterator;
37 import java.io.IOException;
38 import java.io.OutputStream;
39 import java.io.DataOutputStream;
40 import java.io.ByteArrayOutputStream;
41 import java.io.File;
42
43 /**
44 * This class represents an Java class as it is read from
45 * an Java source file.
46 *
47 * WARNING: The contents of this source file are not part of any
48 * supported API. Code that depends on them does so at its own risk:
49 * they are subject to change or removal without notice.
50 */
51 @Deprecated
52 public
53 class SourceClass extends ClassDefinition {
54
55 /**
56 * The toplevel environment, shared with the parser
57 */
58 Environment toplevelEnv;
59
60 /**
61 * The default constructor
62 */
63 SourceMember defConstructor;
64
65 /**
66 * The constant pool
67 */
68 ConstantPool tab = new ConstantPool();
69
70 /**
71 * The list of class dependencies
72 */
73 Hashtable deps = new Hashtable(11);
74
75 /**
76 * The field used to represent "this" in all of my code.
77 */
78 LocalMember thisArg;
79
80 /**
81 * Last token of class, as reported by parser.
82 */
83 long endPosition;
84
85 /**
86 * Access methods for constructors are distinguished from
87 * the constructors themselves by a dummy first argument.
88 * A unique type used for this purpose and shared by all
89 * constructor access methods within a package-member class is
90 * maintained here.
91 * <p>
92 * This field is null except in an outermost class containing
93 * one or more classes needing such an access method.
94 */
95 private Type dummyArgumentType = null;
96
97 /**
98 * Constructor
99 */
100 public SourceClass(Environment env, long where,
101 ClassDeclaration declaration, String documentation,
102 int modifiers, IdentifierToken superClass,
103 IdentifierToken interfaces[],
104 SourceClass outerClass, Identifier localName) {
105 super(env.getSource(), where,
106 declaration, modifiers, superClass, interfaces);
107 setOuterClass(outerClass);
108
109 this.toplevelEnv = env;
110 this.documentation = documentation;
111
112 if (ClassDefinition.containsDeprecated(documentation)) {
113 this.modifiers |= M_DEPRECATED;
114 }
115
116 // Check for a package level class which is declared static.
117 if (isStatic() && outerClass == null) {
118 env.error(where, "static.class", this);
119 this.modifiers &=~ M_STATIC;
120 }
121
122 // Inner classes cannot be static, nor can they be interfaces
123 // (which are implicitly static). Static classes and interfaces
124 // can only occur as top-level entities.
125 //
126 // Note that we do not have to check for local classes declared
127 // to be static (this is currently caught by the parser) but
128 // we check anyway in case the parser is modified to allow this.
129 if (isLocal() || (outerClass != null && !outerClass.isTopLevel())) {
130 if (isInterface()) {
131 env.error(where, "inner.interface");
132 } else if (isStatic()) {
133 env.error(where, "static.inner.class", this);
134 this.modifiers &=~ M_STATIC;
135 if (innerClassMember != null) {
136 innerClassMember.subModifiers(M_STATIC);
137 }
138 }
139 }
140
141 if (isPrivate() && outerClass == null) {
142 env.error(where, "private.class", this);
143 this.modifiers &=~ M_PRIVATE;
144 }
145 if (isProtected() && outerClass == null) {
146 env.error(where, "protected.class", this);
147 this.modifiers &=~ M_PROTECTED;
148 }
149 /*----*
150 if ((isPublic() || isProtected()) && isInsideLocal()) {
151 env.error(where, "warn.public.local.class", this);
152 }
153 *----*/
154
155 // maybe define an uplevel "A.this" current instance field
156 if (!isTopLevel() && !isLocal()) {
157 LocalMember outerArg = outerClass.getThisArgument();
158 UplevelReference r = getReference(outerArg);
159 setOuterMember(r.getLocalField(env));
160 }
161
162 // Set simple, unmangled local name for a local or anonymous class.
163 // NOTE: It would be OK to do this unconditionally, as null is the
164 // correct value for a member (non-local) class.
165 if (localName != null)
166 setLocalName(localName);
167
168 // Check for inner class with same simple name as one of
169 // its enclosing classes. Note that 'getLocalName' returns
170 // the simple, unmangled source-level name of any class.
171 // The previous version of this code was not careful to avoid
172 // mangled local class names. This version fixes 4047746.
173 Identifier thisName = getLocalName();
174 if (thisName != idNull) {
175 // Test above suppresses error for nested anonymous classes,
176 // which have an internal "name", but are not named in source code.
177 for (ClassDefinition scope = outerClass; scope != null;
178 scope = scope.getOuterClass()) {
179 Identifier outerName = scope.getLocalName();
180 if (thisName.equals(outerName))
181 env.error(where, "inner.redefined", thisName);
182 }
183 }
184 }
185
186 /**
187 * Return last position in this class.
188 * @see #getWhere
189 */
190 public long getEndPosition() {
191 return endPosition;
192 }
193
194 public void setEndPosition(long endPosition) {
195 this.endPosition = endPosition;
196 }
197
198
199 // JCOV
200 /**
201 * Return absolute name of source file
202 */
203 public String getAbsoluteName() {
204 String AbsName = ((ClassFile)getSource()).getAbsoluteName();
205
206 return AbsName;
207 }
208 //end JCOV
209
210 /**
211 * Return imports
212 */
213 public Imports getImports() {
214 return toplevelEnv.getImports();
215 }
216
217 /**
218 * Find or create my "this" argument, which is used for all methods.
219 */
220 public LocalMember getThisArgument() {
221 if (thisArg == null) {
222 thisArg = new LocalMember(where, this, 0, getType(), idThis);
223 }
224 return thisArg;
225 }
226
227 /**
228 * Add a dependency
229 */
230 public void addDependency(ClassDeclaration c) {
231 if (tab != null) {
232 tab.put(c);
233 }
234 // If doing -xdepend option, save away list of class dependencies
235 // making sure to NOT include duplicates or the class we are in
236 // (Hashtable's put() makes sure we don't have duplicates)
237 if ( toplevelEnv.print_dependencies() && c != getClassDeclaration() ) {
238 deps.put(c,c);
239 }
240 }
241
242 /**
243 * Add a field (check it first)
244 */
245 public void addMember(Environment env, MemberDefinition f) {
246 // Make sure the access permissions are self-consistent:
247 switch (f.getModifiers() & (M_PUBLIC | M_PRIVATE | M_PROTECTED)) {
248 case M_PUBLIC:
249 case M_PRIVATE:
250 case M_PROTECTED:
251 case 0:
252 break;
253 default:
254 env.error(f.getWhere(), "inconsistent.modifier", f);
255 // Cut out the more restrictive modifier(s):
256 if (f.isPublic()) {
257 f.subModifiers(M_PRIVATE | M_PROTECTED);
258 } else {
259 f.subModifiers(M_PRIVATE);
260 }
261 break;
262 }
263
264 // Note exemption for synthetic members below.
265 if (f.isStatic() && !isTopLevel() && !f.isSynthetic()) {
266 if (f.isMethod()) {
267 env.error(f.getWhere(), "static.inner.method", f, this);
268 f.subModifiers(M_STATIC);
269 } else if (f.isVariable()) {
270 if (!f.isFinal() || f.isBlankFinal()) {
271 env.error(f.getWhere(), "static.inner.field", f.getName(), this);
272 f.subModifiers(M_STATIC);
273 }
274 // Even if a static passes this test, there is still another
275 // check in 'SourceMember.check'. The check is delayed so
276 // that the initializer may be inspected more closely, using
277 // 'isConstant()'. Part of fix for 4095568.
278 } else {
279 // Static inner classes are diagnosed in 'SourceClass.<init>'.
280 f.subModifiers(M_STATIC);
281 }
282 }
283
284 if (f.isMethod()) {
285 if (f.isConstructor()) {
286 if (f.getClassDefinition().isInterface()) {
287 env.error(f.getWhere(), "intf.constructor");
288 return;
289 }
290 if (f.isNative() || f.isAbstract() ||
291 f.isStatic() || f.isSynchronized() || f.isFinal()) {
292 env.error(f.getWhere(), "constr.modifier", f);
293 f.subModifiers(M_NATIVE | M_ABSTRACT |
294 M_STATIC | M_SYNCHRONIZED | M_FINAL);
295 }
296 } else if (f.isInitializer()) {
297 if (f.getClassDefinition().isInterface()) {
298 env.error(f.getWhere(), "intf.initializer");
299 return;
300 }
301 }
302
303 // f is not allowed to return an array of void
304 if ((f.getType().getReturnType()).isVoidArray()) {
305 env.error(f.getWhere(), "void.array");
306 }
307
308 if (f.getClassDefinition().isInterface() &&
309 (f.isStatic() || f.isSynchronized() || f.isNative()
310 || f.isFinal() || f.isPrivate() || f.isProtected())) {
311 env.error(f.getWhere(), "intf.modifier.method", f);
312 f.subModifiers(M_STATIC | M_SYNCHRONIZED | M_NATIVE |
313 M_FINAL | M_PRIVATE);
314 }
315 if (f.isTransient()) {
316 env.error(f.getWhere(), "transient.meth", f);
317 f.subModifiers(M_TRANSIENT);
318 }
319 if (f.isVolatile()) {
320 env.error(f.getWhere(), "volatile.meth", f);
321 f.subModifiers(M_VOLATILE);
322 }
323 if (f.isAbstract()) {
324 if (f.isPrivate()) {
325 env.error(f.getWhere(), "abstract.private.modifier", f);
326 f.subModifiers(M_PRIVATE);
327 }
328 if (f.isStatic()) {
329 env.error(f.getWhere(), "abstract.static.modifier", f);
330 f.subModifiers(M_STATIC);
331 }
332 if (f.isFinal()) {
333 env.error(f.getWhere(), "abstract.final.modifier", f);
334 f.subModifiers(M_FINAL);
335 }
336 if (f.isNative()) {
337 env.error(f.getWhere(), "abstract.native.modifier", f);
338 f.subModifiers(M_NATIVE);
339 }
340 if (f.isSynchronized()) {
341 env.error(f.getWhere(),"abstract.synchronized.modifier",f);
342 f.subModifiers(M_SYNCHRONIZED);
343 }
344 }
345 if (f.isAbstract() || f.isNative()) {
346 if (f.getValue() != null) {
347 env.error(f.getWhere(), "invalid.meth.body", f);
348 f.setValue(null);
349 }
350 } else {
351 if (f.getValue() == null) {
352 if (f.isConstructor()) {
353 env.error(f.getWhere(), "no.constructor.body", f);
354 } else {
355 env.error(f.getWhere(), "no.meth.body", f);
356 }
357 f.addModifiers(M_ABSTRACT);
358 }
359 }
360 Vector arguments = f.getArguments();
361 if (arguments != null) {
362 // arguments can be null if this is an implicit abstract method
363 int argumentLength = arguments.size();
364 Type argTypes[] = f.getType().getArgumentTypes();
365 for (int i = 0; i < argTypes.length; i++) {
366 Object arg = arguments.elementAt(i);
367 long where = f.getWhere();
368 if (arg instanceof MemberDefinition) {
369 where = ((MemberDefinition)arg).getWhere();
370 arg = ((MemberDefinition)arg).getName();
371 }
372 // (arg should be an Identifier now)
373 if (argTypes[i].isType(TC_VOID)
374 || argTypes[i].isVoidArray()) {
375 env.error(where, "void.argument", arg);
376 }
377 }
378 }
379 } else if (f.isInnerClass()) {
380 if (f.isVolatile() ||
381 f.isTransient() || f.isNative() || f.isSynchronized()) {
382 env.error(f.getWhere(), "inner.modifier", f);
383 f.subModifiers(M_VOLATILE | M_TRANSIENT |
384 M_NATIVE | M_SYNCHRONIZED);
385 }
386 // same check as for fields, below:
387 if (f.getClassDefinition().isInterface() &&
388 (f.isPrivate() || f.isProtected())) {
389 env.error(f.getWhere(), "intf.modifier.field", f);
390 f.subModifiers(M_PRIVATE | M_PROTECTED);
391 f.addModifiers(M_PUBLIC);
392 // Fix up the class itself to agree with
393 // the inner-class member.
394 ClassDefinition c = f.getInnerClass();
395 c.subModifiers(M_PRIVATE | M_PROTECTED);
396 c.addModifiers(M_PUBLIC);
397 }
398 } else {
399 if (f.getType().isType(TC_VOID) || f.getType().isVoidArray()) {
400 env.error(f.getWhere(), "void.inst.var", f.getName());
401 // REMIND: set type to error
402 return;
403 }
404
405 if (f.isSynchronized() || f.isAbstract() || f.isNative()) {
406 env.error(f.getWhere(), "var.modifier", f);
407 f.subModifiers(M_SYNCHRONIZED | M_ABSTRACT | M_NATIVE);
408 }
409 if (f.isStrict()) {
410 env.error(f.getWhere(), "var.floatmodifier", f);
411 f.subModifiers(M_STRICTFP);
412 }
413 if (f.isTransient() && isInterface()) {
414 env.error(f.getWhere(), "transient.modifier", f);
415 f.subModifiers(M_TRANSIENT);
416 }
417 if (f.isVolatile() && (isInterface() || f.isFinal())) {
418 env.error(f.getWhere(), "volatile.modifier", f);
419 f.subModifiers(M_VOLATILE);
420 }
421 if (f.isFinal() && (f.getValue() == null) && isInterface()) {
422 env.error(f.getWhere(), "initializer.needed", f);
423 f.subModifiers(M_FINAL);
424 }
425
426 if (f.getClassDefinition().isInterface() &&
427 (f.isPrivate() || f.isProtected())) {
428 env.error(f.getWhere(), "intf.modifier.field", f);
429 f.subModifiers(M_PRIVATE | M_PROTECTED);
430 f.addModifiers(M_PUBLIC);
431 }
432 }
433 // Do not check for repeated methods here: Types are not yet resolved.
434 if (!f.isInitializer()) {
435 for (MemberDefinition f2 = getFirstMatch(f.getName());
436 f2 != null; f2 = f2.getNextMatch()) {
437 if (f.isVariable() && f2.isVariable()) {
438 env.error(f.getWhere(), "var.multidef", f, f2);
439 return;
440 } else if (f.isInnerClass() && f2.isInnerClass() &&
441 !f.getInnerClass().isLocal() &&
442 !f2.getInnerClass().isLocal()) {
443 // Found a duplicate inner-class member.
444 // Duplicate local classes are detected in
445 // 'VarDeclarationStatement.checkDeclaration'.
446 env.error(f.getWhere(), "inner.class.multidef", f);
447 return;
448 }
449 }
450 }
451
452 super.addMember(env, f);
453 }
454
455 /**
456 * Create an environment suitable for checking this class.
457 * Make sure the source and imports are set right.
458 * Make sure the environment contains no context information.
459 * (Actually, throw away env altogether and use toplevelEnv instead.)
460 */
461 public Environment setupEnv(Environment env) {
462 // In some cases, we go to some trouble to create the 'env' argument
463 // that is discarded. We should remove the 'env' argument entirely
464 // as well as the vestigial code that supports it. See comments on
465 // 'newEnvironment' in 'checkInternal' below.
466 return new Environment(toplevelEnv, this);
467 }
468
469 /**
470 * A source class never reports deprecation, since the compiler
471 * allows access to deprecated features that are being compiled
472 * in the same job.
473 */
474 public boolean reportDeprecated(Environment env) {
475 return false;
476 }
477
478 /**
479 * See if the source file of this class is right.
480 * @see ClassDefinition#noteUsedBy
481 */
482 public void noteUsedBy(ClassDefinition ref, long where, Environment env) {
483 // If this class is not public, watch for cross-file references.
484 super.noteUsedBy(ref, where, env);
485 ClassDefinition def = this;
486 while (def.isInnerClass()) {
487 def = def.getOuterClass();
488 }
489 if (def.isPublic()) {
490 return; // already checked
491 }
492 while (ref.isInnerClass()) {
493 ref = ref.getOuterClass();
494 }
495 if (def.getSource().equals(ref.getSource())) {
496 return; // intra-file reference
497 }
498 ((SourceClass)def).checkSourceFile(env, where);
499 }
500
501 /**
502 * Check this class and all its fields.
503 */
504 public void check(Environment env) throws ClassNotFound {
505 if (tracing) env.dtEnter("SourceClass.check: " + getName());
506 if (isInsideLocal()) {
507 // An inaccessible class gets checked when the surrounding
508 // block is checked.
509 // QUERY: Should this case ever occur?
510 // What would invoke checking of a local class aside from
511 // checking the surrounding method body?
512 if (tracing) env.dtEvent("SourceClass.check: INSIDE LOCAL " +
513 getOuterClass().getName());
514 getOuterClass().check(env);
515 } else {
516 if (isInnerClass()) {
517 if (tracing) env.dtEvent("SourceClass.check: INNER CLASS " +
518 getOuterClass().getName());
519 // Make sure the outer is checked first.
520 ((SourceClass)getOuterClass()).maybeCheck(env);
521 }
522 Vset vset = new Vset();
523 Context ctx = null;
524 if (tracing)
525 env.dtEvent("SourceClass.check: CHECK INTERNAL " + getName());
526 vset = checkInternal(setupEnv(env), ctx, vset);
527 // drop vset here
528 }
529 if (tracing) env.dtExit("SourceClass.check: " + getName());
530 }
531
532 private void maybeCheck(Environment env) throws ClassNotFound {
533 if (tracing) env.dtEvent("SourceClass.maybeCheck: " + getName());
534 // Check this class now, if it has not yet been checked.
535 // Cf. Main.compile(). Perhaps this code belongs there somehow.
536 ClassDeclaration c = getClassDeclaration();
537 if (c.getStatus() == CS_PARSED) {
538 // Set it first to avoid vicious circularity:
539 c.setDefinition(this, CS_CHECKED);
540 check(env);
541 }
542 }
543
544 private Vset checkInternal(Environment env, Context ctx, Vset vset)
545 throws ClassNotFound {
546 Identifier nm = getClassDeclaration().getName();
547 if (env.verbose()) {
548 env.output("[checking class " + nm + "]");
549 }
550
551 // Save context enclosing class for later access
552 // by 'ClassDefinition.resolveName.'
553 classContext = ctx;
554
555 // At present, the call to 'newEnvironment' is not needed.
556 // The incoming environment to 'basicCheck' is always passed to
557 // 'setupEnv', which discards it completely. This is also the
558 // only call to 'newEnvironment', which is now apparently dead code.
559 basicCheck(Context.newEnvironment(env, ctx));
560
561 // Validate access for all inner-class components
562 // of a qualified name, not just the last one, which
563 // is checked below. Yes, this is a dirty hack...
564 // Much of this code was cribbed from 'checkSupers'.
565 // Part of fix for 4094658.
566 ClassDeclaration sup = getSuperClass();
567 if (sup != null) {
568 long where = getWhere();
569 where = IdentifierToken.getWhere(superClassId, where);
570 env.resolveExtendsByName(where, this, sup.getName());
571 }
572 for (int i = 0 ; i < interfaces.length ; i++) {
573 ClassDeclaration intf = interfaces[i];
574 long where = getWhere();
575 // Error localization fails here if interfaces were
576 // elided during error recovery from an invalid one.
577 if (interfaceIds != null
578 && interfaceIds.length == interfaces.length) {
579 where = IdentifierToken.getWhere(interfaceIds[i], where);
580 }
581 env.resolveExtendsByName(where, this, intf.getName());
582 }
583
584 // Does the name already exist in an imported package?
585 // See JLS 8.1 for the precise rules.
586 if (!isInnerClass() && !isInsideLocal()) {
587 // Discard package qualification for the import checks.
588 Identifier simpleName = nm.getName();
589 try {
590 // We want this to throw a ClassNotFound exception
591 Imports imports = toplevelEnv.getImports();
592 Identifier ID = imports.resolve(env, simpleName);
593 if (ID != getName())
594 env.error(where, "class.multidef.import", simpleName, ID);
595 } catch (AmbiguousClass e) {
596 // At least one of e.name1 and e.name2 must be different
597 Identifier ID = (e.name1 != getName()) ? e.name1 : e.name2;
598 env.error(where, "class.multidef.import", simpleName, ID);
599 } catch (ClassNotFound e) {
600 // we want this to happen
601 }
602
603 // Make sure that no package with the same fully qualified
604 // name exists. This is required by JLS 7.1. We only need
605 // to perform this check for top level classes -- it isn't
606 // necessary for inner classes. (bug 4101529)
607 //
608 // This change has been backed out because, on WIN32, it
609 // failed to distinguish between java.awt.event and
610 // java.awt.Event when looking for a directory. We will
611 // add this back in later.
612 //
613 // try {
614 // if (env.getPackage(nm).exists()) {
615 // env.error(where, "class.package.conflict", nm);
616 // }
617 // } catch (java.io.IOException ee) {
618 // env.error(where, "io.exception.package", nm);
619 // }
620
621 // Make sure it was defined in the right file
622 if (isPublic()) {
623 checkSourceFile(env, getWhere());
624 }
625 }
626
627 vset = checkMembers(env, ctx, vset);
628 return vset;
629 }
630
631 private boolean sourceFileChecked = false;
632
633 /**
634 * See if the source file of this class is of the right name.
635 */
636 public void checkSourceFile(Environment env, long where) {
637 // one error per offending class is sufficient
638 if (sourceFileChecked) return;
639 sourceFileChecked = true;
640
641 String fname = getName().getName() + ".java";
642 String src = ((ClassFile)getSource()).getName();
643 if (!src.equals(fname)) {
644 if (isPublic()) {
645 env.error(where, "public.class.file", this, fname);
646 } else {
647 env.error(where, "warn.package.class.file", this, src, fname);
648 }
649 }
650 }
651
652 // Set true if superclass (but not necessarily superinterfaces) have
653 // been checked. If the superclass is still unresolved, then an error
654 // message should have been issued, and we assume that no further
655 // resolution is possible.
656 private boolean supersChecked = false;
657
658 /**
659 * Overrides 'ClassDefinition.getSuperClass'.
660 */
661
662 public ClassDeclaration getSuperClass(Environment env) {
663 if (tracing) env.dtEnter("SourceClass.getSuperClass: " + this);
664 // Superclass may fail to be set because of error recovery,
665 // so resolve types here only if 'checkSupers' has not yet
666 // completed its checks on the superclass.
667 // QUERY: Can we eliminate the need to resolve superclasses on demand?
668 // See comments in 'checkSupers' and in 'ClassDefinition.getInnerClass'.
669 if (superClass == null && superClassId != null && !supersChecked) {
670 resolveTypeStructure(env);
671 // We used to report an error here if the superclass was not
672 // resolved. Having moved the call to 'checkSupers' from 'basicCheck'
673 // into 'resolveTypeStructure', the errors reported here should have
674 // already been reported. Furthermore, error recovery can null out
675 // the superclass, which would cause a spurious error from the test here.
676 }
677 if (tracing) env.dtExit("SourceClass.getSuperClass: " + this);
678 return superClass;
679 }
680
681 /**
682 * Check that all superclasses and superinterfaces are defined and
683 * well formed. Among other checks, verify that the inheritance
684 * graph is acyclic. Called from 'resolveTypeStructure'.
685 */
686
687 private void checkSupers(Environment env) throws ClassNotFound {
688
689 // *** DEBUG ***
690 supersCheckStarted = true;
691
692 if (tracing) env.dtEnter("SourceClass.checkSupers: " + this);
693
694 if (isInterface()) {
695 if (isFinal()) {
696 Identifier nm = getClassDeclaration().getName();
697 env.error(getWhere(), "final.intf", nm);
698 // Interfaces have no superclass. Superinterfaces
699 // are checked below, in code shared with the class case.
700 }
701 } else {
702 // Check superclass.
703 // Call to 'getSuperClass(env)' (note argument) attempts
704 // 'resolveTypeStructure' if superclass has not successfully
705 // been resolved. Since we have just now called 'resolveSupers'
706 // (see our call in 'resolveTypeStructure'), it is not clear
707 // that this can do any good. Why not 'getSuperClass()' here?
708 if (getSuperClass(env) != null) {
709 long where = getWhere();
710 where = IdentifierToken.getWhere(superClassId, where);
711 try {
712 ClassDefinition def =
713 getSuperClass().getClassDefinition(env);
714 // Resolve superclass and its ancestors.
715 def.resolveTypeStructure(env);
716 // Access to the superclass should be checked relative
717 // to the surrounding context, not as if the reference
718 // appeared within the class body. Changed 'canAccess'
719 // to 'extendsCanAccess' to fix 4087314.
720 if (!extendsCanAccess(env, getSuperClass())) {
721 env.error(where, "cant.access.class", getSuperClass());
722 // Might it be a better recovery to let the access go through?
723 superClass = null;
724 } else if (def.isFinal()) {
725 env.error(where, "super.is.final", getSuperClass());
726 // Might it be a better recovery to let the access go through?
727 superClass = null;
728 } else if (def.isInterface()) {
729 env.error(where, "super.is.intf", getSuperClass());
730 superClass = null;
731 } else if (superClassOf(env, getSuperClass())) {
732 env.error(where, "cyclic.super");
733 superClass = null;
734 } else {
735 def.noteUsedBy(this, where, env);
736 }
737 if (superClass == null) {
738 def = null;
739 } else {
740 // If we have a valid superclass, check its
741 // supers as well, and so on up to root class.
742 // Call to 'enclosingClassOf' will raise
743 // 'NullPointerException' if 'def' is null,
744 // so omit this check as error recovery.
745 ClassDefinition sup = def;
746 for (;;) {
747 if (enclosingClassOf(sup)) {
748 // Do we need a similar test for
749 // interfaces? See bugid 4038529.
750 env.error(where, "super.is.inner");
751 superClass = null;
752 break;
753 }
754 // Since we resolved the superclass and its
755 // ancestors above, we should not discover
756 // any unresolved classes on the superclass
757 // chain. It should thus be sufficient to
758 // call 'getSuperClass()' (no argument) here.
759 ClassDeclaration s = sup.getSuperClass(env);
760 if (s == null) {
761 // Superclass not resolved due to error.
762 break;
763 }
764 sup = s.getClassDefinition(env);
765 }
766 }
767 } catch (ClassNotFound e) {
768 // Error is detected in call to 'getClassDefinition'.
769 // The class may actually exist but be ambiguous.
770 // Call env.resolve(e.name) to see if it is.
771 // env.resolve(name) will definitely tell us if the
772 // class is ambiguous, but may not necessarily tell
773 // us if the class is not found.
774 // (part of solution for 4059855)
775 reportError: {
776 try {
777 env.resolve(e.name);
778 } catch (AmbiguousClass ee) {
779 env.error(where,
780 "ambig.class", ee.name1, ee.name2);
781 superClass = null;
782 break reportError;
783 } catch (ClassNotFound ee) {
784 // fall through
785 }
786 env.error(where, "super.not.found", e.name, this);
787 superClass = null;
788 } // The break exits this block
789 }
790
791 } else {
792 // Superclass was null on entry, after call to
793 // 'resolveSupers'. This should normally not happen,
794 // as 'resolveSupers' sets 'superClass' to a non-null
795 // value for all named classes, except for one special
796 // case: 'java.lang.Object', which has no superclass.
797 if (isAnonymous()) {
798 // checker should have filled it in first
799 throw new CompilerError("anonymous super");
800 } else if (!getName().equals(idJavaLangObject)) {
801 throw new CompilerError("unresolved super");
802 }
803 }
804 }
805
806 // At this point, if 'superClass' is null due to an error
807 // in the user program, a message should have been issued.
808 supersChecked = true;
809
810 // Check interfaces
811 for (int i = 0 ; i < interfaces.length ; i++) {
812 ClassDeclaration intf = interfaces[i];
813 long where = getWhere();
814 if (interfaceIds != null
815 && interfaceIds.length == interfaces.length) {
816 where = IdentifierToken.getWhere(interfaceIds[i], where);
817 }
818 try {
819 ClassDefinition def = intf.getClassDefinition(env);
820 // Resolve superinterface and its ancestors.
821 def.resolveTypeStructure(env);
822 // Check superinterface access in the correct context.
823 // Changed 'canAccess' to 'extendsCanAccess' to fix 4087314.
824 if (!extendsCanAccess(env, intf)) {
825 env.error(where, "cant.access.class", intf);
826 } else if (!intf.getClassDefinition(env).isInterface()) {
827 env.error(where, "not.intf", intf);
828 } else if (isInterface() && implementedBy(env, intf)) {
829 env.error(where, "cyclic.intf", intf);
830 } else {
831 def.noteUsedBy(this, where, env);
832 // Interface is OK, leave it in the interface list.
833 continue;
834 }
835 } catch (ClassNotFound e) {
836 // The interface may actually exist but be ambiguous.
837 // Call env.resolve(e.name) to see if it is.
838 // env.resolve(name) will definitely tell us if the
839 // interface is ambiguous, but may not necessarily tell
840 // us if the interface is not found.
841 // (part of solution for 4059855)
842 reportError2: {
843 try {
844 env.resolve(e.name);
845 } catch (AmbiguousClass ee) {
846 env.error(where,
847 "ambig.class", ee.name1, ee.name2);
848 superClass = null;
849 break reportError2;
850 } catch (ClassNotFound ee) {
851 // fall through
852 }
853 env.error(where, "intf.not.found", e.name, this);
854 superClass = null;
855 } // The break exits this block
856 }
857 // Remove this interface from the list of interfaces
858 // as recovery from an error.
859 ClassDeclaration newInterfaces[] =
860 new ClassDeclaration[interfaces.length - 1];
861 System.arraycopy(interfaces, 0, newInterfaces, 0, i);
862 System.arraycopy(interfaces, i + 1, newInterfaces, i,
863 newInterfaces.length - i);
864 interfaces = newInterfaces;
865 --i;
866 }
867 if (tracing) env.dtExit("SourceClass.checkSupers: " + this);
868 }
869
870 /**
871 * Check all of the members of this class.
872 * <p>
873 * Inner classes are checked in the following way. Any class which
874 * is immediately contained in a block (anonymous and local classes)
875 * is checked along with its containing method; see the
876 * SourceMember.check() method for more information. Member classes
877 * of this class are checked immediately after this class, unless this
878 * class is insideLocal(), in which case, they are checked with the
879 * rest of the members.
880 */
881 private Vset checkMembers(Environment env, Context ctx, Vset vset)
882 throws ClassNotFound {
883
884 // bail out if there were any errors
885 if (getError()) {
886 return vset;
887 }
888
889 // Make sure that all of our member classes have been
890 // basicCheck'ed before we check the rest of our members.
891 // If our member classes haven't been basicCheck'ed, then they
892 // may not have <init> methods. It is important that they
893 // have <init> methods so we can process NewInstanceExpressions
894 // correctly. This problem didn't occur before 1.2beta1.
895 // This is a fix for bug 4082816.
896 for (MemberDefinition f = getFirstMember();
897 f != null; f = f.getNextMember()) {
898 if (f.isInnerClass()) {
899 // System.out.println("Considering " + f + " in " + this);
900 SourceClass cdef = (SourceClass) f.getInnerClass();
901 if (cdef.isMember()) {
902 cdef.basicCheck(env);
903 }
904 }
905 }
906
907 if (isFinal() && isAbstract()) {
908 env.error(where, "final.abstract", this.getName().getName());
909 }
910
911 // This class should be abstract if there are any abstract methods
912 // in our parent classes and interfaces which we do not override.
913 // There are odd cases when, even though we cannot access some
914 // abstract method from our superclass, that abstract method can
915 // still force this class to be abstract. See the discussion in
916 // bug id 1240831.
917 if (!isInterface() && !isAbstract() && mustBeAbstract(env)) {
918 // Set the class abstract.
919 modifiers |= M_ABSTRACT;
920
921 // Tell the user which methods force this class to be abstract.
922
923 // First list all of the "unimplementable" abstract methods.
924 Iterator iter = getPermanentlyAbstractMethods();
925 while (iter.hasNext()) {
926 MemberDefinition method = (MemberDefinition) iter.next();
927 // We couldn't override this method even if we
928 // wanted to. Try to make the error message
929 // as non-confusing as possible.
930 env.error(where, "abstract.class.cannot.override",
931 getClassDeclaration(), method,
932 method.getDefiningClassDeclaration());
933 }
934
935 // Now list all of the traditional abstract methods.
936 iter = getMethods(env);
937 while (iter.hasNext()) {
938 // For each method, check if it is abstract. If it is,
939 // output an appropriate error message.
940 MemberDefinition method = (MemberDefinition) iter.next();
941 if (method.isAbstract()) {
942 env.error(where, "abstract.class",
943 getClassDeclaration(), method,
944 method.getDefiningClassDeclaration());
945 }
946 }
947 }
948
949 // Check the instance variables in a pre-pass before any constructors.
950 // This lets constructors "in-line" any initializers directly.
951 // It also lets us do some definite assignment checks on variables.
952 Context ctxInit = new Context(ctx);
953 Vset vsInst = vset.copy();
954 Vset vsClass = vset.copy();
955
956 // Do definite assignment checking on blank finals.
957 // Other variables do not need such checks. The simple textual
958 // ordering constraints implemented by MemberDefinition.canReach()
959 // are necessary and sufficient for the other variables.
960 // Note that within non-static code, all statics are always
961 // definitely assigned, and vice-versa.
962 for (MemberDefinition f = getFirstMember();
963 f != null; f = f.getNextMember()) {
964 if (f.isVariable() && f.isBlankFinal()) {
965 // The following allocates a LocalMember object as a proxy
966 // to represent the field.
967 int number = ctxInit.declareFieldNumber(f);
968 if (f.isStatic()) {
969 vsClass = vsClass.addVarUnassigned(number);
970 vsInst = vsInst.addVar(number);
971 } else {
972 vsInst = vsInst.addVarUnassigned(number);
973 vsClass = vsClass.addVar(number);
974 }
975 }
976 }
977
978 // For instance variable checks, use a context with a "this" parameter.
979 Context ctxInst = new Context(ctxInit, this);
980 LocalMember thisArg = getThisArgument();
981 int thisNumber = ctxInst.declare(env, thisArg);
982 vsInst = vsInst.addVar(thisNumber);
983
984 // Do all the initializers in order, checking the definite
985 // assignment of blank finals. Separate static from non-static.
986 for (MemberDefinition f = getFirstMember();
987 f != null; f = f.getNextMember()) {
988 try {
989 if (f.isVariable() || f.isInitializer()) {
990 if (f.isStatic()) {
991 vsClass = f.check(env, ctxInit, vsClass);
992 } else {
993 vsInst = f.check(env, ctxInst, vsInst);
994 }
995 }
996 } catch (ClassNotFound ee) {
997 env.error(f.getWhere(), "class.not.found", ee.name, this);
998 }
999 }
1000
1001 checkBlankFinals(env, ctxInit, vsClass, true);
1002
1003 // Check the rest of the field definitions.
1004 // (Note: Re-checking a field is a no-op.)
1005 for (MemberDefinition f = getFirstMember();
1006 f != null; f = f.getNextMember()) {
1007 try {
1008 if (f.isConstructor()) {
1009 // When checking a constructor, an explicit call to
1010 // 'this(...)' makes all blank finals definitely assigned.
1011 // See 'MethodExpression.checkValue'.
1012 Vset vsCon = f.check(env, ctxInit, vsInst.copy());
1013 // May issue multiple messages for the same variable!!
1014 checkBlankFinals(env, ctxInit, vsCon, false);
1015 // (drop vsCon here)
1016 } else {
1017 Vset vsFld = f.check(env, ctx, vset.copy());
1018 // (drop vsFld here)
1019 }
1020 } catch (ClassNotFound ee) {
1021 env.error(f.getWhere(), "class.not.found", ee.name, this);
1022 }
1023 }
1024
1025 // Must mark class as checked before visiting inner classes,
1026 // as they may in turn request checking of the current class
1027 // as an outer class. Fix for bug id 4056774.
1028 getClassDeclaration().setDefinition(this, CS_CHECKED);
1029
1030 // Also check other classes in the same nest.
1031 // All checking of this nest must be finished before any
1032 // of its classes emit bytecode.
1033 // Otherwise, the inner classes might not have a chance to
1034 // add access or class literal fields to the outer class.
1035 for (MemberDefinition f = getFirstMember();
1036 f != null; f = f.getNextMember()) {
1037 if (f.isInnerClass()) {
1038 SourceClass cdef = (SourceClass) f.getInnerClass();
1039 if (!cdef.isInsideLocal()) {
1040 cdef.maybeCheck(env);
1041 }
1042 }
1043 }
1044
1045 // Note: Since inner classes cannot set up-level variables,
1046 // the returned vset is always equal to the passed-in vset.
1047 // Still, we'll return it for the sake of regularity.
1048 return vset;
1049 }
1050
1051 /** Make sure all my blank finals exist now. */
1052
1053 private void checkBlankFinals(Environment env, Context ctxInit, Vset vset,
1054 boolean isStatic) {
1055 for (int i = 0; i < ctxInit.getVarNumber(); i++) {
1056 if (!vset.testVar(i)) {
1057 MemberDefinition ff = ctxInit.getElement(i);
1058 if (ff != null && ff.isBlankFinal()
1059 && ff.isStatic() == isStatic
1060 && ff.getClassDefinition() == this) {
1061 env.error(ff.getWhere(),
1062 "final.var.not.initialized", ff.getName());
1063 }
1064 }
1065 }
1066 }
1067
1068 /**
1069 * Check this class has its superclass and its interfaces. Also
1070 * force it to have an <init> method (if it doesn't already have one)
1071 * and to have all the abstract methods of its parents.
1072 */
1073 private boolean basicChecking = false;
1074 private boolean basicCheckDone = false;
1075 protected void basicCheck(Environment env) throws ClassNotFound {
1076
1077 if (tracing) env.dtEnter("SourceClass.basicCheck: " + getName());
1078
1079 super.basicCheck(env);
1080
1081 if (basicChecking || basicCheckDone) {
1082 if (tracing) env.dtExit("SourceClass.basicCheck: OK " + getName());
1083 return;
1084 }
1085
1086 if (tracing) env.dtEvent("SourceClass.basicCheck: CHECKING " + getName());
1087
1088 basicChecking = true;
1089
1090 env = setupEnv(env);
1091
1092 Imports imports = env.getImports();
1093 if (imports != null) {
1094 imports.resolve(env);
1095 }
1096
1097 resolveTypeStructure(env);
1098
1099 // Check the existence of the superclass and all interfaces.
1100 // Also responsible for breaking inheritance cycles. This call
1101 // has been moved to 'resolveTypeStructure', just after the call
1102 // to 'resolveSupers', as inheritance cycles must be broken before
1103 // resolving types within the members. Fixes 4073739.
1104 // checkSupers(env);
1105
1106 if (!isInterface()) {
1107
1108 // Add implicit <init> method, if necessary.
1109 // QUERY: What keeps us from adding an implicit constructor
1110 // when the user explicitly declares one? Is it truly guaranteed
1111 // that the declaration for such an explicit constructor will have
1112 // been processed by the time we arrive here? In general, 'basicCheck'
1113 // is called very early, prior to the normal member checking phase.
1114 if (!hasConstructor()) {
1115 Node code = new CompoundStatement(getWhere(), new Statement[0]);
1116 Type t = Type.tMethod(Type.tVoid);
1117
1118 // Default constructors inherit the access modifiers of their
1119 // class. For non-inner classes, this follows from JLS 8.6.7,
1120 // as the only possible modifier is 'public'. For the sake of
1121 // robustness in the presence of errors, we ignore any other
1122 // modifiers. For inner classes, the rule needs to be extended
1123 // in some way to account for the possibility of private and
1124 // protected classes. We make the 'obvious' extension, however,
1125 // the inner classes spec is silent on this issue, and a definitive
1126 // resolution is needed. See bugid 4087421.
1127 // WORKAROUND: A private constructor might need an access method,
1128 // but it is not possible to create one due to a restriction in
1129 // the verifier. (This is a known problem -- see 4015397.)
1130 // We therefore do not inherit the 'private' modifier from the class,
1131 // allowing the default constructor to be package private. This
1132 // workaround can be observed via reflection, but is otherwise
1133 // undetectable, as the constructor is always accessible within
1134 // the class in which its containing (private) class appears.
1135 int accessModifiers = getModifiers() &
1136 (isInnerClass() ? (M_PUBLIC | M_PROTECTED) : M_PUBLIC);
1137 env.makeMemberDefinition(env, getWhere(), this, null,
1138 accessModifiers,
1139 t, idInit, null, null, code);
1140 }
1141 }
1142
1143 // Only do the inheritance/override checks if they are turned on.
1144 // The idea here is that they will be done in javac, but not
1145 // in javadoc. See the comment for turnOffChecks(), above.
1146 if (doInheritanceChecks) {
1147
1148 // Verify the compatibility of all inherited method definitions
1149 // by collecting all of our inheritable methods.
1150 collectInheritedMethods(env);
1151 }
1152
1153 basicChecking = false;
1154 basicCheckDone = true;
1155 if (tracing) env.dtExit("SourceClass.basicCheck: " + getName());
1156 }
1157
1158 /**
1159 * Add a group of methods to this class as miranda methods.
1160 *
1161 * For a definition of Miranda methods, see the comment above the
1162 * method addMirandaMethods() in the file
1163 * sun/tools/java/ClassDeclaration.java
1164 */
1165 protected void addMirandaMethods(Environment env,
1166 Iterator mirandas) {
1167
1168 while(mirandas.hasNext()) {
1169 MemberDefinition method =
1170 (MemberDefinition)mirandas.next();
1171
1172 addMember(method);
1173
1174 //System.out.println("adding miranda method " + newMethod +
1175 // " to " + this);
1176 }
1177 }
1178
1179 /**
1180 * <em>After parsing is complete</em>, resolve all names
1181 * except those inside method bodies or initializers.
1182 * In particular, this is the point at which we find out what
1183 * kinds of variables and methods there are in the classes,
1184 * and therefore what is each class's interface to the world.
1185 * <p>
1186 * Also perform certain other transformations, such as inserting
1187 * "this$C" arguments into constructors, and reorganizing structure
1188 * to flatten qualified member names.
1189 * <p>
1190 * Do not perform type-based or name-based consistency checks
1191 * or normalizations (such as default nullary constructors),
1192 * and do not attempt to compile code against this class,
1193 * until after this phase.
1194 */
1195
1196 private boolean resolving = false;
1197
1198 public void resolveTypeStructure(Environment env) {
1199
1200 if (tracing)
1201 env.dtEnter("SourceClass.resolveTypeStructure: " + getName());
1202
1203 // Resolve immediately enclosing type, which in turn
1204 // forces resolution of all enclosing type declarations.
1205 ClassDefinition oc = getOuterClass();
1206 if (oc != null && oc instanceof SourceClass
1207 && !((SourceClass)oc).resolved) {
1208 // Do the outer class first, always.
1209 ((SourceClass)oc).resolveTypeStructure(env);
1210 // (Note: this.resolved is probably true at this point.)
1211 }
1212
1213 // Punt if we've already resolved this class, or are currently
1214 // in the process of doing so.
1215 if (resolved || resolving) {
1216 if (tracing)
1217 env.dtExit("SourceClass.resolveTypeStructure: OK " + getName());
1218 return;
1219 }
1220
1221 // Previously, 'resolved' was set here, and served to prevent
1222 // duplicate resolutions here as well as its function in
1223 // 'ClassDefinition.addMember'. Now, 'resolving' serves the
1224 // former purpose, distinct from that of 'resolved'.
1225 resolving = true;
1226
1227 if (tracing)
1228 env.dtEvent("SourceClass.resolveTypeStructure: RESOLVING " + getName());
1229
1230 env = setupEnv(env);
1231
1232 // Resolve superclass names to class declarations
1233 // for the immediate superclass and superinterfaces.
1234 resolveSupers(env);
1235
1236 // Check all ancestor superclasses for various
1237 // errors, verifying definition of all superclasses
1238 // and superinterfaces. Also breaks inheritance cycles.
1239 // Calls 'resolveTypeStructure' recursively for ancestors
1240 // This call used to appear in 'basicCheck', but was not
1241 // performed early enough. Most of the compiler will barf
1242 // on inheritance cycles!
1243 try {
1244 checkSupers(env);
1245 } catch (ClassNotFound ee) {
1246 // Undefined classes should be reported by 'checkSupers'.
1247 env.error(where, "class.not.found", ee.name, this);
1248 }
1249
1250 for (MemberDefinition
1251 f = getFirstMember() ; f != null ; f = f.getNextMember()) {
1252 if (f instanceof SourceMember)
1253 ((SourceMember)f).resolveTypeStructure(env);
1254 }
1255
1256 resolving = false;
1257
1258 // Mark class as resolved. If new members are subsequently
1259 // added to the class, they will be resolved at that time.
1260 // See 'ClassDefinition.addMember'. Previously, this variable was
1261 // set prior to the calls to 'checkSupers' and 'resolveTypeStructure'
1262 // (which may engender further calls to 'checkSupers'). This could
1263 // lead to duplicate resolution of implicit constructors, as the call to
1264 // 'basicCheck' from 'checkSupers' could add the constructor while
1265 // its class is marked resolved, and thus would resolve the constructor,
1266 // believing it to be a "late addition". It would then be resolved
1267 // redundantly during the normal traversal of the members, which
1268 // immediately follows in the code above.
1269 resolved = true;
1270
1271 // Now we have enough information to detect method repeats.
1272 for (MemberDefinition
1273 f = getFirstMember() ; f != null ; f = f.getNextMember()) {
1274 if (f.isInitializer()) continue;
1275 if (!f.isMethod()) continue;
1276 for (MemberDefinition f2 = f; (f2 = f2.getNextMatch()) != null; ) {
1277 if (!f2.isMethod()) continue;
1278 if (f.getType().equals(f2.getType())) {
1279 env.error(f.getWhere(), "meth.multidef", f);
1280 continue;
1281 }
1282 if (f.getType().equalArguments(f2.getType())) {
1283 env.error(f.getWhere(), "meth.redef.rettype", f, f2);
1284 continue;
1285 }
1286 }
1287 }
1288 if (tracing)
1289 env.dtExit("SourceClass.resolveTypeStructure: " + getName());
1290 }
1291
1292 protected void resolveSupers(Environment env) {
1293 if (tracing)
1294 env.dtEnter("SourceClass.resolveSupers: " + this);
1295 // Find the super class
1296 if (superClassId != null && superClass == null) {
1297 superClass = resolveSuper(env, superClassId);
1298 // Special-case java.lang.Object here (not in the parser).
1299 // In all other cases, if we have a valid 'superClassId',
1300 // we return with a valid and non-null 'superClass' value.
1301 if (superClass == getClassDeclaration()
1302 && getName().equals(idJavaLangObject)) {
1303 superClass = null;
1304 superClassId = null;
1305 }
1306 }
1307 // Find interfaces
1308 if (interfaceIds != null && interfaces == null) {
1309 interfaces = new ClassDeclaration[interfaceIds.length];
1310 for (int i = 0 ; i < interfaces.length ; i++) {
1311 interfaces[i] = resolveSuper(env, interfaceIds[i]);
1312 for (int j = 0; j < i; j++) {
1313 if (interfaces[i] == interfaces[j]) {
1314 Identifier id = interfaceIds[i].getName();
1315 long where = interfaceIds[j].getWhere();
1316 env.error(where, "intf.repeated", id);
1317 }
1318 }
1319 }
1320 }
1321 if (tracing)
1322 env.dtExit("SourceClass.resolveSupers: " + this);
1323 }
1324
1325 private ClassDeclaration resolveSuper(Environment env, IdentifierToken t) {
1326 Identifier name = t.getName();
1327 if (tracing)
1328 env.dtEnter("SourceClass.resolveSuper: " + name);
1329 if (isInnerClass())
1330 name = outerClass.resolveName(env, name);
1331 else
1332 name = env.resolveName(name);
1333 ClassDeclaration result = env.getClassDeclaration(name);
1334 // Result is never null, as a new 'ClassDeclaration' is
1335 // created if one with the given name does not exist.
1336 if (tracing) env.dtExit("SourceClass.resolveSuper: " + name);
1337 return result;
1338 }
1339
1340 /**
1341 * During the type-checking of an outer method body or initializer,
1342 * this routine is called to check a local class body
1343 * in the proper context.
1344 * @param sup the named super class or interface (if anonymous)
1345 * @param args the actual arguments (if anonymous)
1346 */
1347 public Vset checkLocalClass(Environment env, Context ctx, Vset vset,
1348 ClassDefinition sup,
1349 Expression args[], Type argTypes[]
1350 ) throws ClassNotFound {
1351 env = setupEnv(env);
1352
1353 if ((sup != null) != isAnonymous()) {
1354 throw new CompilerError("resolveAnonymousStructure");
1355 }
1356 if (isAnonymous()) {
1357 resolveAnonymousStructure(env, sup, args, argTypes);
1358 }
1359
1360 // Run the checks in the lexical context from the outer class.
1361 vset = checkInternal(env, ctx, vset);
1362
1363 // This is now done by 'checkInternal' via its call to 'checkMembers'.
1364 // getClassDeclaration().setDefinition(this, CS_CHECKED);
1365
1366 return vset;
1367 }
1368
1369 /**
1370 * As with checkLocalClass, run the inline phase for a local class.
1371 */
1372 public void inlineLocalClass(Environment env) {
1373 for (MemberDefinition
1374 f = getFirstMember(); f != null; f = f.getNextMember()) {
1375 if ((f.isVariable() || f.isInitializer()) && !f.isStatic()) {
1376 continue; // inlined inside of constructors only
1377 }
1378 try {
1379 ((SourceMember)f).inline(env);
1380 } catch (ClassNotFound ee) {
1381 env.error(f.getWhere(), "class.not.found", ee.name, this);
1382 }
1383 }
1384 if (getReferencesFrozen() != null && !inlinedLocalClass) {
1385 inlinedLocalClass = true;
1386 // add more constructor arguments for uplevel references
1387 for (MemberDefinition
1388 f = getFirstMember(); f != null; f = f.getNextMember()) {
1389 if (f.isConstructor()) {
1390 //((SourceMember)f).addUplevelArguments(false);
1391 ((SourceMember)f).addUplevelArguments();
1392 }
1393 }
1394 }
1395 }
1396 private boolean inlinedLocalClass = false;
1397
1398 /**
1399 * Check a class which is inside a local class, but is not itself local.
1400 */
1401 public Vset checkInsideClass(Environment env, Context ctx, Vset vset)
1402 throws ClassNotFound {
1403 if (!isInsideLocal() || isLocal()) {
1404 throw new CompilerError("checkInsideClass");
1405 }
1406 return checkInternal(env, ctx, vset);
1407 }
1408
1409 /**
1410 * Just before checking an anonymous class, decide its true
1411 * inheritance, and build its (sole, implicit) constructor.
1412 */
1413 private void resolveAnonymousStructure(Environment env,
1414 ClassDefinition sup,
1415 Expression args[], Type argTypes[]
1416 ) throws ClassNotFound {
1417
1418 if (tracing) env.dtEvent("SourceClass.resolveAnonymousStructure: " +
1419 this + ", super " + sup);
1420
1421 // Decide now on the superclass.
1422
1423 // This check has been removed as part of the fix for 4055017.
1424 // In the anonymous class created to hold the 'class$' method
1425 // of an interface, 'superClassId' refers to 'java.lang.Object'.
1426 /*---------------------*
1427 if (!(superClass == null && superClassId.getName() == idNull)) {
1428 throw new CompilerError("superclass "+superClass);
1429 }
1430 *---------------------*/
1431
1432 if (sup.isInterface()) {
1433 // allow an interface in the "super class" position
1434 int ni = (interfaces == null) ? 0 : interfaces.length;
1435 ClassDeclaration i1[] = new ClassDeclaration[1+ni];
1436 if (ni > 0) {
1437 System.arraycopy(interfaces, 0, i1, 1, ni);
1438 if (interfaceIds != null && interfaceIds.length == ni) {
1439 IdentifierToken id1[] = new IdentifierToken[1+ni];
1440 System.arraycopy(interfaceIds, 0, id1, 1, ni);
1441 id1[0] = new IdentifierToken(sup.getName());
1442 }
1443 }
1444 i1[0] = sup.getClassDeclaration();
1445 interfaces = i1;
1446
1447 sup = toplevelEnv.getClassDefinition(idJavaLangObject);
1448 }
1449 superClass = sup.getClassDeclaration();
1450
1451 if (hasConstructor()) {
1452 throw new CompilerError("anonymous constructor");
1453 }
1454
1455 // Synthesize an appropriate constructor.
1456 Type t = Type.tMethod(Type.tVoid, argTypes);
1457 IdentifierToken names[] = new IdentifierToken[argTypes.length];
1458 for (int i = 0; i < names.length; i++) {
1459 names[i] = new IdentifierToken(args[i].getWhere(),
1460 Identifier.lookup("$"+i));
1461 }
1462 int outerArg = (sup.isTopLevel() || sup.isLocal()) ? 0 : 1;
1463 Expression superArgs[] = new Expression[-outerArg + args.length];
1464 for (int i = outerArg ; i < args.length ; i++) {
1465 superArgs[-outerArg + i] = new IdentifierExpression(names[i]);
1466 }
1467 long where = getWhere();
1468 Expression superExp;
1469 if (outerArg == 0) {
1470 superExp = new SuperExpression(where);
1471 } else {
1472 superExp = new SuperExpression(where,
1473 new IdentifierExpression(names[0]));
1474 }
1475 Expression superCall = new MethodExpression(where,
1476 superExp, idInit,
1477 superArgs);
1478 Statement body[] = { new ExpressionStatement(where, superCall) };
1479 Node code = new CompoundStatement(where, body);
1480 int mod = M_SYNTHETIC; // ISSUE: make M_PRIVATE, with wrapper?
1481 env.makeMemberDefinition(env, where, this, null,
1482 mod, t, idInit, names, null, code);
1483 }
1484
1485 /**
1486 * Convert class modifiers to a string for diagnostic purposes.
1487 * Accepts modifiers applicable to inner classes and that appear
1488 * in the InnerClasses attribute only, as well as those that may
1489 * appear in the class modifier proper.
1490 */
1491
1492 private static int classModifierBits[] =
1493 { ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
1494 ACC_INTERFACE, ACC_ABSTRACT, ACC_SUPER, M_ANONYMOUS, M_LOCAL,
1495 M_STRICTFP, ACC_STRICT};
1496
1497 private static String classModifierNames[] =
1498 { "PUBLIC", "PRIVATE", "PROTECTED", "STATIC", "FINAL",
1499 "INTERFACE", "ABSTRACT", "SUPER", "ANONYMOUS", "LOCAL",
1500 "STRICTFP", "STRICT"};
1501
1502 static String classModifierString(int mods) {
1503 String s = "";
1504 for (int i = 0; i < classModifierBits.length; i++) {
1505 if ((mods & classModifierBits[i]) != 0) {
1506 s = s + " " + classModifierNames[i];
1507 mods &= ~classModifierBits[i];
1508 }
1509 }
1510 if (mods != 0) {
1511 s = s + " ILLEGAL:" + Integer.toHexString(mods);
1512 }
1513 return s;
1514 }
1515
1516 /**
1517 * Find or create an access method for a private member,
1518 * or return null if this is not possible.
1519 */
1520 public MemberDefinition getAccessMember(Environment env, Context ctx,
1521 MemberDefinition field, boolean isSuper) {
1522 return getAccessMember(env, ctx, field, false, isSuper);
1523 }
1524
1525 public MemberDefinition getUpdateMember(Environment env, Context ctx,
1526 MemberDefinition field, boolean isSuper) {
1527 if (!field.isVariable()) {
1528 throw new CompilerError("method");
1529 }
1530 return getAccessMember(env, ctx, field, true, isSuper);
1531 }
1532
1533 private MemberDefinition getAccessMember(Environment env, Context ctx,
1534 MemberDefinition field,
1535 boolean isUpdate,
1536 boolean isSuper) {
1537
1538 // The 'isSuper' argument is really only meaningful when the
1539 // target member is a method, in which case an 'invokespecial'
1540 // is needed. For fields, 'getfield' and 'putfield' instructions
1541 // are generated in either case, and 'isSuper' currently plays
1542 // no essential role. Nonetheless, we maintain the distinction
1543 // consistently for the time being.
1544
1545 boolean isStatic = field.isStatic();
1546 boolean isMethod = field.isMethod();
1547
1548 // Find pre-existing access method.
1549 // In the case of a field access method, we only look for the getter.
1550 // A getter is always created whenever a setter is.
1551 // QUERY: Why doesn't the 'MemberDefinition' object for the field
1552 // itself just have fields for its getter and setter?
1553 MemberDefinition af;
1554 for (af = getFirstMember(); af != null; af = af.getNextMember()) {
1555 if (af.getAccessMethodTarget() == field) {
1556 if (isMethod && af.isSuperAccessMethod() == isSuper) {
1557 break;
1558 }
1559 // Distinguish the getter and the setter by the number of
1560 // arguments.
1561 int nargs = af.getType().getArgumentTypes().length;
1562 // This was (nargs == (isStatic ? 0 : 1) + (isUpdate ? 1 : 0))
1563 // in order to find a setter as well as a getter. This caused
1564 // allocation of multiple getters.
1565 if (nargs == (isStatic ? 0 : 1)) {
1566 break;
1567 }
1568 }
1569 }
1570
1571 if (af != null) {
1572 if (!isUpdate) {
1573 return af;
1574 } else {
1575 MemberDefinition uf = af.getAccessUpdateMember();
1576 if (uf != null) {
1577 return uf;
1578 }
1579 }
1580 } else if (isUpdate) {
1581 // must find or create the getter before creating the setter
1582 af = getAccessMember(env, ctx, field, false, isSuper);
1583 }
1584
1585 // If we arrive here, we are creating a new access member.
1586
1587 Identifier anm;
1588 Type dummyType = null;
1589
1590 if (field.isConstructor()) {
1591 // For a constructor, we use the same name as for all
1592 // constructors ("<init>"), but add a distinguishing
1593 // argument of an otherwise unused "dummy" type.
1594 anm = idInit;
1595 // Get the dummy class, creating it if necessary.
1596 SourceClass outerMostClass = (SourceClass)getTopClass();
1597 dummyType = outerMostClass.dummyArgumentType;
1598 if (dummyType == null) {
1599 // Create dummy class.
1600 IdentifierToken sup =
1601 new IdentifierToken(0, idJavaLangObject);
1602 IdentifierToken interfaces[] = {};
1603 IdentifierToken t = new IdentifierToken(0, idNull);
1604 int mod = M_ANONYMOUS | M_STATIC | M_SYNTHETIC;
1605 // If an interface has a public inner class, the dummy class for
1606 // the constructor must always be accessible. Fix for 4221648.
1607 if (outerMostClass.isInterface()) {
1608 mod |= M_PUBLIC;
1609 }
1610 ClassDefinition dummyClass =
1611 toplevelEnv.makeClassDefinition(toplevelEnv,
1612 0, t, null, mod,
1613 sup, interfaces,
1614 outerMostClass);
1615 // Check the class.
1616 // It is likely that a full check is not really necessary,
1617 // but it is essential that the class be marked as parsed.
1618 dummyClass.getClassDeclaration().setDefinition(dummyClass, CS_PARSED);
1619 Expression argsX[] = {};
1620 Type argTypesX[] = {};
1621 try {
1622 ClassDefinition supcls =
1623 toplevelEnv.getClassDefinition(idJavaLangObject);
1624 dummyClass.checkLocalClass(toplevelEnv, null,
1625 new Vset(), supcls, argsX, argTypesX);
1626 } catch (ClassNotFound ee) {};
1627 // Get class type.
1628 dummyType = dummyClass.getType();
1629 outerMostClass.dummyArgumentType = dummyType;
1630 }
1631 } else {
1632 // Otherwise, we use the name "access$N", for the
1633 // smallest value of N >= 0 yielding an unused name.
1634 for (int i = 0; ; i++) {
1635 anm = Identifier.lookup(prefixAccess + i);
1636 if (getFirstMatch(anm) == null) {
1637 break;
1638 }
1639 }
1640 }
1641
1642 Type argTypes[];
1643 Type t = field.getType();
1644
1645 if (isStatic) {
1646 if (!isMethod) {
1647 if (!isUpdate) {
1648 Type at[] = { };
1649 argTypes = at;
1650 t = Type.tMethod(t); // nullary getter
1651 } else {
1652 Type at[] = { t };
1653 argTypes = at;
1654 t = Type.tMethod(Type.tVoid, argTypes); // unary setter
1655 }
1656 } else {
1657 // Since constructors are never static, we don't
1658 // have to worry about a dummy argument here.
1659 argTypes = t.getArgumentTypes();
1660 }
1661 } else {
1662 // All access methods for non-static members get an explicit
1663 // 'this' pointer as an extra argument, as the access methods
1664 // themselves must be static. EXCEPTION: Access methods for
1665 // constructors are non-static.
1666 Type classType = this.getType();
1667 if (!isMethod) {
1668 if (!isUpdate) {
1669 Type at[] = { classType };
1670 argTypes = at;
1671 t = Type.tMethod(t, argTypes); // nullary getter
1672 } else {
1673 Type at[] = { classType, t };
1674 argTypes = at;
1675 t = Type.tMethod(Type.tVoid, argTypes); // unary setter
1676 }
1677 } else {
1678 // Target is a method, possibly a constructor.
1679 Type at[] = t.getArgumentTypes();
1680 int nargs = at.length;
1681 if (field.isConstructor()) {
1682 // Access method is a constructor.
1683 // Requires a dummy argument.
1684 MemberDefinition outerThisArg =
1685 ((SourceMember)field).getOuterThisArg();
1686 if (outerThisArg != null) {
1687 // Outer instance link must be the first argument.
1688 // The following is a sanity check that will catch
1689 // most cases in which in this requirement is violated.
1690 if (at[0] != outerThisArg.getType()) {
1691 throw new CompilerError("misplaced outer this");
1692 }
1693 // Strip outer 'this' argument.
1694 // It will be added back when the access method is checked.
1695 argTypes = new Type[nargs];
1696 argTypes[0] = dummyType;
1697 for (int i = 1; i < nargs; i++) {
1698 argTypes[i] = at[i];
1699 }
1700 } else {
1701 // There is no outer instance.
1702 argTypes = new Type[nargs+1];
1703 argTypes[0] = dummyType;
1704 for (int i = 0; i < nargs; i++) {
1705 argTypes[i+1] = at[i];
1706 }
1707 }
1708 } else {
1709 // Access method is static.
1710 // Requires an explicit 'this' argument.
1711 argTypes = new Type[nargs+1];
1712 argTypes[0] = classType;
1713 for (int i = 0; i < nargs; i++) {
1714 argTypes[i+1] = at[i];
1715 }
1716 }
1717 t = Type.tMethod(t.getReturnType(), argTypes);
1718 }
1719 }
1720
1721 int nlen = argTypes.length;
1722 long where = field.getWhere();
1723 IdentifierToken names[] = new IdentifierToken[nlen];
1724 for (int i = 0; i < nlen; i++) {
1725 names[i] = new IdentifierToken(where, Identifier.lookup("$"+i));
1726 }
1727
1728 Expression access = null;
1729 Expression thisArg = null;
1730 Expression args[] = null;
1731
1732 if (isStatic) {
1733 args = new Expression[nlen];
1734 for (int i = 0 ; i < nlen ; i++) {
1735 args[i] = new IdentifierExpression(names[i]);
1736 }
1737 } else {
1738 if (field.isConstructor()) {
1739 // Constructor access method is non-static, so
1740 // 'this' works normally.
1741 thisArg = new ThisExpression(where);
1742 // Remove dummy argument, as it is not
1743 // passed to the target method.
1744 args = new Expression[nlen-1];
1745 for (int i = 1 ; i < nlen ; i++) {
1746 args[i-1] = new IdentifierExpression(names[i]);
1747 }
1748 } else {
1749 // Non-constructor access method is static, so
1750 // we use the first argument as 'this'.
1751 thisArg = new IdentifierExpression(names[0]);
1752 // Remove first argument.
1753 args = new Expression[nlen-1];
1754 for (int i = 1 ; i < nlen ; i++) {
1755 args[i-1] = new IdentifierExpression(names[i]);
1756 }
1757 }
1758 access = thisArg;
1759 }
1760
1761 if (!isMethod) {
1762 access = new FieldExpression(where, access, field);
1763 if (isUpdate) {
1764 access = new AssignExpression(where, access, args[0]);
1765 }
1766 } else {
1767 // If true, 'isSuper' forces a non-virtual call.
1768 access = new MethodExpression(where, access, field, args, isSuper);
1769 }
1770
1771 Statement code;
1772 if (t.getReturnType().isType(TC_VOID)) {
1773 code = new ExpressionStatement(where, access);
1774 } else {
1775 code = new ReturnStatement(where, access);
1776 }
1777 Statement body[] = { code };
1778 code = new CompoundStatement(where, body);
1779
1780 // Access methods are now static (constructors excepted), and no longer final.
1781 // This change was mandated by the interaction of the access method
1782 // naming conventions and the restriction against overriding final
1783 // methods.
1784 int mod = M_SYNTHETIC;
1785 if (!field.isConstructor()) {
1786 mod |= M_STATIC;
1787 }
1788
1789 // Create the synthetic method within the class in which the referenced
1790 // private member appears. The 'env' argument to 'makeMemberDefinition'
1791 // is suspect because it represents the environment at the point at
1792 // which a reference takes place, while it should represent the
1793 // environment in which the definition of the synthetic method appears.
1794 // We get away with this because 'env' is used only to access globals
1795 // such as 'Environment.error', and also as an argument to
1796 // 'resolveTypeStructure', which immediately discards it using
1797 // 'setupEnv'. Apparently, the current definition of 'setupEnv'
1798 // represents a design change that has not been thoroughly propagated.
1799 // An access method is declared with same list of exceptions as its
1800 // target. As the exceptions are simply listed by name, the correctness
1801 // of this approach requires that the access method be checked
1802 // (name-resolved) in the same context as its target method This
1803 // should always be the case.
1804 SourceMember newf = (SourceMember)
1805 env.makeMemberDefinition(env, where, this,
1806 null, mod, t, anm, names,
1807 field.getExceptionIds(), code);
1808 // Just to be safe, copy over the name-resolved exceptions from the
1809 // target so that the context in which the access method is checked
1810 // doesn't matter.
1811 newf.setExceptions(field.getExceptions(env));
1812
1813 newf.setAccessMethodTarget(field);
1814 if (isUpdate) {
1815 af.setAccessUpdateMember(newf);
1816 }
1817 newf.setIsSuperAccessMethod(isSuper);
1818
1819 // The call to 'check' is not needed, as the access method will be
1820 // checked by the containing class after it is added. This is the
1821 // idiom followed in the implementation of class literals. (See
1822 // 'FieldExpression.java'.) In any case, the context is wrong in the
1823 // call below. The access method must be checked in the context in
1824 // which it is declared, i.e., the class containing the referenced
1825 // private member, not the (inner) class in which the original member
1826 // reference occurs.
1827 //
1828 // try {
1829 // newf.check(env, ctx, new Vset());
1830 // } catch (ClassNotFound ee) {
1831 // env.error(where, "class.not.found", ee.name, this);
1832 // }
1833
1834 // The comment above is inaccurate. While it is often the case
1835 // that the containing class will check the access method, this is
1836 // by no means guaranteed. In fact, an access method may be added
1837 // after the checking of its class is complete. In this case, however,
1838 // the context in which the class was checked will have been saved in
1839 // the class definition object (by the fix for 4095716), allowing us
1840 // to check the field now, and in the correct context.
1841 // This fixes bug 4098093.
1842
1843 Context checkContext = newf.getClassDefinition().getClassContext();
1844 if (checkContext != null) {
1845 //System.out.println("checking late addition: " + this);
1846 try {
1847 newf.check(env, checkContext, new Vset());
1848 } catch (ClassNotFound ee) {
1849 env.error(where, "class.not.found", ee.name, this);
1850 }
1851 }
1852
1853
1854 //System.out.println("[Access member '" +
1855 // newf + "' created for field '" +
1856 // field +"' in class '" + this + "']");
1857
1858 return newf;
1859 }
1860
1861 /**
1862 * Find an inner class of 'this', chosen arbitrarily.
1863 * Result is always an actual class, never an interface.
1864 * Returns null if none found.
1865 */
1866 SourceClass findLookupContext() {
1867 // Look for an immediate inner class.
1868 for (MemberDefinition f = getFirstMember();
1869 f != null;
1870 f = f.getNextMember()) {
1871 if (f.isInnerClass()) {
1872 SourceClass ic = (SourceClass)f.getInnerClass();
1873 if (!ic.isInterface()) {
1874 return ic;
1875 }
1876 }
1877 }
1878 // Look for a class nested within an immediate inner interface.
1879 // At this point, we have given up on finding a minimally-nested
1880 // class (which would require a breadth-first traversal). It doesn't
1881 // really matter which inner class we find.
1882 for (MemberDefinition f = getFirstMember();
1883 f != null;
1884 f = f.getNextMember()) {
1885 if (f.isInnerClass()) {
1886 SourceClass lc =
1887 ((SourceClass)f.getInnerClass()).findLookupContext();
1888 if (lc != null) {
1889 return lc;
1890 }
1891 }
1892 }
1893 // No inner classes.
1894 return null;
1895 }
1896
1897 private MemberDefinition lookup = null;
1898
1899 /**
1900 * Get helper method for class literal lookup.
1901 */
1902 public MemberDefinition getClassLiteralLookup(long fwhere) {
1903
1904 // If we have already created a lookup method, reuse it.
1905 if (lookup != null) {
1906 return lookup;
1907 }
1908
1909 // If the current class is a nested class, make sure we put the
1910 // lookup method in the outermost class. Set 'lookup' for the
1911 // intervening inner classes so we won't have to do the search
1912 // again.
1913 if (outerClass != null) {
1914 lookup = outerClass.getClassLiteralLookup(fwhere);
1915 return lookup;
1916 }
1917
1918 // If we arrive here, there was no existing 'class$' method.
1919
1920 ClassDefinition c = this;
1921 boolean needNewClass = false;
1922
1923 if (isInterface()) {
1924 // The top-level type is an interface. Try to find an existing
1925 // inner class in which to create the helper method. Any will do.
1926 c = findLookupContext();
1927 if (c == null) {
1928 // The interface has no inner classes. Create an anonymous
1929 // inner class to hold the helper method, as an interface must
1930 // not have any methods. The tests above for prior creation
1931 // of a 'class$' method assure that only one such class is
1932 // allocated for each outermost class containing a class
1933 // literal embedded somewhere within. Part of fix for 4055017.
1934 needNewClass = true;
1935 IdentifierToken sup =
1936 new IdentifierToken(fwhere, idJavaLangObject);
1937 IdentifierToken interfaces[] = {};
1938 IdentifierToken t = new IdentifierToken(fwhere, idNull);
1939 int mod = M_PUBLIC | M_ANONYMOUS | M_STATIC | M_SYNTHETIC;
1940 c = (SourceClass)
1941 toplevelEnv.makeClassDefinition(toplevelEnv,
1942 fwhere, t, null, mod,
1943 sup, interfaces, this);
1944 }
1945 }
1946
1947
1948 // The name of the class-getter stub is "class$"
1949 Identifier idDClass = Identifier.lookup(prefixClass);
1950 Type strarg[] = { Type.tString };
1951
1952 // Some sanity checks of questionable value.
1953 //
1954 // This check became useless after matchMethod() was modified
1955 // to not return synthetic methods.
1956 //
1957 //try {
1958 // lookup = c.matchMethod(toplevelEnv, c, idDClass, strarg);
1959 //} catch (ClassNotFound ee) {
1960 // throw new CompilerError("unexpected missing class");
1961 //} catch (AmbiguousMember ee) {
1962 // throw new CompilerError("synthetic name clash");
1963 //}
1964 //if (lookup != null && lookup.getClassDefinition() == c) {
1965 // // Error if method found was not inherited.
1966 // throw new CompilerError("unexpected duplicate");
1967 //}
1968 // Some sanity checks of questionable value.
1969
1970 /* // The helper function looks like this.
1971 * // It simply maps a checked exception to an unchecked one.
1972 * static Class class$(String class$) {
1973 * try { return Class.forName(class$); }
1974 * catch (ClassNotFoundException forName) {
1975 * throw new NoClassDefFoundError(forName.getMessage());
1976 * }
1977 * }
1978 */
1979 long w = c.getWhere();
1980 IdentifierToken arg = new IdentifierToken(w, idDClass);
1981 Expression e = new IdentifierExpression(arg);
1982 Expression a1[] = { e };
1983 Identifier idForName = Identifier.lookup("forName");
1984 e = new MethodExpression(w, new TypeExpression(w, Type.tClassDesc),
1985 idForName, a1);
1986 Statement body = new ReturnStatement(w, e);
1987 // map the exceptions
1988 Identifier idClassNotFound =
1989 Identifier.lookup("java.lang.ClassNotFoundException");
1990 Identifier idNoClassDefFound =
1991 Identifier.lookup("java.lang.NoClassDefFoundError");
1992 Type ctyp = Type.tClass(idClassNotFound);
1993 Type exptyp = Type.tClass(idNoClassDefFound);
1994 Identifier idGetMessage = Identifier.lookup("getMessage");
1995 e = new IdentifierExpression(w, idForName);
1996 e = new MethodExpression(w, e, idGetMessage, new Expression[0]);
1997 Expression a2[] = { e };
1998 e = new NewInstanceExpression(w, new TypeExpression(w, exptyp), a2);
1999 Statement handler = new CatchStatement(w, new TypeExpression(w, ctyp),
2000 new IdentifierToken(idForName),
2001 new ThrowStatement(w, e));
2002 Statement handlers[] = { handler };
2003 body = new TryStatement(w, body, handlers);
2004
2005 Type mtype = Type.tMethod(Type.tClassDesc, strarg);
2006 IdentifierToken args[] = { arg };
2007
2008 // Use default (package) access. If private, an access method would
2009 // be needed in the event that the class literal belonged to an interface.
2010 // Also, making it private tickles bug 4098316.
2011 lookup = toplevelEnv.makeMemberDefinition(toplevelEnv, w,
2012 c, null,
2013 M_STATIC | M_SYNTHETIC,
2014 mtype, idDClass,
2015 args, null, body);
2016
2017 // If a new class was created to contain the helper method,
2018 // check it now.
2019 if (needNewClass) {
2020 if (c.getClassDeclaration().getStatus() == CS_CHECKED) {
2021 throw new CompilerError("duplicate check");
2022 }
2023 c.getClassDeclaration().setDefinition(c, CS_PARSED);
2024 Expression argsX[] = {};
2025 Type argTypesX[] = {};
2026 try {
2027 ClassDefinition sup =
2028 toplevelEnv.getClassDefinition(idJavaLangObject);
2029 c.checkLocalClass(toplevelEnv, null,
2030 new Vset(), sup, argsX, argTypesX);
2031 } catch (ClassNotFound ee) {};
2032 }
2033
2034 return lookup;
2035 }
2036
2037
2038 /**
2039 * A list of active ongoing compilations. This list
2040 * is used to stop two compilations from saving the
2041 * same class.
2042 */
2043 private static Vector active = new Vector();
2044
2045 /**
2046 * Compile this class
2047 */
2048 public void compile(OutputStream out)
2049 throws InterruptedException, IOException {
2050 Environment env = toplevelEnv;
2051 synchronized (active) {
2052 while (active.contains(getName())) {
2053 active.wait();
2054 }
2055 active.addElement(getName());
2056 }
2057
2058 try {
2059 compileClass(env, out);
2060 } catch (ClassNotFound e) {
2061 throw new CompilerError(e);
2062 } finally {
2063 synchronized (active) {
2064 active.removeElement(getName());
2065 active.notifyAll();
2066 }
2067 }
2068 }
2069
2070 /**
2071 * Verify that the modifier bits included in 'required' are
2072 * all present in 'mods', otherwise signal an internal error.
2073 * Note that errors in the source program may corrupt the modifiers,
2074 * thus we rely on the fact that 'CompilerError' exceptions are
2075 * silently ignored after an error message has been issued.
2076 */
2077 private static void assertModifiers(int mods, int required) {
2078 if ((mods & required) != required) {
2079 throw new CompilerError("illegal class modifiers");
2080 }
2081 }
2082
2083 protected void compileClass(Environment env, OutputStream out)
2084 throws IOException, ClassNotFound {
2085 Vector variables = new Vector();
2086 Vector methods = new Vector();
2087 Vector innerClasses = new Vector();
2088 CompilerMember init = new CompilerMember(new MemberDefinition(getWhere(), this, M_STATIC, Type.tMethod(Type.tVoid), idClassInit, null, null), new Assembler());
2089 Context ctx = new Context((Context)null, init.field);
2090
2091 for (ClassDefinition def = this; def.isInnerClass(); def = def.getOuterClass()) {
2092 innerClasses.addElement(def);
2093 }
2094 // Reverse the order, so that outer levels come first:
2095 int ncsize = innerClasses.size();
2096 for (int i = ncsize; --i >= 0; )
2097 innerClasses.addElement(innerClasses.elementAt(i));
2098 for (int i = ncsize; --i >= 0; )
2099 innerClasses.removeElementAt(i);
2100
2101 // System.out.println("compile class " + getName());
2102
2103 boolean haveDeprecated = this.isDeprecated();
2104 boolean haveSynthetic = this.isSynthetic();
2105 boolean haveConstantValue = false;
2106 boolean haveExceptions = false;
2107
2108 // Generate code for all fields
2109 for (SourceMember field = (SourceMember)getFirstMember();
2110 field != null;
2111 field = (SourceMember)field.getNextMember()) {
2112
2113 //System.out.println("compile field " + field.getName());
2114
2115 haveDeprecated |= field.isDeprecated();
2116 haveSynthetic |= field.isSynthetic();
2117
2118 try {
2119 if (field.isMethod()) {
2120 haveExceptions |=
2121 (field.getExceptions(env).length > 0);
2122
2123 if (field.isInitializer()) {
2124 if (field.isStatic()) {
2125 field.code(env, init.asm);
2126 }
2127 } else {
2128 CompilerMember f =
2129 new CompilerMember(field, new Assembler());
2130 field.code(env, f.asm);
2131 methods.addElement(f);
2132 }
2133 } else if (field.isInnerClass()) {
2134 innerClasses.addElement(field.getInnerClass());
2135 } else if (field.isVariable()) {
2136 field.inline(env);
2137 CompilerMember f = new CompilerMember(field, null);
2138 variables.addElement(f);
2139 if (field.isStatic()) {
2140 field.codeInit(env, ctx, init.asm);
2141
2142 }
2143 haveConstantValue |=
2144 (field.getInitialValue() != null);
2145 }
2146 } catch (CompilerError ee) {
2147 ee.printStackTrace();
2148 env.error(field, 0, "generic",
2149 field.getClassDeclaration() + ":" + field +
2150 "@" + ee.toString(), null, null);
2151 }
2152 }
2153 if (!init.asm.empty()) {
2154 init.asm.add(getWhere(), opc_return, true);
2155 methods.addElement(init);
2156 }
2157
2158 // bail out if there were any errors
2159 if (getNestError()) {
2160 return;
2161 }
2162
2163 int nClassAttrs = 0;
2164
2165 // Insert constants
2166 if (methods.size() > 0) {
2167 tab.put("Code");
2168 }
2169 if (haveConstantValue) {
2170 tab.put("ConstantValue");
2171 }
2172
2173 String sourceFile = null;
2174 if (env.debug_source()) {
2175 sourceFile = ((ClassFile)getSource()).getName();
2176 tab.put("SourceFile");
2177 tab.put(sourceFile);
2178 nClassAttrs += 1;
2179 }
2180
2181 if (haveExceptions) {
2182 tab.put("Exceptions");
2183 }
2184
2185 if (env.debug_lines()) {
2186 tab.put("LineNumberTable");
2187 }
2188 if (haveDeprecated) {
2189 tab.put("Deprecated");
2190 if (this.isDeprecated()) {
2191 nClassAttrs += 1;
2192 }
2193 }
2194 if (haveSynthetic) {
2195 tab.put("Synthetic");
2196 if (this.isSynthetic()) {
2197 nClassAttrs += 1;
2198 }
2199 }
2200 // JCOV
2201 if (env.coverage()) {
2202 nClassAttrs += 2; // AbsoluteSourcePath, TimeStamp
2203 tab.put("AbsoluteSourcePath");
2204 tab.put("TimeStamp");
2205 tab.put("CoverageTable");
2206 }
2207 // end JCOV
2208 if (env.debug_vars()) {
2209 tab.put("LocalVariableTable");
2210 }
2211 if (innerClasses.size() > 0) {
2212 tab.put("InnerClasses");
2213 nClassAttrs += 1; // InnerClasses
2214 }
2215
2216 // JCOV
2217 String absoluteSourcePath = "";
2218 long timeStamp = 0;
2219
2220 if (env.coverage()) {
2221 absoluteSourcePath = getAbsoluteName();
2222 timeStamp = System.currentTimeMillis();
2223 tab.put(absoluteSourcePath);
2224 }
2225 // end JCOV
2226 tab.put(getClassDeclaration());
2227 if (getSuperClass() != null) {
2228 tab.put(getSuperClass());
2229 }
2230 for (int i = 0 ; i < interfaces.length ; i++) {
2231 tab.put(interfaces[i]);
2232 }
2233
2234 // Sort the methods in order to make sure both constant pool
2235 // entries and methods are in a deterministic order from run
2236 // to run (this allows comparing class files for a fixed point
2237 // to validate the compiler)
2238 CompilerMember[] ordered_methods =
2239 new CompilerMember[methods.size()];
2240 methods.copyInto(ordered_methods);
2241 java.util.Arrays.sort(ordered_methods);
2242 for (int i=0; i<methods.size(); i++)
2243 methods.setElementAt(ordered_methods[i], i);
2244
2245 // Optimize Code and Collect method constants
2246 for (Enumeration e = methods.elements() ; e.hasMoreElements() ; ) {
2247 CompilerMember f = (CompilerMember)e.nextElement();
2248 try {
2249 f.asm.optimize(env);
2250 f.asm.collect(env, f.field, tab);
2251 tab.put(f.name);
2252 tab.put(f.sig);
2253 ClassDeclaration exp[] = f.field.getExceptions(env);
2254 for (int i = 0 ; i < exp.length ; i++) {
2255 tab.put(exp[i]);
2256 }
2257 } catch (Exception ee) {
2258 ee.printStackTrace();
2259 env.error(f.field, -1, "generic", f.field.getName() + "@" + ee.toString(), null, null);
2260 f.asm.listing(System.out);
2261 }
2262 }
2263
2264 // Collect field constants
2265 for (Enumeration e = variables.elements() ; e.hasMoreElements() ; ) {
2266 CompilerMember f = (CompilerMember)e.nextElement();
2267 tab.put(f.name);
2268 tab.put(f.sig);
2269
2270 Object val = f.field.getInitialValue();
2271 if (val != null) {
2272 tab.put((val instanceof String) ? new StringExpression(f.field.getWhere(), (String)val) : val);
2273 }
2274 }
2275
2276 // Collect inner class constants
2277 for (Enumeration e = innerClasses.elements();
2278 e.hasMoreElements() ; ) {
2279 ClassDefinition inner = (ClassDefinition)e.nextElement();
2280 tab.put(inner.getClassDeclaration());
2281
2282 // If the inner class is local, we do not need to add its
2283 // outer class here -- the outer_class_info_index is zero.
2284 if (!inner.isLocal()) {
2285 ClassDefinition outer = inner.getOuterClass();
2286 tab.put(outer.getClassDeclaration());
2287 }
2288
2289 // If the local name of the class is idNull, don't bother to
2290 // add it to the constant pool. We won't need it.
2291 Identifier inner_local_name = inner.getLocalName();
2292 if (inner_local_name != idNull) {
2293 tab.put(inner_local_name.toString());
2294 }
2295 }
2296
2297 // Write header
2298 DataOutputStream data = new DataOutputStream(out);
2299 data.writeInt(JAVA_MAGIC);
2300 data.writeShort(toplevelEnv.getMinorVersion());
2301 data.writeShort(toplevelEnv.getMajorVersion());
2302 tab.write(env, data);
2303
2304 // Write class information
2305 int cmods = getModifiers() & MM_CLASS;
2306
2307 // Certain modifiers are implied:
2308 // 1. Any interface (nested or not) is implicitly deemed to be abstract,
2309 // whether it is explicitly marked so or not. (Java 1.0.)
2310 // 2. A interface which is a member of a type is implicitly deemed to
2311 // be static, whether it is explicitly marked so or not.
2312 // 3a. A type which is a member of an interface is implicitly deemed
2313 // to be public, whether it is explicitly marked so or not.
2314 // 3b. A type which is a member of an interface is implicitly deemed
2315 // to be static, whether it is explicitly marked so or not.
2316 // All of these rules are implemented in 'BatchParser.beginClass',
2317 // but the results are verified here.
2318
2319 if (isInterface()) {
2320 // Rule 1.
2321 // The VM spec states that ACC_ABSTRACT must be set when
2322 // ACC_INTERFACE is; this was not done by javac prior to 1.2,
2323 // and the runtime compensates by setting it. Making sure
2324 // it is set here will allow the runtime hack to eventually
2325 // be removed. Rule 2 doesn't apply to transformed modifiers.
2326 assertModifiers(cmods, ACC_ABSTRACT);
2327 } else {
2328 // Contrary to the JVM spec, we only set ACC_SUPER for classes,
2329 // not interfaces. This is a workaround for a bug in IE3.0,
2330 // which refuses interfaces with ACC_SUPER on.
2331 cmods |= ACC_SUPER;
2332 }
2333
2334 // If this is a nested class, transform access modifiers.
2335 if (outerClass != null) {
2336 // If private, transform to default (package) access.
2337 // If protected, transform to public.
2338 // M_PRIVATE and M_PROTECTED are already masked off by MM_CLASS above.
2339 // cmods &= ~(M_PRIVATE | M_PROTECTED);
2340 if (isProtected()) cmods |= M_PUBLIC;
2341 // Rule 3a. Note that Rule 3b doesn't apply to transformed modifiers.
2342 if (outerClass.isInterface()) {
2343 assertModifiers(cmods, M_PUBLIC);
2344 }
2345 }
2346
2347 data.writeShort(cmods);
2348
2349 if (env.dumpModifiers()) {
2350 Identifier cn = getName();
2351 Identifier nm =
2352 Identifier.lookup(cn.getQualifier(), cn.getFlatName());
2353 System.out.println();
2354 System.out.println("CLASSFILE " + nm);
2355 System.out.println("---" + classModifierString(cmods));
2356 }
2357
2358 data.writeShort(tab.index(getClassDeclaration()));
2359 data.writeShort((getSuperClass() != null) ? tab.index(getSuperClass()) : 0);
2360 data.writeShort(interfaces.length);
2361 for (int i = 0 ; i < interfaces.length ; i++) {
2362 data.writeShort(tab.index(interfaces[i]));
2363 }
2364
2365 // write variables
2366 ByteArrayOutputStream buf = new ByteArrayOutputStream(256);
2367 ByteArrayOutputStream attbuf = new ByteArrayOutputStream(256);
2368 DataOutputStream databuf = new DataOutputStream(buf);
2369
2370 data.writeShort(variables.size());
2371 for (Enumeration e = variables.elements() ; e.hasMoreElements() ; ) {
2372 CompilerMember f = (CompilerMember)e.nextElement();
2373 Object val = f.field.getInitialValue();
2374
2375 data.writeShort(f.field.getModifiers() & MM_FIELD);
2376 data.writeShort(tab.index(f.name));
2377 data.writeShort(tab.index(f.sig));
2378
2379 int fieldAtts = (val != null ? 1 : 0);
2380 boolean dep = f.field.isDeprecated();
2381 boolean syn = f.field.isSynthetic();
2382 fieldAtts += (dep ? 1 : 0) + (syn ? 1 : 0);
2383
2384 data.writeShort(fieldAtts);
2385 if (val != null) {
2386 data.writeShort(tab.index("ConstantValue"));
2387 data.writeInt(2);
2388 data.writeShort(tab.index((val instanceof String) ? new StringExpression(f.field.getWhere(), (String)val) : val));
2389 }
2390 if (dep) {
2391 data.writeShort(tab.index("Deprecated"));
2392 data.writeInt(0);
2393 }
2394 if (syn) {
2395 data.writeShort(tab.index("Synthetic"));
2396 data.writeInt(0);
2397 }
2398 }
2399
2400 // write methods
2401
2402 data.writeShort(methods.size());
2403 for (Enumeration e = methods.elements() ; e.hasMoreElements() ; ) {
2404 CompilerMember f = (CompilerMember)e.nextElement();
2405
2406 int xmods = f.field.getModifiers() & MM_METHOD;
2407 // Transform floating point modifiers. M_STRICTFP
2408 // of member + status of enclosing class turn into
2409 // ACC_STRICT bit.
2410 if (((xmods & M_STRICTFP)!=0) || ((cmods & M_STRICTFP)!=0)) {
2411 xmods |= ACC_STRICT;
2412 } else {
2413 // Use the default
2414 if (env.strictdefault()) {
2415 xmods |= ACC_STRICT;
2416 }
2417 }
2418 data.writeShort(xmods);
2419
2420 data.writeShort(tab.index(f.name));
2421 data.writeShort(tab.index(f.sig));
2422 ClassDeclaration exp[] = f.field.getExceptions(env);
2423 int methodAtts = ((exp.length > 0) ? 1 : 0);
2424 boolean dep = f.field.isDeprecated();
2425 boolean syn = f.field.isSynthetic();
2426 methodAtts += (dep ? 1 : 0) + (syn ? 1 : 0);
2427
2428 if (!f.asm.empty()) {
2429 data.writeShort(methodAtts+1);
2430 f.asm.write(env, databuf, f.field, tab);
2431 int natts = 0;
2432 if (env.debug_lines()) {
2433 natts++;
2434 }
2435 // JCOV
2436 if (env.coverage()) {
2437 natts++;
2438 }
2439 // end JCOV
2440 if (env.debug_vars()) {
2441 natts++;
2442 }
2443 databuf.writeShort(natts);
2444
2445 if (env.debug_lines()) {
2446 f.asm.writeLineNumberTable(env, new DataOutputStream(attbuf), tab);
2447 databuf.writeShort(tab.index("LineNumberTable"));
2448 databuf.writeInt(attbuf.size());
2449 attbuf.writeTo(buf);
2450 attbuf.reset();
2451 }
2452
2453 //JCOV
2454 if (env.coverage()) {
2455 f.asm.writeCoverageTable(env, (ClassDefinition)this, new DataOutputStream(attbuf), tab, f.field.getWhere());
2456 databuf.writeShort(tab.index("CoverageTable"));
2457 databuf.writeInt(attbuf.size());
2458 attbuf.writeTo(buf);
2459 attbuf.reset();
2460 }
2461 // end JCOV
2462 if (env.debug_vars()) {
2463 f.asm.writeLocalVariableTable(env, f.field, new DataOutputStream(attbuf), tab);
2464 databuf.writeShort(tab.index("LocalVariableTable"));
2465 databuf.writeInt(attbuf.size());
2466 attbuf.writeTo(buf);
2467 attbuf.reset();
2468 }
2469
2470 data.writeShort(tab.index("Code"));
2471 data.writeInt(buf.size());
2472 buf.writeTo(data);
2473 buf.reset();
2474 } else {
2475 //JCOV
2476 if ((env.coverage()) && ((f.field.getModifiers() & M_NATIVE) > 0))
2477 f.asm.addNativeToJcovTab(env, (ClassDefinition)this);
2478 // end JCOV
2479 data.writeShort(methodAtts);
2480 }
2481
2482 if (exp.length > 0) {
2483 data.writeShort(tab.index("Exceptions"));
2484 data.writeInt(2 + exp.length * 2);
2485 data.writeShort(exp.length);
2486 for (int i = 0 ; i < exp.length ; i++) {
2487 data.writeShort(tab.index(exp[i]));
2488 }
2489 }
2490 if (dep) {
2491 data.writeShort(tab.index("Deprecated"));
2492 data.writeInt(0);
2493 }
2494 if (syn) {
2495 data.writeShort(tab.index("Synthetic"));
2496 data.writeInt(0);
2497 }
2498 }
2499
2500 // class attributes
2501 data.writeShort(nClassAttrs);
2502
2503 if (env.debug_source()) {
2504 data.writeShort(tab.index("SourceFile"));
2505 data.writeInt(2);
2506 data.writeShort(tab.index(sourceFile));
2507 }
2508
2509 if (this.isDeprecated()) {
2510 data.writeShort(tab.index("Deprecated"));
2511 data.writeInt(0);
2512 }
2513 if (this.isSynthetic()) {
2514 data.writeShort(tab.index("Synthetic"));
2515 data.writeInt(0);
2516 }
2517
2518 // JCOV
2519 if (env.coverage()) {
2520 data.writeShort(tab.index("AbsoluteSourcePath"));
2521 data.writeInt(2);
2522 data.writeShort(tab.index(absoluteSourcePath));
2523 data.writeShort(tab.index("TimeStamp"));
2524 data.writeInt(8);
2525 data.writeLong(timeStamp);
2526 }
2527 // end JCOV
2528
2529 if (innerClasses.size() > 0) {
2530 data.writeShort(tab.index("InnerClasses"));
2531 data.writeInt(2 + 2*4*innerClasses.size());
2532 data.writeShort(innerClasses.size());
2533 for (Enumeration e = innerClasses.elements() ;
2534 e.hasMoreElements() ; ) {
2535 // For each inner class name transformation, we have a record
2536 // with the following fields:
2537 //
2538 // u2 inner_class_info_index; // CONSTANT_Class_info index
2539 // u2 outer_class_info_index; // CONSTANT_Class_info index
2540 // u2 inner_name_index; // CONSTANT_Utf8_info index
2541 // u2 inner_class_access_flags; // access_flags bitmask
2542 //
2543 // The spec states that outer_class_info_index is 0 iff
2544 // the inner class is not a member of its enclosing class (i.e.
2545 // it is a local or anonymous class). The spec also states
2546 // that if a class is anonymous then inner_name_index should
2547 // be 0.
2548 //
2549 // See also the initInnerClasses() method in BinaryClass.java.
2550
2551 // Generate inner_class_info_index.
2552 ClassDefinition inner = (ClassDefinition)e.nextElement();
2553 data.writeShort(tab.index(inner.getClassDeclaration()));
2554
2555 // Generate outer_class_info_index.
2556 //
2557 // Checking isLocal() should probably be enough here,
2558 // but the check for isAnonymous is added for good
2559 // measure.
2560 if (inner.isLocal() || inner.isAnonymous()) {
2561 data.writeShort(0);
2562 } else {
2563 // Query: what about if inner.isInsideLocal()?
2564 // For now we continue to generate a nonzero
2565 // outer_class_info_index.
2566 ClassDefinition outer = inner.getOuterClass();
2567 data.writeShort(tab.index(outer.getClassDeclaration()));
2568 }
2569
2570 // Generate inner_name_index.
2571 Identifier inner_name = inner.getLocalName();
2572 if (inner_name == idNull) {
2573 if (!inner.isAnonymous()) {
2574 throw new CompilerError("compileClass(), anonymous");
2575 }
2576 data.writeShort(0);
2577 } else {
2578 data.writeShort(tab.index(inner_name.toString()));
2579 }
2580
2581 // Generate inner_class_access_flags.
2582 int imods = inner.getInnerClassMember().getModifiers()
2583 & ACCM_INNERCLASS;
2584
2585 // Certain modifiers are implied for nested types.
2586 // See rules 1, 2, 3a, and 3b enumerated above.
2587 // All of these rules are implemented in 'BatchParser.beginClass',
2588 // but are verified here.
2589
2590 if (inner.isInterface()) {
2591 // Rules 1 and 2.
2592 assertModifiers(imods, M_ABSTRACT | M_STATIC);
2593 }
2594 if (inner.getOuterClass().isInterface()) {
2595 // Rules 3a and 3b.
2596 imods &= ~(M_PRIVATE | M_PROTECTED); // error recovery
2597 assertModifiers(imods, M_PUBLIC | M_STATIC);
2598 }
2599
2600 data.writeShort(imods);
2601
2602 if (env.dumpModifiers()) {
2603 Identifier fn = inner.getInnerClassMember().getName();
2604 Identifier nm =
2605 Identifier.lookup(fn.getQualifier(), fn.getFlatName());
2606 System.out.println("INNERCLASS " + nm);
2607 System.out.println("---" + classModifierString(imods));
2608 }
2609
2610 }
2611 }
2612
2613 // Cleanup
2614 data.flush();
2615 tab = null;
2616
2617 // JCOV
2618 // generate coverage data
2619 if (env.covdata()) {
2620 Assembler CovAsm = new Assembler();
2621 CovAsm.GenVecJCov(env, (ClassDefinition)this, timeStamp);
2622 }
2623 // end JCOV
2624 }
2625
2626 /**
2627 * Print out the dependencies for this class (-xdepend) option
2628 */
2629
2630 public void printClassDependencies(Environment env) {
2631
2632 // Only do this if the -xdepend flag is on
2633 if ( toplevelEnv.print_dependencies() ) {
2634
2635 // Name of java source file this class was in (full path)
2636 // e.g. /home/ohair/Test.java
2637 String src = ((ClassFile)getSource()).getAbsoluteName();
2638
2639 // Class name, fully qualified
2640 // e.g. "java.lang.Object" or "FooBar" or "sun.tools.javac.Main"
2641 // Inner class names must be mangled, as ordinary '.' qualification
2642 // is used internally where the spec requires '$' separators.
2643 // String className = getName().toString();
2644 String className = Type.mangleInnerType(getName()).toString();
2645
2646 // Line number where class starts in the src file
2647 long startLine = getWhere() >> WHEREOFFSETBITS;
2648
2649 // Line number where class ends in the src file (not used yet)
2650 long endLine = getEndPosition() >> WHEREOFFSETBITS;
2651
2652 // First line looks like:
2653 // CLASS:src,startLine,endLine,className
2654 System.out.println( "CLASS:"
2655 + src + ","
2656 + startLine + ","
2657 + endLine + ","
2658 + className);
2659
2660 // For each class this class is dependent on:
2661 // CLDEP:className1,className2
2662 // where className1 is the name of the class we are in, and
2663 // classname2 is the name of the class className1
2664 // is dependent on.
2665 for(Enumeration e = deps.elements(); e.hasMoreElements(); ) {
2666 ClassDeclaration data = (ClassDeclaration) e.nextElement();
2667 // Mangle name of class dependend on.
2668 String depName =
2669 Type.mangleInnerType(data.getName()).toString();
2670 env.output("CLDEP:" + className + "," + depName);
2671 }
2672 }
2673 }
2674 }