src/share/classes/com/sun/tools/javac/jvm/ClassReader.java

Fri, 18 Jun 2010 15:12:04 -0700

author
jrose
date
Fri, 18 Jun 2010 15:12:04 -0700
changeset 573
005bec70ca27
parent 554
9d9f26857129
parent 571
f0e3ec1f9d9f
child 591
d1d7595fa824
permissions
-rw-r--r--

Merge

duke@1 1 /*
ohair@554 2 * Copyright (c) 1999, 2009, Oracle and/or its affiliates. All rights reserved.
duke@1 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@1 4 *
duke@1 5 * This code is free software; you can redistribute it and/or modify it
duke@1 6 * under the terms of the GNU General Public License version 2 only, as
ohair@554 7 * published by the Free Software Foundation. Oracle designates this
duke@1 8 * particular file as subject to the "Classpath" exception as provided
ohair@554 9 * by Oracle in the LICENSE file that accompanied this code.
duke@1 10 *
duke@1 11 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@1 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@1 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@1 14 * version 2 for more details (a copy is included in the LICENSE file that
duke@1 15 * accompanied this code).
duke@1 16 *
duke@1 17 * You should have received a copy of the GNU General Public License version
duke@1 18 * 2 along with this work; if not, write to the Free Software Foundation,
duke@1 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@1 20 *
ohair@554 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@554 22 * or visit www.oracle.com if you need additional information or have any
ohair@554 23 * questions.
duke@1 24 */
duke@1 25
duke@1 26 package com.sun.tools.javac.jvm;
duke@1 27
duke@1 28 import java.io.*;
duke@1 29 import java.net.URI;
jjg@400 30 import java.net.URISyntaxException;
duke@1 31 import java.nio.CharBuffer;
jjg@428 32 import java.util.Arrays;
duke@1 33 import java.util.EnumSet;
duke@1 34 import java.util.HashMap;
duke@1 35 import java.util.Map;
duke@1 36 import java.util.Set;
duke@1 37 import javax.lang.model.SourceVersion;
duke@1 38 import javax.tools.JavaFileObject;
duke@1 39 import javax.tools.JavaFileManager;
jjg@256 40 import javax.tools.JavaFileManager.Location;
duke@1 41 import javax.tools.StandardJavaFileManager;
duke@1 42
jjg@256 43 import static javax.tools.StandardLocation.*;
jjg@256 44
duke@1 45 import com.sun.tools.javac.comp.Annotate;
duke@1 46 import com.sun.tools.javac.code.*;
duke@1 47 import com.sun.tools.javac.code.Type.*;
duke@1 48 import com.sun.tools.javac.code.Symbol.*;
duke@1 49 import com.sun.tools.javac.code.Symtab;
jjg@50 50 import com.sun.tools.javac.file.BaseFileObject;
duke@1 51 import com.sun.tools.javac.util.*;
duke@1 52
duke@1 53 import static com.sun.tools.javac.code.Flags.*;
duke@1 54 import static com.sun.tools.javac.code.Kinds.*;
duke@1 55 import static com.sun.tools.javac.code.TypeTags.*;
jjg@256 56 import static com.sun.tools.javac.jvm.ClassFile.*;
jjg@256 57 import static com.sun.tools.javac.jvm.ClassFile.Version.*;
duke@1 58
duke@1 59 /** This class provides operations to read a classfile into an internal
duke@1 60 * representation. The internal representation is anchored in a
duke@1 61 * ClassSymbol which contains in its scope symbol representations
duke@1 62 * for all other definitions in the classfile. Top-level Classes themselves
duke@1 63 * appear as members of the scopes of PackageSymbols.
duke@1 64 *
duke@1 65 * <p><b>This is NOT part of any API supported by Sun Microsystems. If
duke@1 66 * you write code that depends on this, you do so at your own risk.
duke@1 67 * This code and its internal interfaces are subject to change or
duke@1 68 * deletion without notice.</b>
duke@1 69 */
jjg@256 70 public class ClassReader implements Completer {
duke@1 71 /** The context key for the class reader. */
duke@1 72 protected static final Context.Key<ClassReader> classReaderKey =
duke@1 73 new Context.Key<ClassReader>();
duke@1 74
duke@1 75 Annotate annotate;
duke@1 76
duke@1 77 /** Switch: verbose output.
duke@1 78 */
duke@1 79 boolean verbose;
duke@1 80
duke@1 81 /** Switch: check class file for correct minor version, unrecognized
duke@1 82 * attributes.
duke@1 83 */
duke@1 84 boolean checkClassFile;
duke@1 85
duke@1 86 /** Switch: read constant pool and code sections. This switch is initially
duke@1 87 * set to false but can be turned on from outside.
duke@1 88 */
duke@1 89 public boolean readAllOfClassFile = false;
duke@1 90
duke@1 91 /** Switch: read GJ signature information.
duke@1 92 */
duke@1 93 boolean allowGenerics;
duke@1 94
duke@1 95 /** Switch: read varargs attribute.
duke@1 96 */
duke@1 97 boolean allowVarargs;
duke@1 98
duke@1 99 /** Switch: allow annotations.
duke@1 100 */
duke@1 101 boolean allowAnnotations;
duke@1 102
duke@1 103 /** Switch: preserve parameter names from the variable table.
duke@1 104 */
duke@1 105 public boolean saveParameterNames;
duke@1 106
duke@1 107 /**
duke@1 108 * Switch: cache completion failures unless -XDdev is used
duke@1 109 */
duke@1 110 private boolean cacheCompletionFailure;
duke@1 111
duke@1 112 /**
duke@1 113 * Switch: prefer source files instead of newer when both source
duke@1 114 * and class are available
duke@1 115 **/
duke@1 116 public boolean preferSource;
duke@1 117
duke@1 118 /** The log to use for verbose output
duke@1 119 */
duke@1 120 final Log log;
duke@1 121
duke@1 122 /** The symbol table. */
duke@1 123 Symtab syms;
duke@1 124
duke@1 125 Types types;
duke@1 126
duke@1 127 /** The name table. */
jjg@113 128 final Names names;
duke@1 129
duke@1 130 /** Force a completion failure on this name
duke@1 131 */
duke@1 132 final Name completionFailureName;
duke@1 133
duke@1 134 /** Access to files
duke@1 135 */
duke@1 136 private final JavaFileManager fileManager;
duke@1 137
jjg@12 138 /** Factory for diagnostics
jjg@12 139 */
jjg@12 140 JCDiagnostic.Factory diagFactory;
jjg@12 141
duke@1 142 /** Can be reassigned from outside:
duke@1 143 * the completer to be used for ".java" files. If this remains unassigned
duke@1 144 * ".java" files will not be loaded.
duke@1 145 */
duke@1 146 public SourceCompleter sourceCompleter = null;
duke@1 147
duke@1 148 /** A hashtable containing the encountered top-level and member classes,
duke@1 149 * indexed by flat names. The table does not contain local classes.
duke@1 150 */
duke@1 151 private Map<Name,ClassSymbol> classes;
duke@1 152
duke@1 153 /** A hashtable containing the encountered packages.
duke@1 154 */
duke@1 155 private Map<Name, PackageSymbol> packages;
duke@1 156
duke@1 157 /** The current scope where type variables are entered.
duke@1 158 */
duke@1 159 protected Scope typevars;
duke@1 160
duke@1 161 /** The path name of the class file currently being read.
duke@1 162 */
duke@1 163 protected JavaFileObject currentClassFile = null;
duke@1 164
duke@1 165 /** The class or method currently being read.
duke@1 166 */
duke@1 167 protected Symbol currentOwner = null;
duke@1 168
duke@1 169 /** The buffer containing the currently read class file.
duke@1 170 */
duke@1 171 byte[] buf = new byte[0x0fff0];
duke@1 172
duke@1 173 /** The current input pointer.
duke@1 174 */
duke@1 175 int bp;
duke@1 176
duke@1 177 /** The objects of the constant pool.
duke@1 178 */
duke@1 179 Object[] poolObj;
duke@1 180
duke@1 181 /** For every constant pool entry, an index into buf where the
duke@1 182 * defining section of the entry is found.
duke@1 183 */
duke@1 184 int[] poolIdx;
duke@1 185
jjg@256 186 /** The major version number of the class file being read. */
jjg@256 187 int majorVersion;
jjg@256 188 /** The minor version number of the class file being read. */
jjg@256 189 int minorVersion;
jjg@256 190
jjg@308 191 /** Switch: debug output for JSR 308-related operations.
jjg@308 192 */
jjg@308 193 boolean debugJSR308;
jjg@308 194
jjg@428 195 /** A table to hold the constant pool indices for method parameter
jjg@428 196 * names, as given in LocalVariableTable attributes.
jjg@428 197 */
jjg@428 198 int[] parameterNameIndices;
jjg@428 199
jjg@428 200 /**
jjg@428 201 * Whether or not any parameter names have been found.
jjg@428 202 */
jjg@428 203 boolean haveParameterNameIndices;
jjg@428 204
duke@1 205 /** Get the ClassReader instance for this invocation. */
duke@1 206 public static ClassReader instance(Context context) {
duke@1 207 ClassReader instance = context.get(classReaderKey);
duke@1 208 if (instance == null)
duke@1 209 instance = new ClassReader(context, true);
duke@1 210 return instance;
duke@1 211 }
duke@1 212
duke@1 213 /** Initialize classes and packages, treating this as the definitive classreader. */
duke@1 214 public void init(Symtab syms) {
duke@1 215 init(syms, true);
duke@1 216 }
duke@1 217
duke@1 218 /** Initialize classes and packages, optionally treating this as
duke@1 219 * the definitive classreader.
duke@1 220 */
duke@1 221 private void init(Symtab syms, boolean definitive) {
duke@1 222 if (classes != null) return;
duke@1 223
duke@1 224 if (definitive) {
duke@1 225 assert packages == null || packages == syms.packages;
duke@1 226 packages = syms.packages;
duke@1 227 assert classes == null || classes == syms.classes;
duke@1 228 classes = syms.classes;
duke@1 229 } else {
duke@1 230 packages = new HashMap<Name, PackageSymbol>();
duke@1 231 classes = new HashMap<Name, ClassSymbol>();
duke@1 232 }
duke@1 233
duke@1 234 packages.put(names.empty, syms.rootPackage);
duke@1 235 syms.rootPackage.completer = this;
duke@1 236 syms.unnamedPackage.completer = this;
duke@1 237 }
duke@1 238
duke@1 239 /** Construct a new class reader, optionally treated as the
duke@1 240 * definitive classreader for this invocation.
duke@1 241 */
duke@1 242 protected ClassReader(Context context, boolean definitive) {
duke@1 243 if (definitive) context.put(classReaderKey, this);
duke@1 244
jjg@113 245 names = Names.instance(context);
duke@1 246 syms = Symtab.instance(context);
duke@1 247 types = Types.instance(context);
duke@1 248 fileManager = context.get(JavaFileManager.class);
duke@1 249 if (fileManager == null)
duke@1 250 throw new AssertionError("FileManager initialization error");
jjg@12 251 diagFactory = JCDiagnostic.Factory.instance(context);
duke@1 252
duke@1 253 init(syms, definitive);
duke@1 254 log = Log.instance(context);
duke@1 255
duke@1 256 Options options = Options.instance(context);
duke@1 257 annotate = Annotate.instance(context);
duke@1 258 verbose = options.get("-verbose") != null;
duke@1 259 checkClassFile = options.get("-checkclassfile") != null;
duke@1 260 Source source = Source.instance(context);
duke@1 261 allowGenerics = source.allowGenerics();
duke@1 262 allowVarargs = source.allowVarargs();
duke@1 263 allowAnnotations = source.allowAnnotations();
duke@1 264 saveParameterNames = options.get("save-parameter-names") != null;
duke@1 265 cacheCompletionFailure = options.get("dev") == null;
duke@1 266 preferSource = "source".equals(options.get("-Xprefer"));
duke@1 267
duke@1 268 completionFailureName =
duke@1 269 (options.get("failcomplete") != null)
duke@1 270 ? names.fromString(options.get("failcomplete"))
duke@1 271 : null;
duke@1 272
duke@1 273 typevars = new Scope(syms.noSymbol);
jjg@308 274 debugJSR308 = options.get("TA:reader") != null;
jjg@256 275
jjg@256 276 initAttributeReaders();
duke@1 277 }
duke@1 278
duke@1 279 /** Add member to class unless it is synthetic.
duke@1 280 */
duke@1 281 private void enterMember(ClassSymbol c, Symbol sym) {
duke@1 282 if ((sym.flags_field & (SYNTHETIC|BRIDGE)) != SYNTHETIC)
duke@1 283 c.members_field.enter(sym);
duke@1 284 }
duke@1 285
duke@1 286 /************************************************************************
duke@1 287 * Error Diagnoses
duke@1 288 ***********************************************************************/
duke@1 289
jjg@12 290
jjg@12 291 public class BadClassFile extends CompletionFailure {
duke@1 292 private static final long serialVersionUID = 0;
duke@1 293
jjg@12 294 public BadClassFile(TypeSymbol sym, JavaFileObject file, JCDiagnostic diag) {
jjg@12 295 super(sym, createBadClassFileDiagnostic(file, diag));
duke@1 296 }
duke@1 297 }
jjg@12 298 // where
jjg@12 299 private JCDiagnostic createBadClassFileDiagnostic(JavaFileObject file, JCDiagnostic diag) {
jjg@12 300 String key = (file.getKind() == JavaFileObject.Kind.SOURCE
jjg@12 301 ? "bad.source.file.header" : "bad.class.file.header");
jjg@12 302 return diagFactory.fragment(key, file, diag);
jjg@12 303 }
duke@1 304
duke@1 305 public BadClassFile badClassFile(String key, Object... args) {
duke@1 306 return new BadClassFile (
duke@1 307 currentOwner.enclClass(),
duke@1 308 currentClassFile,
jjg@12 309 diagFactory.fragment(key, args));
duke@1 310 }
duke@1 311
duke@1 312 /************************************************************************
duke@1 313 * Buffer Access
duke@1 314 ***********************************************************************/
duke@1 315
duke@1 316 /** Read a character.
duke@1 317 */
duke@1 318 char nextChar() {
duke@1 319 return (char)(((buf[bp++] & 0xFF) << 8) + (buf[bp++] & 0xFF));
duke@1 320 }
duke@1 321
jjg@308 322 /** Read a byte.
jjg@308 323 */
jjg@308 324 byte nextByte() {
jjg@308 325 return buf[bp++];
jjg@308 326 }
jjg@308 327
duke@1 328 /** Read an integer.
duke@1 329 */
duke@1 330 int nextInt() {
duke@1 331 return
duke@1 332 ((buf[bp++] & 0xFF) << 24) +
duke@1 333 ((buf[bp++] & 0xFF) << 16) +
duke@1 334 ((buf[bp++] & 0xFF) << 8) +
duke@1 335 (buf[bp++] & 0xFF);
duke@1 336 }
duke@1 337
duke@1 338 /** Extract a character at position bp from buf.
duke@1 339 */
duke@1 340 char getChar(int bp) {
duke@1 341 return
duke@1 342 (char)(((buf[bp] & 0xFF) << 8) + (buf[bp+1] & 0xFF));
duke@1 343 }
duke@1 344
duke@1 345 /** Extract an integer at position bp from buf.
duke@1 346 */
duke@1 347 int getInt(int bp) {
duke@1 348 return
duke@1 349 ((buf[bp] & 0xFF) << 24) +
duke@1 350 ((buf[bp+1] & 0xFF) << 16) +
duke@1 351 ((buf[bp+2] & 0xFF) << 8) +
duke@1 352 (buf[bp+3] & 0xFF);
duke@1 353 }
duke@1 354
duke@1 355
duke@1 356 /** Extract a long integer at position bp from buf.
duke@1 357 */
duke@1 358 long getLong(int bp) {
duke@1 359 DataInputStream bufin =
duke@1 360 new DataInputStream(new ByteArrayInputStream(buf, bp, 8));
duke@1 361 try {
duke@1 362 return bufin.readLong();
duke@1 363 } catch (IOException e) {
duke@1 364 throw new AssertionError(e);
duke@1 365 }
duke@1 366 }
duke@1 367
duke@1 368 /** Extract a float at position bp from buf.
duke@1 369 */
duke@1 370 float getFloat(int bp) {
duke@1 371 DataInputStream bufin =
duke@1 372 new DataInputStream(new ByteArrayInputStream(buf, bp, 4));
duke@1 373 try {
duke@1 374 return bufin.readFloat();
duke@1 375 } catch (IOException e) {
duke@1 376 throw new AssertionError(e);
duke@1 377 }
duke@1 378 }
duke@1 379
duke@1 380 /** Extract a double at position bp from buf.
duke@1 381 */
duke@1 382 double getDouble(int bp) {
duke@1 383 DataInputStream bufin =
duke@1 384 new DataInputStream(new ByteArrayInputStream(buf, bp, 8));
duke@1 385 try {
duke@1 386 return bufin.readDouble();
duke@1 387 } catch (IOException e) {
duke@1 388 throw new AssertionError(e);
duke@1 389 }
duke@1 390 }
duke@1 391
duke@1 392 /************************************************************************
duke@1 393 * Constant Pool Access
duke@1 394 ***********************************************************************/
duke@1 395
duke@1 396 /** Index all constant pool entries, writing their start addresses into
duke@1 397 * poolIdx.
duke@1 398 */
duke@1 399 void indexPool() {
duke@1 400 poolIdx = new int[nextChar()];
duke@1 401 poolObj = new Object[poolIdx.length];
duke@1 402 int i = 1;
duke@1 403 while (i < poolIdx.length) {
duke@1 404 poolIdx[i++] = bp;
duke@1 405 byte tag = buf[bp++];
duke@1 406 switch (tag) {
duke@1 407 case CONSTANT_Utf8: case CONSTANT_Unicode: {
duke@1 408 int len = nextChar();
duke@1 409 bp = bp + len;
duke@1 410 break;
duke@1 411 }
duke@1 412 case CONSTANT_Class:
duke@1 413 case CONSTANT_String:
duke@1 414 bp = bp + 2;
duke@1 415 break;
duke@1 416 case CONSTANT_Fieldref:
duke@1 417 case CONSTANT_Methodref:
duke@1 418 case CONSTANT_InterfaceMethodref:
duke@1 419 case CONSTANT_NameandType:
duke@1 420 case CONSTANT_Integer:
duke@1 421 case CONSTANT_Float:
duke@1 422 bp = bp + 4;
duke@1 423 break;
duke@1 424 case CONSTANT_Long:
duke@1 425 case CONSTANT_Double:
duke@1 426 bp = bp + 8;
duke@1 427 i++;
duke@1 428 break;
duke@1 429 default:
duke@1 430 throw badClassFile("bad.const.pool.tag.at",
duke@1 431 Byte.toString(tag),
duke@1 432 Integer.toString(bp -1));
duke@1 433 }
duke@1 434 }
duke@1 435 }
duke@1 436
duke@1 437 /** Read constant pool entry at start address i, use pool as a cache.
duke@1 438 */
duke@1 439 Object readPool(int i) {
duke@1 440 Object result = poolObj[i];
duke@1 441 if (result != null) return result;
duke@1 442
duke@1 443 int index = poolIdx[i];
duke@1 444 if (index == 0) return null;
duke@1 445
duke@1 446 byte tag = buf[index];
duke@1 447 switch (tag) {
duke@1 448 case CONSTANT_Utf8:
duke@1 449 poolObj[i] = names.fromUtf(buf, index + 3, getChar(index + 1));
duke@1 450 break;
duke@1 451 case CONSTANT_Unicode:
duke@1 452 throw badClassFile("unicode.str.not.supported");
duke@1 453 case CONSTANT_Class:
duke@1 454 poolObj[i] = readClassOrType(getChar(index + 1));
duke@1 455 break;
duke@1 456 case CONSTANT_String:
duke@1 457 // FIXME: (footprint) do not use toString here
duke@1 458 poolObj[i] = readName(getChar(index + 1)).toString();
duke@1 459 break;
duke@1 460 case CONSTANT_Fieldref: {
duke@1 461 ClassSymbol owner = readClassSymbol(getChar(index + 1));
duke@1 462 NameAndType nt = (NameAndType)readPool(getChar(index + 3));
duke@1 463 poolObj[i] = new VarSymbol(0, nt.name, nt.type, owner);
duke@1 464 break;
duke@1 465 }
duke@1 466 case CONSTANT_Methodref:
duke@1 467 case CONSTANT_InterfaceMethodref: {
duke@1 468 ClassSymbol owner = readClassSymbol(getChar(index + 1));
duke@1 469 NameAndType nt = (NameAndType)readPool(getChar(index + 3));
duke@1 470 poolObj[i] = new MethodSymbol(0, nt.name, nt.type, owner);
duke@1 471 break;
duke@1 472 }
duke@1 473 case CONSTANT_NameandType:
duke@1 474 poolObj[i] = new NameAndType(
duke@1 475 readName(getChar(index + 1)),
duke@1 476 readType(getChar(index + 3)));
duke@1 477 break;
duke@1 478 case CONSTANT_Integer:
duke@1 479 poolObj[i] = getInt(index + 1);
duke@1 480 break;
duke@1 481 case CONSTANT_Float:
duke@1 482 poolObj[i] = new Float(getFloat(index + 1));
duke@1 483 break;
duke@1 484 case CONSTANT_Long:
duke@1 485 poolObj[i] = new Long(getLong(index + 1));
duke@1 486 break;
duke@1 487 case CONSTANT_Double:
duke@1 488 poolObj[i] = new Double(getDouble(index + 1));
duke@1 489 break;
duke@1 490 default:
duke@1 491 throw badClassFile("bad.const.pool.tag", Byte.toString(tag));
duke@1 492 }
duke@1 493 return poolObj[i];
duke@1 494 }
duke@1 495
duke@1 496 /** Read signature and convert to type.
duke@1 497 */
duke@1 498 Type readType(int i) {
duke@1 499 int index = poolIdx[i];
duke@1 500 return sigToType(buf, index + 3, getChar(index + 1));
duke@1 501 }
duke@1 502
duke@1 503 /** If name is an array type or class signature, return the
duke@1 504 * corresponding type; otherwise return a ClassSymbol with given name.
duke@1 505 */
duke@1 506 Object readClassOrType(int i) {
duke@1 507 int index = poolIdx[i];
duke@1 508 int len = getChar(index + 1);
duke@1 509 int start = index + 3;
duke@1 510 assert buf[start] == '[' || buf[start + len - 1] != ';';
duke@1 511 // by the above assertion, the following test can be
duke@1 512 // simplified to (buf[start] == '[')
duke@1 513 return (buf[start] == '[' || buf[start + len - 1] == ';')
duke@1 514 ? (Object)sigToType(buf, start, len)
duke@1 515 : (Object)enterClass(names.fromUtf(internalize(buf, start,
duke@1 516 len)));
duke@1 517 }
duke@1 518
duke@1 519 /** Read signature and convert to type parameters.
duke@1 520 */
duke@1 521 List<Type> readTypeParams(int i) {
duke@1 522 int index = poolIdx[i];
duke@1 523 return sigToTypeParams(buf, index + 3, getChar(index + 1));
duke@1 524 }
duke@1 525
duke@1 526 /** Read class entry.
duke@1 527 */
duke@1 528 ClassSymbol readClassSymbol(int i) {
duke@1 529 return (ClassSymbol) (readPool(i));
duke@1 530 }
duke@1 531
duke@1 532 /** Read name.
duke@1 533 */
duke@1 534 Name readName(int i) {
duke@1 535 return (Name) (readPool(i));
duke@1 536 }
duke@1 537
duke@1 538 /************************************************************************
duke@1 539 * Reading Types
duke@1 540 ***********************************************************************/
duke@1 541
duke@1 542 /** The unread portion of the currently read type is
duke@1 543 * signature[sigp..siglimit-1].
duke@1 544 */
duke@1 545 byte[] signature;
duke@1 546 int sigp;
duke@1 547 int siglimit;
duke@1 548 boolean sigEnterPhase = false;
duke@1 549
duke@1 550 /** Convert signature to type, where signature is a byte array segment.
duke@1 551 */
duke@1 552 Type sigToType(byte[] sig, int offset, int len) {
duke@1 553 signature = sig;
duke@1 554 sigp = offset;
duke@1 555 siglimit = offset + len;
duke@1 556 return sigToType();
duke@1 557 }
duke@1 558
duke@1 559 /** Convert signature to type, where signature is implicit.
duke@1 560 */
duke@1 561 Type sigToType() {
duke@1 562 switch ((char) signature[sigp]) {
duke@1 563 case 'T':
duke@1 564 sigp++;
duke@1 565 int start = sigp;
duke@1 566 while (signature[sigp] != ';') sigp++;
duke@1 567 sigp++;
duke@1 568 return sigEnterPhase
duke@1 569 ? Type.noType
duke@1 570 : findTypeVar(names.fromUtf(signature, start, sigp - 1 - start));
duke@1 571 case '+': {
duke@1 572 sigp++;
duke@1 573 Type t = sigToType();
duke@1 574 return new WildcardType(t, BoundKind.EXTENDS,
duke@1 575 syms.boundClass);
duke@1 576 }
duke@1 577 case '*':
duke@1 578 sigp++;
duke@1 579 return new WildcardType(syms.objectType, BoundKind.UNBOUND,
duke@1 580 syms.boundClass);
duke@1 581 case '-': {
duke@1 582 sigp++;
duke@1 583 Type t = sigToType();
duke@1 584 return new WildcardType(t, BoundKind.SUPER,
duke@1 585 syms.boundClass);
duke@1 586 }
duke@1 587 case 'B':
duke@1 588 sigp++;
duke@1 589 return syms.byteType;
duke@1 590 case 'C':
duke@1 591 sigp++;
duke@1 592 return syms.charType;
duke@1 593 case 'D':
duke@1 594 sigp++;
duke@1 595 return syms.doubleType;
duke@1 596 case 'F':
duke@1 597 sigp++;
duke@1 598 return syms.floatType;
duke@1 599 case 'I':
duke@1 600 sigp++;
duke@1 601 return syms.intType;
duke@1 602 case 'J':
duke@1 603 sigp++;
duke@1 604 return syms.longType;
duke@1 605 case 'L':
duke@1 606 {
duke@1 607 // int oldsigp = sigp;
duke@1 608 Type t = classSigToType();
duke@1 609 if (sigp < siglimit && signature[sigp] == '.')
duke@1 610 throw badClassFile("deprecated inner class signature syntax " +
duke@1 611 "(please recompile from source)");
duke@1 612 /*
duke@1 613 System.err.println(" decoded " +
duke@1 614 new String(signature, oldsigp, sigp-oldsigp) +
duke@1 615 " => " + t + " outer " + t.outer());
duke@1 616 */
duke@1 617 return t;
duke@1 618 }
duke@1 619 case 'S':
duke@1 620 sigp++;
duke@1 621 return syms.shortType;
duke@1 622 case 'V':
duke@1 623 sigp++;
duke@1 624 return syms.voidType;
duke@1 625 case 'Z':
duke@1 626 sigp++;
duke@1 627 return syms.booleanType;
duke@1 628 case '[':
duke@1 629 sigp++;
duke@1 630 return new ArrayType(sigToType(), syms.arrayClass);
duke@1 631 case '(':
duke@1 632 sigp++;
duke@1 633 List<Type> argtypes = sigToTypes(')');
duke@1 634 Type restype = sigToType();
duke@1 635 List<Type> thrown = List.nil();
duke@1 636 while (signature[sigp] == '^') {
duke@1 637 sigp++;
duke@1 638 thrown = thrown.prepend(sigToType());
duke@1 639 }
duke@1 640 return new MethodType(argtypes,
duke@1 641 restype,
duke@1 642 thrown.reverse(),
duke@1 643 syms.methodClass);
duke@1 644 case '<':
duke@1 645 typevars = typevars.dup(currentOwner);
duke@1 646 Type poly = new ForAll(sigToTypeParams(), sigToType());
duke@1 647 typevars = typevars.leave();
duke@1 648 return poly;
duke@1 649 default:
duke@1 650 throw badClassFile("bad.signature",
duke@1 651 Convert.utf2string(signature, sigp, 10));
duke@1 652 }
duke@1 653 }
duke@1 654
duke@1 655 byte[] signatureBuffer = new byte[0];
duke@1 656 int sbp = 0;
duke@1 657 /** Convert class signature to type, where signature is implicit.
duke@1 658 */
duke@1 659 Type classSigToType() {
duke@1 660 if (signature[sigp] != 'L')
duke@1 661 throw badClassFile("bad.class.signature",
duke@1 662 Convert.utf2string(signature, sigp, 10));
duke@1 663 sigp++;
duke@1 664 Type outer = Type.noType;
duke@1 665 int startSbp = sbp;
duke@1 666
duke@1 667 while (true) {
duke@1 668 final byte c = signature[sigp++];
duke@1 669 switch (c) {
duke@1 670
duke@1 671 case ';': { // end
duke@1 672 ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,
duke@1 673 startSbp,
duke@1 674 sbp - startSbp));
duke@1 675 if (outer == Type.noType)
duke@1 676 outer = t.erasure(types);
duke@1 677 else
duke@1 678 outer = new ClassType(outer, List.<Type>nil(), t);
duke@1 679 sbp = startSbp;
duke@1 680 return outer;
duke@1 681 }
duke@1 682
duke@1 683 case '<': // generic arguments
duke@1 684 ClassSymbol t = enterClass(names.fromUtf(signatureBuffer,
duke@1 685 startSbp,
duke@1 686 sbp - startSbp));
duke@1 687 outer = new ClassType(outer, sigToTypes('>'), t) {
duke@1 688 boolean completed = false;
jjg@256 689 @Override
duke@1 690 public Type getEnclosingType() {
duke@1 691 if (!completed) {
duke@1 692 completed = true;
duke@1 693 tsym.complete();
duke@1 694 Type enclosingType = tsym.type.getEnclosingType();
duke@1 695 if (enclosingType != Type.noType) {
duke@1 696 List<Type> typeArgs =
duke@1 697 super.getEnclosingType().allparams();
duke@1 698 List<Type> typeParams =
duke@1 699 enclosingType.allparams();
duke@1 700 if (typeParams.length() != typeArgs.length()) {
duke@1 701 // no "rare" types
duke@1 702 super.setEnclosingType(types.erasure(enclosingType));
duke@1 703 } else {
duke@1 704 super.setEnclosingType(types.subst(enclosingType,
duke@1 705 typeParams,
duke@1 706 typeArgs));
duke@1 707 }
duke@1 708 } else {
duke@1 709 super.setEnclosingType(Type.noType);
duke@1 710 }
duke@1 711 }
duke@1 712 return super.getEnclosingType();
duke@1 713 }
jjg@256 714 @Override
duke@1 715 public void setEnclosingType(Type outer) {
duke@1 716 throw new UnsupportedOperationException();
duke@1 717 }
duke@1 718 };
duke@1 719 switch (signature[sigp++]) {
duke@1 720 case ';':
duke@1 721 if (sigp < signature.length && signature[sigp] == '.') {
duke@1 722 // support old-style GJC signatures
duke@1 723 // The signature produced was
duke@1 724 // Lfoo/Outer<Lfoo/X;>;.Lfoo/Outer$Inner<Lfoo/Y;>;
duke@1 725 // rather than say
duke@1 726 // Lfoo/Outer<Lfoo/X;>.Inner<Lfoo/Y;>;
duke@1 727 // so we skip past ".Lfoo/Outer$"
duke@1 728 sigp += (sbp - startSbp) + // "foo/Outer"
duke@1 729 3; // ".L" and "$"
duke@1 730 signatureBuffer[sbp++] = (byte)'$';
duke@1 731 break;
duke@1 732 } else {
duke@1 733 sbp = startSbp;
duke@1 734 return outer;
duke@1 735 }
duke@1 736 case '.':
duke@1 737 signatureBuffer[sbp++] = (byte)'$';
duke@1 738 break;
duke@1 739 default:
duke@1 740 throw new AssertionError(signature[sigp-1]);
duke@1 741 }
duke@1 742 continue;
duke@1 743
duke@1 744 case '.':
duke@1 745 signatureBuffer[sbp++] = (byte)'$';
duke@1 746 continue;
duke@1 747 case '/':
duke@1 748 signatureBuffer[sbp++] = (byte)'.';
duke@1 749 continue;
duke@1 750 default:
duke@1 751 signatureBuffer[sbp++] = c;
duke@1 752 continue;
duke@1 753 }
duke@1 754 }
duke@1 755 }
duke@1 756
duke@1 757 /** Convert (implicit) signature to list of types
duke@1 758 * until `terminator' is encountered.
duke@1 759 */
duke@1 760 List<Type> sigToTypes(char terminator) {
duke@1 761 List<Type> head = List.of(null);
duke@1 762 List<Type> tail = head;
duke@1 763 while (signature[sigp] != terminator)
duke@1 764 tail = tail.setTail(List.of(sigToType()));
duke@1 765 sigp++;
duke@1 766 return head.tail;
duke@1 767 }
duke@1 768
duke@1 769 /** Convert signature to type parameters, where signature is a byte
duke@1 770 * array segment.
duke@1 771 */
duke@1 772 List<Type> sigToTypeParams(byte[] sig, int offset, int len) {
duke@1 773 signature = sig;
duke@1 774 sigp = offset;
duke@1 775 siglimit = offset + len;
duke@1 776 return sigToTypeParams();
duke@1 777 }
duke@1 778
duke@1 779 /** Convert signature to type parameters, where signature is implicit.
duke@1 780 */
duke@1 781 List<Type> sigToTypeParams() {
duke@1 782 List<Type> tvars = List.nil();
duke@1 783 if (signature[sigp] == '<') {
duke@1 784 sigp++;
duke@1 785 int start = sigp;
duke@1 786 sigEnterPhase = true;
duke@1 787 while (signature[sigp] != '>')
duke@1 788 tvars = tvars.prepend(sigToTypeParam());
duke@1 789 sigEnterPhase = false;
duke@1 790 sigp = start;
duke@1 791 while (signature[sigp] != '>')
duke@1 792 sigToTypeParam();
duke@1 793 sigp++;
duke@1 794 }
duke@1 795 return tvars.reverse();
duke@1 796 }
duke@1 797
duke@1 798 /** Convert (implicit) signature to type parameter.
duke@1 799 */
duke@1 800 Type sigToTypeParam() {
duke@1 801 int start = sigp;
duke@1 802 while (signature[sigp] != ':') sigp++;
duke@1 803 Name name = names.fromUtf(signature, start, sigp - start);
duke@1 804 TypeVar tvar;
duke@1 805 if (sigEnterPhase) {
duke@1 806 tvar = new TypeVar(name, currentOwner, syms.botType);
duke@1 807 typevars.enter(tvar.tsym);
duke@1 808 } else {
duke@1 809 tvar = (TypeVar)findTypeVar(name);
duke@1 810 }
duke@1 811 List<Type> bounds = List.nil();
duke@1 812 Type st = null;
duke@1 813 if (signature[sigp] == ':' && signature[sigp+1] == ':') {
duke@1 814 sigp++;
duke@1 815 st = syms.objectType;
duke@1 816 }
duke@1 817 while (signature[sigp] == ':') {
duke@1 818 sigp++;
duke@1 819 bounds = bounds.prepend(sigToType());
duke@1 820 }
duke@1 821 if (!sigEnterPhase) {
duke@1 822 types.setBounds(tvar, bounds.reverse(), st);
duke@1 823 }
duke@1 824 return tvar;
duke@1 825 }
duke@1 826
duke@1 827 /** Find type variable with given name in `typevars' scope.
duke@1 828 */
duke@1 829 Type findTypeVar(Name name) {
duke@1 830 Scope.Entry e = typevars.lookup(name);
duke@1 831 if (e.scope != null) {
duke@1 832 return e.sym.type;
duke@1 833 } else {
duke@1 834 if (readingClassAttr) {
duke@1 835 // While reading the class attribute, the supertypes
duke@1 836 // might refer to a type variable from an enclosing element
duke@1 837 // (method or class).
duke@1 838 // If the type variable is defined in the enclosing class,
duke@1 839 // we can actually find it in
duke@1 840 // currentOwner.owner.type.getTypeArguments()
duke@1 841 // However, until we have read the enclosing method attribute
duke@1 842 // we don't know for sure if this owner is correct. It could
duke@1 843 // be a method and there is no way to tell before reading the
duke@1 844 // enclosing method attribute.
duke@1 845 TypeVar t = new TypeVar(name, currentOwner, syms.botType);
duke@1 846 missingTypeVariables = missingTypeVariables.prepend(t);
duke@1 847 // System.err.println("Missing type var " + name);
duke@1 848 return t;
duke@1 849 }
duke@1 850 throw badClassFile("undecl.type.var", name);
duke@1 851 }
duke@1 852 }
duke@1 853
duke@1 854 /************************************************************************
duke@1 855 * Reading Attributes
duke@1 856 ***********************************************************************/
duke@1 857
jjg@256 858 protected enum AttributeKind { CLASS, MEMBER };
jjg@256 859 protected abstract class AttributeReader {
jjg@256 860 AttributeReader(Name name, Version version, Set<AttributeKind> kinds) {
jjg@256 861 this.name = name;
jjg@256 862 this.version = version;
jjg@256 863 this.kinds = kinds;
jjg@256 864 }
jjg@256 865
jjg@256 866 boolean accepts(AttributeKind kind) {
jjg@256 867 return kinds.contains(kind) && majorVersion >= version.major;
jjg@256 868 }
jjg@256 869
jjg@256 870 abstract void read(Symbol sym, int attrLen);
jjg@256 871
jjg@256 872 final Name name;
jjg@256 873 final Version version;
jjg@256 874 final Set<AttributeKind> kinds;
jjg@256 875 }
jjg@256 876
jjg@256 877 protected Set<AttributeKind> CLASS_ATTRIBUTE =
jjg@256 878 EnumSet.of(AttributeKind.CLASS);
jjg@256 879 protected Set<AttributeKind> MEMBER_ATTRIBUTE =
jjg@256 880 EnumSet.of(AttributeKind.MEMBER);
jjg@256 881 protected Set<AttributeKind> CLASS_OR_MEMBER_ATTRIBUTE =
jjg@256 882 EnumSet.of(AttributeKind.CLASS, AttributeKind.MEMBER);
jjg@256 883
jjg@256 884 protected Map<Name, AttributeReader> attributeReaders = new HashMap<Name, AttributeReader>();
jjg@256 885
jjg@256 886 protected void initAttributeReaders() {
jjg@256 887 AttributeReader[] readers = {
jjg@256 888 // v45.3 attributes
jjg@256 889
jjg@256 890 new AttributeReader(names.Code, V45_3, MEMBER_ATTRIBUTE) {
jjg@256 891 void read(Symbol sym, int attrLen) {
jjg@256 892 if (readAllOfClassFile || saveParameterNames)
jjg@256 893 ((MethodSymbol)sym).code = readCode(sym);
jjg@256 894 else
jjg@256 895 bp = bp + attrLen;
jjg@256 896 }
jjg@256 897 },
jjg@256 898
jjg@256 899 new AttributeReader(names.ConstantValue, V45_3, MEMBER_ATTRIBUTE) {
jjg@256 900 void read(Symbol sym, int attrLen) {
jjg@256 901 Object v = readPool(nextChar());
jjg@256 902 // Ignore ConstantValue attribute if field not final.
jjg@256 903 if ((sym.flags() & FINAL) != 0)
jjg@256 904 ((VarSymbol) sym).setData(v);
jjg@256 905 }
jjg@256 906 },
jjg@256 907
jjg@256 908 new AttributeReader(names.Deprecated, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 909 void read(Symbol sym, int attrLen) {
jjg@256 910 sym.flags_field |= DEPRECATED;
jjg@256 911 }
jjg@256 912 },
jjg@256 913
jjg@256 914 new AttributeReader(names.Exceptions, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 915 void read(Symbol sym, int attrLen) {
jjg@256 916 int nexceptions = nextChar();
jjg@256 917 List<Type> thrown = List.nil();
jjg@256 918 for (int j = 0; j < nexceptions; j++)
jjg@256 919 thrown = thrown.prepend(readClassSymbol(nextChar()).type);
jjg@256 920 if (sym.type.getThrownTypes().isEmpty())
jjg@256 921 sym.type.asMethodType().thrown = thrown.reverse();
jjg@256 922 }
jjg@256 923 },
jjg@256 924
jjg@256 925 new AttributeReader(names.InnerClasses, V45_3, CLASS_ATTRIBUTE) {
jjg@256 926 void read(Symbol sym, int attrLen) {
jjg@256 927 ClassSymbol c = (ClassSymbol) sym;
jjg@256 928 readInnerClasses(c);
jjg@256 929 }
jjg@256 930 },
jjg@256 931
jjg@256 932 new AttributeReader(names.LocalVariableTable, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 933 void read(Symbol sym, int attrLen) {
jjg@256 934 int newbp = bp + attrLen;
jjg@256 935 if (saveParameterNames) {
jjg@428 936 // Pick up parameter names from the variable table.
jjg@428 937 // Parameter names are not explicitly identified as such,
jjg@428 938 // but all parameter name entries in the LocalVariableTable
jjg@428 939 // have a start_pc of 0. Therefore, we record the name
jjg@428 940 // indicies of all slots with a start_pc of zero in the
jjg@428 941 // parameterNameIndicies array.
jjg@428 942 // Note that this implicitly honors the JVMS spec that
jjg@428 943 // there may be more than one LocalVariableTable, and that
jjg@428 944 // there is no specified ordering for the entries.
jjg@256 945 int numEntries = nextChar();
jjg@428 946 for (int i = 0; i < numEntries; i++) {
jjg@256 947 int start_pc = nextChar();
jjg@256 948 int length = nextChar();
jjg@256 949 int nameIndex = nextChar();
jjg@256 950 int sigIndex = nextChar();
jjg@256 951 int register = nextChar();
jjg@428 952 if (start_pc == 0) {
jjg@428 953 // ensure array large enough
jjg@428 954 if (register >= parameterNameIndices.length) {
jjg@428 955 int newSize = Math.max(register, parameterNameIndices.length + 8);
jjg@428 956 parameterNameIndices =
jjg@428 957 Arrays.copyOf(parameterNameIndices, newSize);
jjg@256 958 }
jjg@428 959 parameterNameIndices[register] = nameIndex;
jjg@428 960 haveParameterNameIndices = true;
jjg@256 961 }
jjg@256 962 }
jjg@256 963 }
jjg@256 964 bp = newbp;
jjg@256 965 }
jjg@256 966 },
jjg@256 967
jjg@256 968 new AttributeReader(names.SourceFile, V45_3, CLASS_ATTRIBUTE) {
jjg@256 969 void read(Symbol sym, int attrLen) {
jjg@256 970 ClassSymbol c = (ClassSymbol) sym;
jjg@256 971 Name n = readName(nextChar());
jjg@256 972 c.sourcefile = new SourceFileObject(n, c.flatname);
jjg@256 973 }
jjg@256 974 },
jjg@256 975
jjg@256 976 new AttributeReader(names.Synthetic, V45_3, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 977 void read(Symbol sym, int attrLen) {
jjg@256 978 // bridge methods are visible when generics not enabled
jjg@256 979 if (allowGenerics || (sym.flags_field & BRIDGE) == 0)
jjg@256 980 sym.flags_field |= SYNTHETIC;
jjg@256 981 }
jjg@256 982 },
jjg@256 983
jjg@256 984 // standard v49 attributes
jjg@256 985
jjg@256 986 new AttributeReader(names.EnclosingMethod, V49, CLASS_ATTRIBUTE) {
jjg@256 987 void read(Symbol sym, int attrLen) {
jjg@256 988 int newbp = bp + attrLen;
jjg@256 989 readEnclosingMethodAttr(sym);
jjg@256 990 bp = newbp;
jjg@256 991 }
jjg@256 992 },
jjg@256 993
jjg@256 994 new AttributeReader(names.Signature, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 995 @Override
jjg@256 996 boolean accepts(AttributeKind kind) {
jjg@256 997 return super.accepts(kind) && allowGenerics;
jjg@256 998 }
jjg@256 999
jjg@256 1000 void read(Symbol sym, int attrLen) {
jjg@256 1001 if (sym.kind == TYP) {
jjg@256 1002 ClassSymbol c = (ClassSymbol) sym;
jjg@256 1003 readingClassAttr = true;
jjg@256 1004 try {
jjg@256 1005 ClassType ct1 = (ClassType)c.type;
jjg@256 1006 assert c == currentOwner;
jjg@256 1007 ct1.typarams_field = readTypeParams(nextChar());
jjg@256 1008 ct1.supertype_field = sigToType();
jjg@256 1009 ListBuffer<Type> is = new ListBuffer<Type>();
jjg@256 1010 while (sigp != siglimit) is.append(sigToType());
jjg@256 1011 ct1.interfaces_field = is.toList();
jjg@256 1012 } finally {
jjg@256 1013 readingClassAttr = false;
jjg@256 1014 }
jjg@256 1015 } else {
jjg@256 1016 List<Type> thrown = sym.type.getThrownTypes();
jjg@256 1017 sym.type = readType(nextChar());
jjg@256 1018 //- System.err.println(" # " + sym.type);
jjg@256 1019 if (sym.kind == MTH && sym.type.getThrownTypes().isEmpty())
jjg@256 1020 sym.type.asMethodType().thrown = thrown;
jjg@256 1021
jjg@256 1022 }
jjg@256 1023 }
jjg@256 1024 },
jjg@256 1025
jjg@256 1026 // v49 annotation attributes
jjg@256 1027
jjg@256 1028 new AttributeReader(names.AnnotationDefault, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1029 void read(Symbol sym, int attrLen) {
jjg@256 1030 attachAnnotationDefault(sym);
jjg@256 1031 }
jjg@256 1032 },
jjg@256 1033
jjg@256 1034 new AttributeReader(names.RuntimeInvisibleAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1035 void read(Symbol sym, int attrLen) {
jjg@256 1036 attachAnnotations(sym);
jjg@256 1037 }
jjg@256 1038 },
jjg@256 1039
jjg@256 1040 new AttributeReader(names.RuntimeInvisibleParameterAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1041 void read(Symbol sym, int attrLen) {
jjg@256 1042 attachParameterAnnotations(sym);
jjg@256 1043 }
jjg@256 1044 },
jjg@256 1045
jjg@256 1046 new AttributeReader(names.RuntimeVisibleAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1047 void read(Symbol sym, int attrLen) {
jjg@256 1048 attachAnnotations(sym);
jjg@256 1049 }
jjg@256 1050 },
jjg@256 1051
jjg@256 1052 new AttributeReader(names.RuntimeVisibleParameterAnnotations, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1053 void read(Symbol sym, int attrLen) {
jjg@256 1054 attachParameterAnnotations(sym);
jjg@256 1055 }
jjg@256 1056 },
jjg@256 1057
jjg@256 1058 // additional "legacy" v49 attributes, superceded by flags
jjg@256 1059
jjg@256 1060 new AttributeReader(names.Annotation, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1061 void read(Symbol sym, int attrLen) {
jjg@256 1062 if (allowAnnotations)
jjg@256 1063 sym.flags_field |= ANNOTATION;
jjg@256 1064 }
jjg@256 1065 },
jjg@256 1066
jjg@256 1067 new AttributeReader(names.Bridge, V49, MEMBER_ATTRIBUTE) {
jjg@256 1068 void read(Symbol sym, int attrLen) {
jjg@256 1069 sym.flags_field |= BRIDGE;
jjg@256 1070 if (!allowGenerics)
jjg@256 1071 sym.flags_field &= ~SYNTHETIC;
jjg@256 1072 }
jjg@256 1073 },
jjg@256 1074
jjg@256 1075 new AttributeReader(names.Enum, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1076 void read(Symbol sym, int attrLen) {
jjg@256 1077 sym.flags_field |= ENUM;
jjg@256 1078 }
jjg@256 1079 },
jjg@256 1080
jjg@256 1081 new AttributeReader(names.Varargs, V49, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@256 1082 void read(Symbol sym, int attrLen) {
jjg@256 1083 if (allowVarargs)
jjg@256 1084 sym.flags_field |= VARARGS;
jjg@256 1085 }
jjg@308 1086 },
jjg@308 1087
jjg@308 1088 // v51 attributes
jjg@308 1089 new AttributeReader(names.RuntimeVisibleTypeAnnotations, V51, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@308 1090 void read(Symbol sym, int attrLen) {
jjg@308 1091 attachTypeAnnotations(sym);
jjg@308 1092 }
jjg@308 1093 },
jjg@308 1094
jjg@308 1095 new AttributeReader(names.RuntimeInvisibleTypeAnnotations, V51, CLASS_OR_MEMBER_ATTRIBUTE) {
jjg@308 1096 void read(Symbol sym, int attrLen) {
jjg@308 1097 attachTypeAnnotations(sym);
jjg@308 1098 }
jjg@308 1099 },
jjg@308 1100
jrose@571 1101 new AttributeReader(names.PolymorphicSignature, V45_3/*S.B.V51*/, CLASS_OR_MEMBER_ATTRIBUTE) {
jrose@571 1102 void read(Symbol sym, int attrLen) {
jrose@571 1103 sym.flags_field |= POLYMORPHIC_SIGNATURE;
jrose@571 1104 }
jrose@571 1105 },
jrose@571 1106
jjg@256 1107
jjg@256 1108 // The following attributes for a Code attribute are not currently handled
jjg@256 1109 // StackMapTable
jjg@256 1110 // SourceDebugExtension
jjg@256 1111 // LineNumberTable
jjg@256 1112 // LocalVariableTypeTable
jjg@256 1113 };
jjg@256 1114
jjg@256 1115 for (AttributeReader r: readers)
jjg@256 1116 attributeReaders.put(r.name, r);
jjg@256 1117 }
jjg@256 1118
duke@1 1119 /** Report unrecognized attribute.
duke@1 1120 */
duke@1 1121 void unrecognized(Name attrName) {
duke@1 1122 if (checkClassFile)
duke@1 1123 printCCF("ccf.unrecognized.attribute", attrName);
duke@1 1124 }
duke@1 1125
jjg@256 1126
duke@1 1127
duke@1 1128 void readEnclosingMethodAttr(Symbol sym) {
duke@1 1129 // sym is a nested class with an "Enclosing Method" attribute
duke@1 1130 // remove sym from it's current owners scope and place it in
duke@1 1131 // the scope specified by the attribute
duke@1 1132 sym.owner.members().remove(sym);
duke@1 1133 ClassSymbol self = (ClassSymbol)sym;
duke@1 1134 ClassSymbol c = readClassSymbol(nextChar());
duke@1 1135 NameAndType nt = (NameAndType)readPool(nextChar());
duke@1 1136
duke@1 1137 MethodSymbol m = findMethod(nt, c.members_field, self.flags());
duke@1 1138 if (nt != null && m == null)
duke@1 1139 throw badClassFile("bad.enclosing.method", self);
duke@1 1140
duke@1 1141 self.name = simpleBinaryName(self.flatname, c.flatname) ;
duke@1 1142 self.owner = m != null ? m : c;
jjg@113 1143 if (self.name.isEmpty())
darcy@515 1144 self.fullname = names.empty;
duke@1 1145 else
duke@1 1146 self.fullname = ClassSymbol.formFullName(self.name, self.owner);
duke@1 1147
duke@1 1148 if (m != null) {
duke@1 1149 ((ClassType)sym.type).setEnclosingType(m.type);
duke@1 1150 } else if ((self.flags_field & STATIC) == 0) {
duke@1 1151 ((ClassType)sym.type).setEnclosingType(c.type);
duke@1 1152 } else {
duke@1 1153 ((ClassType)sym.type).setEnclosingType(Type.noType);
duke@1 1154 }
duke@1 1155 enterTypevars(self);
duke@1 1156 if (!missingTypeVariables.isEmpty()) {
duke@1 1157 ListBuffer<Type> typeVars = new ListBuffer<Type>();
duke@1 1158 for (Type typevar : missingTypeVariables) {
duke@1 1159 typeVars.append(findTypeVar(typevar.tsym.name));
duke@1 1160 }
duke@1 1161 foundTypeVariables = typeVars.toList();
duke@1 1162 } else {
duke@1 1163 foundTypeVariables = List.nil();
duke@1 1164 }
duke@1 1165 }
duke@1 1166
duke@1 1167 // See java.lang.Class
duke@1 1168 private Name simpleBinaryName(Name self, Name enclosing) {
duke@1 1169 String simpleBinaryName = self.toString().substring(enclosing.toString().length());
duke@1 1170 if (simpleBinaryName.length() < 1 || simpleBinaryName.charAt(0) != '$')
duke@1 1171 throw badClassFile("bad.enclosing.method", self);
duke@1 1172 int index = 1;
duke@1 1173 while (index < simpleBinaryName.length() &&
duke@1 1174 isAsciiDigit(simpleBinaryName.charAt(index)))
duke@1 1175 index++;
duke@1 1176 return names.fromString(simpleBinaryName.substring(index));
duke@1 1177 }
duke@1 1178
duke@1 1179 private MethodSymbol findMethod(NameAndType nt, Scope scope, long flags) {
duke@1 1180 if (nt == null)
duke@1 1181 return null;
duke@1 1182
duke@1 1183 MethodType type = nt.type.asMethodType();
duke@1 1184
duke@1 1185 for (Scope.Entry e = scope.lookup(nt.name); e.scope != null; e = e.next())
duke@1 1186 if (e.sym.kind == MTH && isSameBinaryType(e.sym.type.asMethodType(), type))
duke@1 1187 return (MethodSymbol)e.sym;
duke@1 1188
duke@1 1189 if (nt.name != names.init)
duke@1 1190 // not a constructor
duke@1 1191 return null;
duke@1 1192 if ((flags & INTERFACE) != 0)
duke@1 1193 // no enclosing instance
duke@1 1194 return null;
duke@1 1195 if (nt.type.getParameterTypes().isEmpty())
duke@1 1196 // no parameters
duke@1 1197 return null;
duke@1 1198
duke@1 1199 // A constructor of an inner class.
duke@1 1200 // Remove the first argument (the enclosing instance)
duke@1 1201 nt.type = new MethodType(nt.type.getParameterTypes().tail,
duke@1 1202 nt.type.getReturnType(),
duke@1 1203 nt.type.getThrownTypes(),
duke@1 1204 syms.methodClass);
duke@1 1205 // Try searching again
duke@1 1206 return findMethod(nt, scope, flags);
duke@1 1207 }
duke@1 1208
duke@1 1209 /** Similar to Types.isSameType but avoids completion */
duke@1 1210 private boolean isSameBinaryType(MethodType mt1, MethodType mt2) {
duke@1 1211 List<Type> types1 = types.erasure(mt1.getParameterTypes())
duke@1 1212 .prepend(types.erasure(mt1.getReturnType()));
duke@1 1213 List<Type> types2 = mt2.getParameterTypes().prepend(mt2.getReturnType());
duke@1 1214 while (!types1.isEmpty() && !types2.isEmpty()) {
duke@1 1215 if (types1.head.tsym != types2.head.tsym)
duke@1 1216 return false;
duke@1 1217 types1 = types1.tail;
duke@1 1218 types2 = types2.tail;
duke@1 1219 }
duke@1 1220 return types1.isEmpty() && types2.isEmpty();
duke@1 1221 }
duke@1 1222
duke@1 1223 /**
duke@1 1224 * Character.isDigit answers <tt>true</tt> to some non-ascii
duke@1 1225 * digits. This one does not. <b>copied from java.lang.Class</b>
duke@1 1226 */
duke@1 1227 private static boolean isAsciiDigit(char c) {
duke@1 1228 return '0' <= c && c <= '9';
duke@1 1229 }
duke@1 1230
duke@1 1231 /** Read member attributes.
duke@1 1232 */
duke@1 1233 void readMemberAttrs(Symbol sym) {
jjg@256 1234 readAttrs(sym, AttributeKind.MEMBER);
jjg@256 1235 }
jjg@256 1236
jjg@256 1237 void readAttrs(Symbol sym, AttributeKind kind) {
duke@1 1238 char ac = nextChar();
duke@1 1239 for (int i = 0; i < ac; i++) {
duke@1 1240 Name attrName = readName(nextChar());
duke@1 1241 int attrLen = nextInt();
jjg@256 1242 AttributeReader r = attributeReaders.get(attrName);
jjg@256 1243 if (r != null && r.accepts(kind))
jjg@256 1244 r.read(sym, attrLen);
jjg@256 1245 else {
jjg@256 1246 unrecognized(attrName);
jjg@256 1247 bp = bp + attrLen;
jjg@256 1248 }
duke@1 1249 }
duke@1 1250 }
duke@1 1251
duke@1 1252 private boolean readingClassAttr = false;
duke@1 1253 private List<Type> missingTypeVariables = List.nil();
duke@1 1254 private List<Type> foundTypeVariables = List.nil();
duke@1 1255
duke@1 1256 /** Read class attributes.
duke@1 1257 */
duke@1 1258 void readClassAttrs(ClassSymbol c) {
jjg@256 1259 readAttrs(c, AttributeKind.CLASS);
duke@1 1260 }
duke@1 1261
duke@1 1262 /** Read code block.
duke@1 1263 */
duke@1 1264 Code readCode(Symbol owner) {
duke@1 1265 nextChar(); // max_stack
duke@1 1266 nextChar(); // max_locals
duke@1 1267 final int code_length = nextInt();
duke@1 1268 bp += code_length;
duke@1 1269 final char exception_table_length = nextChar();
duke@1 1270 bp += exception_table_length * 8;
duke@1 1271 readMemberAttrs(owner);
duke@1 1272 return null;
duke@1 1273 }
duke@1 1274
duke@1 1275 /************************************************************************
duke@1 1276 * Reading Java-language annotations
duke@1 1277 ***********************************************************************/
duke@1 1278
duke@1 1279 /** Attach annotations.
duke@1 1280 */
duke@1 1281 void attachAnnotations(final Symbol sym) {
duke@1 1282 int numAttributes = nextChar();
duke@1 1283 if (numAttributes != 0) {
duke@1 1284 ListBuffer<CompoundAnnotationProxy> proxies =
duke@1 1285 new ListBuffer<CompoundAnnotationProxy>();
duke@1 1286 for (int i = 0; i<numAttributes; i++) {
duke@1 1287 CompoundAnnotationProxy proxy = readCompoundAnnotation();
duke@1 1288 if (proxy.type.tsym == syms.proprietaryType.tsym)
duke@1 1289 sym.flags_field |= PROPRIETARY;
duke@1 1290 else
duke@1 1291 proxies.append(proxy);
duke@1 1292 }
duke@1 1293 annotate.later(new AnnotationCompleter(sym, proxies.toList()));
duke@1 1294 }
duke@1 1295 }
duke@1 1296
duke@1 1297 /** Attach parameter annotations.
duke@1 1298 */
duke@1 1299 void attachParameterAnnotations(final Symbol method) {
duke@1 1300 final MethodSymbol meth = (MethodSymbol)method;
duke@1 1301 int numParameters = buf[bp++] & 0xFF;
duke@1 1302 List<VarSymbol> parameters = meth.params();
duke@1 1303 int pnum = 0;
duke@1 1304 while (parameters.tail != null) {
duke@1 1305 attachAnnotations(parameters.head);
duke@1 1306 parameters = parameters.tail;
duke@1 1307 pnum++;
duke@1 1308 }
duke@1 1309 if (pnum != numParameters) {
duke@1 1310 throw badClassFile("bad.runtime.invisible.param.annotations", meth);
duke@1 1311 }
duke@1 1312 }
duke@1 1313
jjg@308 1314 void attachTypeAnnotations(final Symbol sym) {
jjg@308 1315 int numAttributes = nextChar();
jjg@308 1316 if (numAttributes != 0) {
jjg@308 1317 ListBuffer<TypeAnnotationProxy> proxies =
jjg@308 1318 ListBuffer.lb();
jjg@308 1319 for (int i = 0; i < numAttributes; i++)
jjg@308 1320 proxies.append(readTypeAnnotation());
jjg@308 1321 annotate.later(new TypeAnnotationCompleter(sym, proxies.toList()));
jjg@308 1322 }
jjg@308 1323 }
jjg@308 1324
duke@1 1325 /** Attach the default value for an annotation element.
duke@1 1326 */
duke@1 1327 void attachAnnotationDefault(final Symbol sym) {
duke@1 1328 final MethodSymbol meth = (MethodSymbol)sym; // only on methods
duke@1 1329 final Attribute value = readAttributeValue();
duke@1 1330 annotate.later(new AnnotationDefaultCompleter(meth, value));
duke@1 1331 }
duke@1 1332
duke@1 1333 Type readTypeOrClassSymbol(int i) {
duke@1 1334 // support preliminary jsr175-format class files
duke@1 1335 if (buf[poolIdx[i]] == CONSTANT_Class)
duke@1 1336 return readClassSymbol(i).type;
duke@1 1337 return readType(i);
duke@1 1338 }
duke@1 1339 Type readEnumType(int i) {
duke@1 1340 // support preliminary jsr175-format class files
duke@1 1341 int index = poolIdx[i];
duke@1 1342 int length = getChar(index + 1);
duke@1 1343 if (buf[index + length + 2] != ';')
duke@1 1344 return enterClass(readName(i)).type;
duke@1 1345 return readType(i);
duke@1 1346 }
duke@1 1347
duke@1 1348 CompoundAnnotationProxy readCompoundAnnotation() {
duke@1 1349 Type t = readTypeOrClassSymbol(nextChar());
duke@1 1350 int numFields = nextChar();
duke@1 1351 ListBuffer<Pair<Name,Attribute>> pairs =
duke@1 1352 new ListBuffer<Pair<Name,Attribute>>();
duke@1 1353 for (int i=0; i<numFields; i++) {
duke@1 1354 Name name = readName(nextChar());
duke@1 1355 Attribute value = readAttributeValue();
duke@1 1356 pairs.append(new Pair<Name,Attribute>(name, value));
duke@1 1357 }
duke@1 1358 return new CompoundAnnotationProxy(t, pairs.toList());
duke@1 1359 }
duke@1 1360
jjg@308 1361 TypeAnnotationProxy readTypeAnnotation() {
jjg@308 1362 CompoundAnnotationProxy proxy = readCompoundAnnotation();
jjg@308 1363 TypeAnnotationPosition position = readPosition();
jjg@308 1364
jjg@308 1365 if (debugJSR308)
jjg@308 1366 System.out.println("TA: reading: " + proxy + " @ " + position
jjg@308 1367 + " in " + log.currentSourceFile());
jjg@308 1368
jjg@308 1369 return new TypeAnnotationProxy(proxy, position);
jjg@308 1370 }
jjg@308 1371
jjg@308 1372 TypeAnnotationPosition readPosition() {
jjg@308 1373 byte tag = nextByte();
jjg@308 1374
jjg@308 1375 if (!TargetType.isValidTargetTypeValue(tag))
jjg@308 1376 throw this.badClassFile("bad.type.annotation.value", tag);
jjg@308 1377
jjg@308 1378 TypeAnnotationPosition position = new TypeAnnotationPosition();
jjg@308 1379 TargetType type = TargetType.fromTargetTypeValue(tag);
jjg@308 1380
jjg@308 1381 position.type = type;
jjg@308 1382
jjg@308 1383 switch (type) {
jjg@308 1384 // type case
jjg@308 1385 case TYPECAST:
jjg@308 1386 case TYPECAST_GENERIC_OR_ARRAY:
jjg@308 1387 // object creation
jjg@308 1388 case INSTANCEOF:
jjg@308 1389 case INSTANCEOF_GENERIC_OR_ARRAY:
jjg@308 1390 // new expression
jjg@308 1391 case NEW:
jjg@308 1392 case NEW_GENERIC_OR_ARRAY:
jjg@308 1393 position.offset = nextChar();
jjg@308 1394 break;
jjg@308 1395 // local variable
jjg@308 1396 case LOCAL_VARIABLE:
jjg@308 1397 case LOCAL_VARIABLE_GENERIC_OR_ARRAY:
jjg@308 1398 int table_length = nextChar();
jjg@308 1399 position.lvarOffset = new int[table_length];
jjg@308 1400 position.lvarLength = new int[table_length];
jjg@308 1401 position.lvarIndex = new int[table_length];
jjg@308 1402
jjg@308 1403 for (int i = 0; i < table_length; ++i) {
jjg@308 1404 position.lvarOffset[i] = nextChar();
jjg@308 1405 position.lvarLength[i] = nextChar();
jjg@308 1406 position.lvarIndex[i] = nextChar();
jjg@308 1407 }
jjg@308 1408 break;
jjg@308 1409 // method receiver
jjg@308 1410 case METHOD_RECEIVER:
jjg@308 1411 // Do nothing
jjg@308 1412 break;
jjg@308 1413 // type parameters
jjg@308 1414 case CLASS_TYPE_PARAMETER:
jjg@308 1415 case METHOD_TYPE_PARAMETER:
jjg@308 1416 position.parameter_index = nextByte();
jjg@308 1417 break;
jjg@308 1418 // type parameter bounds
jjg@308 1419 case CLASS_TYPE_PARAMETER_BOUND:
jjg@308 1420 case CLASS_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
jjg@308 1421 case METHOD_TYPE_PARAMETER_BOUND:
jjg@308 1422 case METHOD_TYPE_PARAMETER_BOUND_GENERIC_OR_ARRAY:
jjg@308 1423 position.parameter_index = nextByte();
jjg@308 1424 position.bound_index = nextByte();
jjg@308 1425 break;
jjg@308 1426 // wildcard
jjg@308 1427 case WILDCARD_BOUND:
jjg@308 1428 case WILDCARD_BOUND_GENERIC_OR_ARRAY:
jjg@308 1429 position.wildcard_position = readPosition();
jjg@308 1430 break;
jjg@308 1431 // Class extends and implements clauses
jjg@308 1432 case CLASS_EXTENDS:
jjg@308 1433 case CLASS_EXTENDS_GENERIC_OR_ARRAY:
jjg@484 1434 position.type_index = nextChar();
jjg@308 1435 break;
jjg@308 1436 // throws
jjg@308 1437 case THROWS:
jjg@484 1438 position.type_index = nextChar();
jjg@308 1439 break;
jjg@308 1440 case CLASS_LITERAL:
jjg@308 1441 case CLASS_LITERAL_GENERIC_OR_ARRAY:
jjg@308 1442 position.offset = nextChar();
jjg@308 1443 break;
jjg@308 1444 // method parameter: not specified
jjg@308 1445 case METHOD_PARAMETER_GENERIC_OR_ARRAY:
jjg@308 1446 position.parameter_index = nextByte();
jjg@308 1447 break;
jjg@308 1448 // method type argument: wasn't specified
jjg@308 1449 case NEW_TYPE_ARGUMENT:
jjg@308 1450 case NEW_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
jjg@308 1451 case METHOD_TYPE_ARGUMENT:
jjg@308 1452 case METHOD_TYPE_ARGUMENT_GENERIC_OR_ARRAY:
jjg@308 1453 position.offset = nextChar();
jjg@308 1454 position.type_index = nextByte();
jjg@308 1455 break;
jjg@308 1456 // We don't need to worry abut these
jjg@308 1457 case METHOD_RETURN_GENERIC_OR_ARRAY:
jjg@308 1458 case FIELD_GENERIC_OR_ARRAY:
jjg@308 1459 break;
jjg@308 1460 case UNKNOWN:
jjg@308 1461 break;
jjg@308 1462 default:
jjg@308 1463 throw new AssertionError("unknown type: " + position);
jjg@308 1464 }
jjg@308 1465
jjg@308 1466 if (type.hasLocation()) {
jjg@308 1467 int len = nextChar();
jjg@308 1468 ListBuffer<Integer> loc = ListBuffer.lb();
jjg@308 1469 for (int i = 0; i < len; i++)
jjg@308 1470 loc = loc.append((int)nextByte());
jjg@308 1471 position.location = loc.toList();
jjg@308 1472 }
jjg@308 1473
jjg@308 1474 return position;
jjg@308 1475 }
duke@1 1476 Attribute readAttributeValue() {
duke@1 1477 char c = (char) buf[bp++];
duke@1 1478 switch (c) {
duke@1 1479 case 'B':
duke@1 1480 return new Attribute.Constant(syms.byteType, readPool(nextChar()));
duke@1 1481 case 'C':
duke@1 1482 return new Attribute.Constant(syms.charType, readPool(nextChar()));
duke@1 1483 case 'D':
duke@1 1484 return new Attribute.Constant(syms.doubleType, readPool(nextChar()));
duke@1 1485 case 'F':
duke@1 1486 return new Attribute.Constant(syms.floatType, readPool(nextChar()));
duke@1 1487 case 'I':
duke@1 1488 return new Attribute.Constant(syms.intType, readPool(nextChar()));
duke@1 1489 case 'J':
duke@1 1490 return new Attribute.Constant(syms.longType, readPool(nextChar()));
duke@1 1491 case 'S':
duke@1 1492 return new Attribute.Constant(syms.shortType, readPool(nextChar()));
duke@1 1493 case 'Z':
duke@1 1494 return new Attribute.Constant(syms.booleanType, readPool(nextChar()));
duke@1 1495 case 's':
duke@1 1496 return new Attribute.Constant(syms.stringType, readPool(nextChar()).toString());
duke@1 1497 case 'e':
duke@1 1498 return new EnumAttributeProxy(readEnumType(nextChar()), readName(nextChar()));
duke@1 1499 case 'c':
duke@1 1500 return new Attribute.Class(types, readTypeOrClassSymbol(nextChar()));
duke@1 1501 case '[': {
duke@1 1502 int n = nextChar();
duke@1 1503 ListBuffer<Attribute> l = new ListBuffer<Attribute>();
duke@1 1504 for (int i=0; i<n; i++)
duke@1 1505 l.append(readAttributeValue());
duke@1 1506 return new ArrayAttributeProxy(l.toList());
duke@1 1507 }
duke@1 1508 case '@':
duke@1 1509 return readCompoundAnnotation();
duke@1 1510 default:
duke@1 1511 throw new AssertionError("unknown annotation tag '" + c + "'");
duke@1 1512 }
duke@1 1513 }
duke@1 1514
duke@1 1515 interface ProxyVisitor extends Attribute.Visitor {
duke@1 1516 void visitEnumAttributeProxy(EnumAttributeProxy proxy);
duke@1 1517 void visitArrayAttributeProxy(ArrayAttributeProxy proxy);
duke@1 1518 void visitCompoundAnnotationProxy(CompoundAnnotationProxy proxy);
duke@1 1519 }
duke@1 1520
duke@1 1521 static class EnumAttributeProxy extends Attribute {
duke@1 1522 Type enumType;
duke@1 1523 Name enumerator;
duke@1 1524 public EnumAttributeProxy(Type enumType, Name enumerator) {
duke@1 1525 super(null);
duke@1 1526 this.enumType = enumType;
duke@1 1527 this.enumerator = enumerator;
duke@1 1528 }
duke@1 1529 public void accept(Visitor v) { ((ProxyVisitor)v).visitEnumAttributeProxy(this); }
jjg@256 1530 @Override
duke@1 1531 public String toString() {
duke@1 1532 return "/*proxy enum*/" + enumType + "." + enumerator;
duke@1 1533 }
duke@1 1534 }
duke@1 1535
duke@1 1536 static class ArrayAttributeProxy extends Attribute {
duke@1 1537 List<Attribute> values;
duke@1 1538 ArrayAttributeProxy(List<Attribute> values) {
duke@1 1539 super(null);
duke@1 1540 this.values = values;
duke@1 1541 }
duke@1 1542 public void accept(Visitor v) { ((ProxyVisitor)v).visitArrayAttributeProxy(this); }
jjg@256 1543 @Override
duke@1 1544 public String toString() {
duke@1 1545 return "{" + values + "}";
duke@1 1546 }
duke@1 1547 }
duke@1 1548
duke@1 1549 /** A temporary proxy representing a compound attribute.
duke@1 1550 */
duke@1 1551 static class CompoundAnnotationProxy extends Attribute {
duke@1 1552 final List<Pair<Name,Attribute>> values;
duke@1 1553 public CompoundAnnotationProxy(Type type,
duke@1 1554 List<Pair<Name,Attribute>> values) {
duke@1 1555 super(type);
duke@1 1556 this.values = values;
duke@1 1557 }
duke@1 1558 public void accept(Visitor v) { ((ProxyVisitor)v).visitCompoundAnnotationProxy(this); }
jjg@256 1559 @Override
duke@1 1560 public String toString() {
duke@1 1561 StringBuffer buf = new StringBuffer();
duke@1 1562 buf.append("@");
duke@1 1563 buf.append(type.tsym.getQualifiedName());
duke@1 1564 buf.append("/*proxy*/{");
duke@1 1565 boolean first = true;
duke@1 1566 for (List<Pair<Name,Attribute>> v = values;
duke@1 1567 v.nonEmpty(); v = v.tail) {
duke@1 1568 Pair<Name,Attribute> value = v.head;
duke@1 1569 if (!first) buf.append(",");
duke@1 1570 first = false;
duke@1 1571 buf.append(value.fst);
duke@1 1572 buf.append("=");
duke@1 1573 buf.append(value.snd);
duke@1 1574 }
duke@1 1575 buf.append("}");
duke@1 1576 return buf.toString();
duke@1 1577 }
duke@1 1578 }
duke@1 1579
jjg@308 1580 /** A temporary proxy representing a type annotation.
jjg@308 1581 */
jjg@308 1582 static class TypeAnnotationProxy {
jjg@308 1583 final CompoundAnnotationProxy compound;
jjg@308 1584 final TypeAnnotationPosition position;
jjg@308 1585 public TypeAnnotationProxy(CompoundAnnotationProxy compound,
jjg@308 1586 TypeAnnotationPosition position) {
jjg@308 1587 this.compound = compound;
jjg@308 1588 this.position = position;
jjg@308 1589 }
jjg@308 1590 }
jjg@308 1591
duke@1 1592 class AnnotationDeproxy implements ProxyVisitor {
duke@1 1593 private ClassSymbol requestingOwner = currentOwner.kind == MTH
duke@1 1594 ? currentOwner.enclClass() : (ClassSymbol)currentOwner;
duke@1 1595
duke@1 1596 List<Attribute.Compound> deproxyCompoundList(List<CompoundAnnotationProxy> pl) {
duke@1 1597 // also must fill in types!!!!
duke@1 1598 ListBuffer<Attribute.Compound> buf =
duke@1 1599 new ListBuffer<Attribute.Compound>();
duke@1 1600 for (List<CompoundAnnotationProxy> l = pl; l.nonEmpty(); l=l.tail) {
duke@1 1601 buf.append(deproxyCompound(l.head));
duke@1 1602 }
duke@1 1603 return buf.toList();
duke@1 1604 }
duke@1 1605
duke@1 1606 Attribute.Compound deproxyCompound(CompoundAnnotationProxy a) {
duke@1 1607 ListBuffer<Pair<Symbol.MethodSymbol,Attribute>> buf =
duke@1 1608 new ListBuffer<Pair<Symbol.MethodSymbol,Attribute>>();
duke@1 1609 for (List<Pair<Name,Attribute>> l = a.values;
duke@1 1610 l.nonEmpty();
duke@1 1611 l = l.tail) {
duke@1 1612 MethodSymbol meth = findAccessMethod(a.type, l.head.fst);
duke@1 1613 buf.append(new Pair<Symbol.MethodSymbol,Attribute>
duke@1 1614 (meth, deproxy(meth.type.getReturnType(), l.head.snd)));
duke@1 1615 }
duke@1 1616 return new Attribute.Compound(a.type, buf.toList());
duke@1 1617 }
duke@1 1618
duke@1 1619 MethodSymbol findAccessMethod(Type container, Name name) {
duke@1 1620 CompletionFailure failure = null;
duke@1 1621 try {
duke@1 1622 for (Scope.Entry e = container.tsym.members().lookup(name);
duke@1 1623 e.scope != null;
duke@1 1624 e = e.next()) {
duke@1 1625 Symbol sym = e.sym;
duke@1 1626 if (sym.kind == MTH && sym.type.getParameterTypes().length() == 0)
duke@1 1627 return (MethodSymbol) sym;
duke@1 1628 }
duke@1 1629 } catch (CompletionFailure ex) {
duke@1 1630 failure = ex;
duke@1 1631 }
duke@1 1632 // The method wasn't found: emit a warning and recover
duke@1 1633 JavaFileObject prevSource = log.useSource(requestingOwner.classfile);
duke@1 1634 try {
duke@1 1635 if (failure == null) {
duke@1 1636 log.warning("annotation.method.not.found",
duke@1 1637 container,
duke@1 1638 name);
duke@1 1639 } else {
duke@1 1640 log.warning("annotation.method.not.found.reason",
duke@1 1641 container,
duke@1 1642 name,
mcimadamore@80 1643 failure.getDetailValue());//diagnostic, if present
duke@1 1644 }
duke@1 1645 } finally {
duke@1 1646 log.useSource(prevSource);
duke@1 1647 }
duke@1 1648 // Construct a new method type and symbol. Use bottom
duke@1 1649 // type (typeof null) as return type because this type is
duke@1 1650 // a subtype of all reference types and can be converted
duke@1 1651 // to primitive types by unboxing.
duke@1 1652 MethodType mt = new MethodType(List.<Type>nil(),
duke@1 1653 syms.botType,
duke@1 1654 List.<Type>nil(),
duke@1 1655 syms.methodClass);
duke@1 1656 return new MethodSymbol(PUBLIC | ABSTRACT, name, mt, container.tsym);
duke@1 1657 }
duke@1 1658
duke@1 1659 Attribute result;
duke@1 1660 Type type;
duke@1 1661 Attribute deproxy(Type t, Attribute a) {
duke@1 1662 Type oldType = type;
duke@1 1663 try {
duke@1 1664 type = t;
duke@1 1665 a.accept(this);
duke@1 1666 return result;
duke@1 1667 } finally {
duke@1 1668 type = oldType;
duke@1 1669 }
duke@1 1670 }
duke@1 1671
duke@1 1672 // implement Attribute.Visitor below
duke@1 1673
duke@1 1674 public void visitConstant(Attribute.Constant value) {
duke@1 1675 // assert value.type == type;
duke@1 1676 result = value;
duke@1 1677 }
duke@1 1678
duke@1 1679 public void visitClass(Attribute.Class clazz) {
duke@1 1680 result = clazz;
duke@1 1681 }
duke@1 1682
duke@1 1683 public void visitEnum(Attribute.Enum e) {
duke@1 1684 throw new AssertionError(); // shouldn't happen
duke@1 1685 }
duke@1 1686
duke@1 1687 public void visitCompound(Attribute.Compound compound) {
duke@1 1688 throw new AssertionError(); // shouldn't happen
duke@1 1689 }
duke@1 1690
duke@1 1691 public void visitArray(Attribute.Array array) {
duke@1 1692 throw new AssertionError(); // shouldn't happen
duke@1 1693 }
duke@1 1694
duke@1 1695 public void visitError(Attribute.Error e) {
duke@1 1696 throw new AssertionError(); // shouldn't happen
duke@1 1697 }
duke@1 1698
duke@1 1699 public void visitEnumAttributeProxy(EnumAttributeProxy proxy) {
duke@1 1700 // type.tsym.flatName() should == proxy.enumFlatName
duke@1 1701 TypeSymbol enumTypeSym = proxy.enumType.tsym;
duke@1 1702 VarSymbol enumerator = null;
duke@1 1703 for (Scope.Entry e = enumTypeSym.members().lookup(proxy.enumerator);
duke@1 1704 e.scope != null;
duke@1 1705 e = e.next()) {
duke@1 1706 if (e.sym.kind == VAR) {
duke@1 1707 enumerator = (VarSymbol)e.sym;
duke@1 1708 break;
duke@1 1709 }
duke@1 1710 }
duke@1 1711 if (enumerator == null) {
duke@1 1712 log.error("unknown.enum.constant",
duke@1 1713 currentClassFile, enumTypeSym, proxy.enumerator);
duke@1 1714 result = new Attribute.Error(enumTypeSym.type);
duke@1 1715 } else {
duke@1 1716 result = new Attribute.Enum(enumTypeSym.type, enumerator);
duke@1 1717 }
duke@1 1718 }
duke@1 1719
duke@1 1720 public void visitArrayAttributeProxy(ArrayAttributeProxy proxy) {
duke@1 1721 int length = proxy.values.length();
duke@1 1722 Attribute[] ats = new Attribute[length];
duke@1 1723 Type elemtype = types.elemtype(type);
duke@1 1724 int i = 0;
duke@1 1725 for (List<Attribute> p = proxy.values; p.nonEmpty(); p = p.tail) {
duke@1 1726 ats[i++] = deproxy(elemtype, p.head);
duke@1 1727 }
duke@1 1728 result = new Attribute.Array(type, ats);
duke@1 1729 }
duke@1 1730
duke@1 1731 public void visitCompoundAnnotationProxy(CompoundAnnotationProxy proxy) {
duke@1 1732 result = deproxyCompound(proxy);
duke@1 1733 }
duke@1 1734 }
duke@1 1735
duke@1 1736 class AnnotationDefaultCompleter extends AnnotationDeproxy implements Annotate.Annotator {
duke@1 1737 final MethodSymbol sym;
duke@1 1738 final Attribute value;
duke@1 1739 final JavaFileObject classFile = currentClassFile;
jjg@256 1740 @Override
duke@1 1741 public String toString() {
duke@1 1742 return " ClassReader store default for " + sym.owner + "." + sym + " is " + value;
duke@1 1743 }
duke@1 1744 AnnotationDefaultCompleter(MethodSymbol sym, Attribute value) {
duke@1 1745 this.sym = sym;
duke@1 1746 this.value = value;
duke@1 1747 }
duke@1 1748 // implement Annotate.Annotator.enterAnnotation()
duke@1 1749 public void enterAnnotation() {
duke@1 1750 JavaFileObject previousClassFile = currentClassFile;
duke@1 1751 try {
duke@1 1752 currentClassFile = classFile;
duke@1 1753 sym.defaultValue = deproxy(sym.type.getReturnType(), value);
duke@1 1754 } finally {
duke@1 1755 currentClassFile = previousClassFile;
duke@1 1756 }
duke@1 1757 }
duke@1 1758 }
duke@1 1759
duke@1 1760 class AnnotationCompleter extends AnnotationDeproxy implements Annotate.Annotator {
duke@1 1761 final Symbol sym;
duke@1 1762 final List<CompoundAnnotationProxy> l;
duke@1 1763 final JavaFileObject classFile;
jjg@256 1764 @Override
duke@1 1765 public String toString() {
duke@1 1766 return " ClassReader annotate " + sym.owner + "." + sym + " with " + l;
duke@1 1767 }
duke@1 1768 AnnotationCompleter(Symbol sym, List<CompoundAnnotationProxy> l) {
duke@1 1769 this.sym = sym;
duke@1 1770 this.l = l;
duke@1 1771 this.classFile = currentClassFile;
duke@1 1772 }
duke@1 1773 // implement Annotate.Annotator.enterAnnotation()
duke@1 1774 public void enterAnnotation() {
duke@1 1775 JavaFileObject previousClassFile = currentClassFile;
duke@1 1776 try {
duke@1 1777 currentClassFile = classFile;
duke@1 1778 List<Attribute.Compound> newList = deproxyCompoundList(l);
duke@1 1779 sym.attributes_field = ((sym.attributes_field == null)
duke@1 1780 ? newList
duke@1 1781 : newList.prependList(sym.attributes_field));
duke@1 1782 } finally {
duke@1 1783 currentClassFile = previousClassFile;
duke@1 1784 }
duke@1 1785 }
duke@1 1786 }
duke@1 1787
jjg@308 1788 class TypeAnnotationCompleter extends AnnotationCompleter {
jjg@308 1789
jjg@308 1790 List<TypeAnnotationProxy> proxies;
jjg@308 1791
jjg@308 1792 TypeAnnotationCompleter(Symbol sym,
jjg@308 1793 List<TypeAnnotationProxy> proxies) {
jjg@308 1794 super(sym, List.<CompoundAnnotationProxy>nil());
jjg@308 1795 this.proxies = proxies;
jjg@308 1796 }
jjg@308 1797
jjg@308 1798 List<Attribute.TypeCompound> deproxyTypeCompoundList(List<TypeAnnotationProxy> proxies) {
jjg@308 1799 ListBuffer<Attribute.TypeCompound> buf = ListBuffer.lb();
jjg@308 1800 for (TypeAnnotationProxy proxy: proxies) {
jjg@308 1801 Attribute.Compound compound = deproxyCompound(proxy.compound);
jjg@308 1802 Attribute.TypeCompound typeCompound = new Attribute.TypeCompound(compound, proxy.position);
jjg@308 1803 buf.add(typeCompound);
jjg@308 1804 }
jjg@308 1805 return buf.toList();
jjg@308 1806 }
jjg@308 1807
jjg@308 1808 @Override
jjg@308 1809 public void enterAnnotation() {
jjg@308 1810 JavaFileObject previousClassFile = currentClassFile;
jjg@308 1811 try {
jjg@308 1812 currentClassFile = classFile;
jjg@308 1813 List<Attribute.TypeCompound> newList = deproxyTypeCompoundList(proxies);
jjg@308 1814 if (debugJSR308)
jjg@308 1815 System.out.println("TA: reading: adding " + newList
jjg@308 1816 + " to symbol " + sym + " in " + log.currentSourceFile());
jjg@308 1817 sym.typeAnnotations = ((sym.typeAnnotations == null)
jjg@308 1818 ? newList
jjg@308 1819 : newList.prependList(sym.typeAnnotations));
jjg@308 1820
jjg@308 1821 } finally {
jjg@308 1822 currentClassFile = previousClassFile;
jjg@308 1823 }
jjg@308 1824 }
jjg@308 1825 }
jjg@308 1826
duke@1 1827
duke@1 1828 /************************************************************************
duke@1 1829 * Reading Symbols
duke@1 1830 ***********************************************************************/
duke@1 1831
duke@1 1832 /** Read a field.
duke@1 1833 */
duke@1 1834 VarSymbol readField() {
duke@1 1835 long flags = adjustFieldFlags(nextChar());
duke@1 1836 Name name = readName(nextChar());
duke@1 1837 Type type = readType(nextChar());
duke@1 1838 VarSymbol v = new VarSymbol(flags, name, type, currentOwner);
duke@1 1839 readMemberAttrs(v);
duke@1 1840 return v;
duke@1 1841 }
duke@1 1842
duke@1 1843 /** Read a method.
duke@1 1844 */
duke@1 1845 MethodSymbol readMethod() {
duke@1 1846 long flags = adjustMethodFlags(nextChar());
duke@1 1847 Name name = readName(nextChar());
duke@1 1848 Type type = readType(nextChar());
duke@1 1849 if (name == names.init && currentOwner.hasOuterInstance()) {
duke@1 1850 // Sometimes anonymous classes don't have an outer
duke@1 1851 // instance, however, there is no reliable way to tell so
duke@1 1852 // we never strip this$n
jjg@113 1853 if (!currentOwner.name.isEmpty())
duke@1 1854 type = new MethodType(type.getParameterTypes().tail,
duke@1 1855 type.getReturnType(),
duke@1 1856 type.getThrownTypes(),
duke@1 1857 syms.methodClass);
duke@1 1858 }
duke@1 1859 MethodSymbol m = new MethodSymbol(flags, name, type, currentOwner);
jjg@428 1860 if (saveParameterNames)
jjg@428 1861 initParameterNames(m);
duke@1 1862 Symbol prevOwner = currentOwner;
duke@1 1863 currentOwner = m;
duke@1 1864 try {
duke@1 1865 readMemberAttrs(m);
duke@1 1866 } finally {
duke@1 1867 currentOwner = prevOwner;
duke@1 1868 }
jjg@428 1869 if (saveParameterNames)
jjg@428 1870 setParameterNames(m, type);
duke@1 1871 return m;
duke@1 1872 }
duke@1 1873
jjg@428 1874 /**
jjg@428 1875 * Init the parameter names array.
jjg@428 1876 * Parameter names are currently inferred from the names in the
jjg@428 1877 * LocalVariableTable attributes of a Code attribute.
jjg@428 1878 * (Note: this means parameter names are currently not available for
jjg@428 1879 * methods without a Code attribute.)
jjg@428 1880 * This method initializes an array in which to store the name indexes
jjg@428 1881 * of parameter names found in LocalVariableTable attributes. It is
jjg@428 1882 * slightly supersized to allow for additional slots with a start_pc of 0.
jjg@428 1883 */
jjg@428 1884 void initParameterNames(MethodSymbol sym) {
jjg@428 1885 // make allowance for synthetic parameters.
jjg@428 1886 final int excessSlots = 4;
jjg@428 1887 int expectedParameterSlots =
jjg@428 1888 Code.width(sym.type.getParameterTypes()) + excessSlots;
jjg@428 1889 if (parameterNameIndices == null
jjg@428 1890 || parameterNameIndices.length < expectedParameterSlots) {
jjg@428 1891 parameterNameIndices = new int[expectedParameterSlots];
jjg@428 1892 } else
jjg@428 1893 Arrays.fill(parameterNameIndices, 0);
jjg@428 1894 haveParameterNameIndices = false;
jjg@428 1895 }
jjg@428 1896
jjg@428 1897 /**
jjg@428 1898 * Set the parameter names for a symbol from the name index in the
jjg@428 1899 * parameterNameIndicies array. The type of the symbol may have changed
jjg@428 1900 * while reading the method attributes (see the Signature attribute).
jjg@428 1901 * This may be because of generic information or because anonymous
jjg@428 1902 * synthetic parameters were added. The original type (as read from
jjg@428 1903 * the method descriptor) is used to help guess the existence of
jjg@428 1904 * anonymous synthetic parameters.
jjg@428 1905 * On completion, sym.savedParameter names will either be null (if
jjg@428 1906 * no parameter names were found in the class file) or will be set to a
jjg@428 1907 * list of names, one per entry in sym.type.getParameterTypes, with
jjg@428 1908 * any missing names represented by the empty name.
jjg@428 1909 */
jjg@428 1910 void setParameterNames(MethodSymbol sym, Type jvmType) {
jjg@428 1911 // if no names were found in the class file, there's nothing more to do
jjg@428 1912 if (!haveParameterNameIndices)
jjg@428 1913 return;
jjg@428 1914
jjg@428 1915 int firstParam = ((sym.flags() & STATIC) == 0) ? 1 : 0;
jjg@428 1916 // the code in readMethod may have skipped the first parameter when
jjg@428 1917 // setting up the MethodType. If so, we make a corresponding allowance
jjg@428 1918 // here for the position of the first parameter. Note that this
jjg@428 1919 // assumes the skipped parameter has a width of 1 -- i.e. it is not
jjg@428 1920 // a double width type (long or double.)
jjg@428 1921 if (sym.name == names.init && currentOwner.hasOuterInstance()) {
jjg@428 1922 // Sometimes anonymous classes don't have an outer
jjg@428 1923 // instance, however, there is no reliable way to tell so
jjg@428 1924 // we never strip this$n
jjg@428 1925 if (!currentOwner.name.isEmpty())
jjg@428 1926 firstParam += 1;
jjg@428 1927 }
jjg@428 1928
jjg@428 1929 if (sym.type != jvmType) {
jjg@428 1930 // reading the method attributes has caused the symbol's type to
jjg@428 1931 // be changed. (i.e. the Signature attribute.) This may happen if
jjg@428 1932 // there are hidden (synthetic) parameters in the descriptor, but
jjg@428 1933 // not in the Signature. The position of these hidden parameters
jjg@428 1934 // is unspecified; for now, assume they are at the beginning, and
jjg@428 1935 // so skip over them. The primary case for this is two hidden
jjg@428 1936 // parameters passed into Enum constructors.
jjg@428 1937 int skip = Code.width(jvmType.getParameterTypes())
jjg@428 1938 - Code.width(sym.type.getParameterTypes());
jjg@428 1939 firstParam += skip;
jjg@428 1940 }
jjg@428 1941 List<Name> paramNames = List.nil();
jjg@428 1942 int index = firstParam;
jjg@428 1943 for (Type t: sym.type.getParameterTypes()) {
jjg@428 1944 int nameIdx = (index < parameterNameIndices.length
jjg@428 1945 ? parameterNameIndices[index] : 0);
jjg@428 1946 Name name = nameIdx == 0 ? names.empty : readName(nameIdx);
jjg@428 1947 paramNames = paramNames.prepend(name);
jjg@428 1948 index += Code.width(t);
jjg@428 1949 }
jjg@428 1950 sym.savedParameterNames = paramNames.reverse();
jjg@428 1951 }
jjg@428 1952
duke@1 1953 /** Skip a field or method
duke@1 1954 */
duke@1 1955 void skipMember() {
duke@1 1956 bp = bp + 6;
duke@1 1957 char ac = nextChar();
duke@1 1958 for (int i = 0; i < ac; i++) {
duke@1 1959 bp = bp + 2;
duke@1 1960 int attrLen = nextInt();
duke@1 1961 bp = bp + attrLen;
duke@1 1962 }
duke@1 1963 }
duke@1 1964
duke@1 1965 /** Enter type variables of this classtype and all enclosing ones in
duke@1 1966 * `typevars'.
duke@1 1967 */
duke@1 1968 protected void enterTypevars(Type t) {
duke@1 1969 if (t.getEnclosingType() != null && t.getEnclosingType().tag == CLASS)
duke@1 1970 enterTypevars(t.getEnclosingType());
duke@1 1971 for (List<Type> xs = t.getTypeArguments(); xs.nonEmpty(); xs = xs.tail)
duke@1 1972 typevars.enter(xs.head.tsym);
duke@1 1973 }
duke@1 1974
duke@1 1975 protected void enterTypevars(Symbol sym) {
duke@1 1976 if (sym.owner.kind == MTH) {
duke@1 1977 enterTypevars(sym.owner);
duke@1 1978 enterTypevars(sym.owner.owner);
duke@1 1979 }
duke@1 1980 enterTypevars(sym.type);
duke@1 1981 }
duke@1 1982
duke@1 1983 /** Read contents of a given class symbol `c'. Both external and internal
duke@1 1984 * versions of an inner class are read.
duke@1 1985 */
duke@1 1986 void readClass(ClassSymbol c) {
duke@1 1987 ClassType ct = (ClassType)c.type;
duke@1 1988
duke@1 1989 // allocate scope for members
duke@1 1990 c.members_field = new Scope(c);
duke@1 1991
duke@1 1992 // prepare type variable table
duke@1 1993 typevars = typevars.dup(currentOwner);
jjg@256 1994 if (ct.getEnclosingType().tag == CLASS)
jjg@256 1995 enterTypevars(ct.getEnclosingType());
duke@1 1996
duke@1 1997 // read flags, or skip if this is an inner class
duke@1 1998 long flags = adjustClassFlags(nextChar());
duke@1 1999 if (c.owner.kind == PCK) c.flags_field = flags;
duke@1 2000
duke@1 2001 // read own class name and check that it matches
duke@1 2002 ClassSymbol self = readClassSymbol(nextChar());
duke@1 2003 if (c != self)
duke@1 2004 throw badClassFile("class.file.wrong.class",
duke@1 2005 self.flatname);
duke@1 2006
duke@1 2007 // class attributes must be read before class
duke@1 2008 // skip ahead to read class attributes
duke@1 2009 int startbp = bp;
duke@1 2010 nextChar();
duke@1 2011 char interfaceCount = nextChar();
duke@1 2012 bp += interfaceCount * 2;
duke@1 2013 char fieldCount = nextChar();
duke@1 2014 for (int i = 0; i < fieldCount; i++) skipMember();
duke@1 2015 char methodCount = nextChar();
duke@1 2016 for (int i = 0; i < methodCount; i++) skipMember();
duke@1 2017 readClassAttrs(c);
duke@1 2018
duke@1 2019 if (readAllOfClassFile) {
duke@1 2020 for (int i = 1; i < poolObj.length; i++) readPool(i);
duke@1 2021 c.pool = new Pool(poolObj.length, poolObj);
duke@1 2022 }
duke@1 2023
duke@1 2024 // reset and read rest of classinfo
duke@1 2025 bp = startbp;
duke@1 2026 int n = nextChar();
duke@1 2027 if (ct.supertype_field == null)
duke@1 2028 ct.supertype_field = (n == 0)
duke@1 2029 ? Type.noType
duke@1 2030 : readClassSymbol(n).erasure(types);
duke@1 2031 n = nextChar();
duke@1 2032 List<Type> is = List.nil();
duke@1 2033 for (int i = 0; i < n; i++) {
duke@1 2034 Type _inter = readClassSymbol(nextChar()).erasure(types);
duke@1 2035 is = is.prepend(_inter);
duke@1 2036 }
duke@1 2037 if (ct.interfaces_field == null)
duke@1 2038 ct.interfaces_field = is.reverse();
duke@1 2039
duke@1 2040 if (fieldCount != nextChar()) assert false;
duke@1 2041 for (int i = 0; i < fieldCount; i++) enterMember(c, readField());
duke@1 2042 if (methodCount != nextChar()) assert false;
duke@1 2043 for (int i = 0; i < methodCount; i++) enterMember(c, readMethod());
duke@1 2044
duke@1 2045 typevars = typevars.leave();
duke@1 2046 }
duke@1 2047
duke@1 2048 /** Read inner class info. For each inner/outer pair allocate a
duke@1 2049 * member class.
duke@1 2050 */
duke@1 2051 void readInnerClasses(ClassSymbol c) {
duke@1 2052 int n = nextChar();
duke@1 2053 for (int i = 0; i < n; i++) {
duke@1 2054 nextChar(); // skip inner class symbol
duke@1 2055 ClassSymbol outer = readClassSymbol(nextChar());
duke@1 2056 Name name = readName(nextChar());
duke@1 2057 if (name == null) name = names.empty;
duke@1 2058 long flags = adjustClassFlags(nextChar());
duke@1 2059 if (outer != null) { // we have a member class
duke@1 2060 if (name == names.empty)
duke@1 2061 name = names.one;
duke@1 2062 ClassSymbol member = enterClass(name, outer);
duke@1 2063 if ((flags & STATIC) == 0) {
duke@1 2064 ((ClassType)member.type).setEnclosingType(outer.type);
duke@1 2065 if (member.erasure_field != null)
duke@1 2066 ((ClassType)member.erasure_field).setEnclosingType(types.erasure(outer.type));
duke@1 2067 }
duke@1 2068 if (c == outer) {
duke@1 2069 member.flags_field = flags;
duke@1 2070 enterMember(c, member);
duke@1 2071 }
duke@1 2072 }
duke@1 2073 }
duke@1 2074 }
duke@1 2075
duke@1 2076 /** Read a class file.
duke@1 2077 */
duke@1 2078 private void readClassFile(ClassSymbol c) throws IOException {
duke@1 2079 int magic = nextInt();
duke@1 2080 if (magic != JAVA_MAGIC)
duke@1 2081 throw badClassFile("illegal.start.of.class.file");
duke@1 2082
jjg@256 2083 minorVersion = nextChar();
jjg@256 2084 majorVersion = nextChar();
duke@1 2085 int maxMajor = Target.MAX().majorVersion;
duke@1 2086 int maxMinor = Target.MAX().minorVersion;
duke@1 2087 if (majorVersion > maxMajor ||
duke@1 2088 majorVersion * 1000 + minorVersion <
duke@1 2089 Target.MIN().majorVersion * 1000 + Target.MIN().minorVersion)
duke@1 2090 {
duke@1 2091 if (majorVersion == (maxMajor + 1))
duke@1 2092 log.warning("big.major.version",
duke@1 2093 currentClassFile,
duke@1 2094 majorVersion,
duke@1 2095 maxMajor);
duke@1 2096 else
duke@1 2097 throw badClassFile("wrong.version",
duke@1 2098 Integer.toString(majorVersion),
duke@1 2099 Integer.toString(minorVersion),
duke@1 2100 Integer.toString(maxMajor),
duke@1 2101 Integer.toString(maxMinor));
duke@1 2102 }
duke@1 2103 else if (checkClassFile &&
duke@1 2104 majorVersion == maxMajor &&
duke@1 2105 minorVersion > maxMinor)
duke@1 2106 {
duke@1 2107 printCCF("found.later.version",
duke@1 2108 Integer.toString(minorVersion));
duke@1 2109 }
duke@1 2110 indexPool();
duke@1 2111 if (signatureBuffer.length < bp) {
duke@1 2112 int ns = Integer.highestOneBit(bp) << 1;
duke@1 2113 signatureBuffer = new byte[ns];
duke@1 2114 }
duke@1 2115 readClass(c);
duke@1 2116 }
duke@1 2117
duke@1 2118 /************************************************************************
duke@1 2119 * Adjusting flags
duke@1 2120 ***********************************************************************/
duke@1 2121
duke@1 2122 long adjustFieldFlags(long flags) {
duke@1 2123 return flags;
duke@1 2124 }
duke@1 2125 long adjustMethodFlags(long flags) {
duke@1 2126 if ((flags & ACC_BRIDGE) != 0) {
duke@1 2127 flags &= ~ACC_BRIDGE;
duke@1 2128 flags |= BRIDGE;
duke@1 2129 if (!allowGenerics)
duke@1 2130 flags &= ~SYNTHETIC;
duke@1 2131 }
duke@1 2132 if ((flags & ACC_VARARGS) != 0) {
duke@1 2133 flags &= ~ACC_VARARGS;
duke@1 2134 flags |= VARARGS;
duke@1 2135 }
duke@1 2136 return flags;
duke@1 2137 }
duke@1 2138 long adjustClassFlags(long flags) {
duke@1 2139 return flags & ~ACC_SUPER; // SUPER and SYNCHRONIZED bits overloaded
duke@1 2140 }
duke@1 2141
duke@1 2142 /************************************************************************
duke@1 2143 * Loading Classes
duke@1 2144 ***********************************************************************/
duke@1 2145
duke@1 2146 /** Define a new class given its name and owner.
duke@1 2147 */
duke@1 2148 public ClassSymbol defineClass(Name name, Symbol owner) {
duke@1 2149 ClassSymbol c = new ClassSymbol(0, name, owner);
duke@1 2150 if (owner.kind == PCK)
duke@1 2151 assert classes.get(c.flatname) == null : c;
duke@1 2152 c.completer = this;
duke@1 2153 return c;
duke@1 2154 }
duke@1 2155
duke@1 2156 /** Create a new toplevel or member class symbol with given name
duke@1 2157 * and owner and enter in `classes' unless already there.
duke@1 2158 */
duke@1 2159 public ClassSymbol enterClass(Name name, TypeSymbol owner) {
duke@1 2160 Name flatname = TypeSymbol.formFlatName(name, owner);
duke@1 2161 ClassSymbol c = classes.get(flatname);
duke@1 2162 if (c == null) {
duke@1 2163 c = defineClass(name, owner);
duke@1 2164 classes.put(flatname, c);
duke@1 2165 } else if ((c.name != name || c.owner != owner) && owner.kind == TYP && c.owner.kind == PCK) {
duke@1 2166 // reassign fields of classes that might have been loaded with
duke@1 2167 // their flat names.
duke@1 2168 c.owner.members().remove(c);
duke@1 2169 c.name = name;
duke@1 2170 c.owner = owner;
duke@1 2171 c.fullname = ClassSymbol.formFullName(name, owner);
duke@1 2172 }
duke@1 2173 return c;
duke@1 2174 }
duke@1 2175
duke@1 2176 /**
duke@1 2177 * Creates a new toplevel class symbol with given flat name and
duke@1 2178 * given class (or source) file.
duke@1 2179 *
duke@1 2180 * @param flatName a fully qualified binary class name
duke@1 2181 * @param classFile the class file or compilation unit defining
duke@1 2182 * the class (may be {@code null})
duke@1 2183 * @return a newly created class symbol
duke@1 2184 * @throws AssertionError if the class symbol already exists
duke@1 2185 */
duke@1 2186 public ClassSymbol enterClass(Name flatName, JavaFileObject classFile) {
duke@1 2187 ClassSymbol cs = classes.get(flatName);
duke@1 2188 if (cs != null) {
duke@1 2189 String msg = Log.format("%s: completer = %s; class file = %s; source file = %s",
duke@1 2190 cs.fullname,
duke@1 2191 cs.completer,
duke@1 2192 cs.classfile,
duke@1 2193 cs.sourcefile);
duke@1 2194 throw new AssertionError(msg);
duke@1 2195 }
duke@1 2196 Name packageName = Convert.packagePart(flatName);
duke@1 2197 PackageSymbol owner = packageName.isEmpty()
duke@1 2198 ? syms.unnamedPackage
duke@1 2199 : enterPackage(packageName);
duke@1 2200 cs = defineClass(Convert.shortName(flatName), owner);
duke@1 2201 cs.classfile = classFile;
duke@1 2202 classes.put(flatName, cs);
duke@1 2203 return cs;
duke@1 2204 }
duke@1 2205
duke@1 2206 /** Create a new member or toplevel class symbol with given flat name
duke@1 2207 * and enter in `classes' unless already there.
duke@1 2208 */
duke@1 2209 public ClassSymbol enterClass(Name flatname) {
duke@1 2210 ClassSymbol c = classes.get(flatname);
duke@1 2211 if (c == null)
duke@1 2212 return enterClass(flatname, (JavaFileObject)null);
duke@1 2213 else
duke@1 2214 return c;
duke@1 2215 }
duke@1 2216
duke@1 2217 private boolean suppressFlush = false;
duke@1 2218
duke@1 2219 /** Completion for classes to be loaded. Before a class is loaded
duke@1 2220 * we make sure its enclosing class (if any) is loaded.
duke@1 2221 */
duke@1 2222 public void complete(Symbol sym) throws CompletionFailure {
duke@1 2223 if (sym.kind == TYP) {
duke@1 2224 ClassSymbol c = (ClassSymbol)sym;
duke@1 2225 c.members_field = new Scope.ErrorScope(c); // make sure it's always defined
jjg@256 2226 boolean saveSuppressFlush = suppressFlush;
jjg@256 2227 suppressFlush = true;
duke@1 2228 try {
duke@1 2229 completeOwners(c.owner);
duke@1 2230 completeEnclosing(c);
duke@1 2231 } finally {
jjg@256 2232 suppressFlush = saveSuppressFlush;
duke@1 2233 }
duke@1 2234 fillIn(c);
duke@1 2235 } else if (sym.kind == PCK) {
duke@1 2236 PackageSymbol p = (PackageSymbol)sym;
duke@1 2237 try {
duke@1 2238 fillIn(p);
duke@1 2239 } catch (IOException ex) {
duke@1 2240 throw new CompletionFailure(sym, ex.getLocalizedMessage()).initCause(ex);
duke@1 2241 }
duke@1 2242 }
duke@1 2243 if (!filling && !suppressFlush)
duke@1 2244 annotate.flush(); // finish attaching annotations
duke@1 2245 }
duke@1 2246
duke@1 2247 /** complete up through the enclosing package. */
duke@1 2248 private void completeOwners(Symbol o) {
duke@1 2249 if (o.kind != PCK) completeOwners(o.owner);
duke@1 2250 o.complete();
duke@1 2251 }
duke@1 2252
duke@1 2253 /**
duke@1 2254 * Tries to complete lexically enclosing classes if c looks like a
duke@1 2255 * nested class. This is similar to completeOwners but handles
duke@1 2256 * the situation when a nested class is accessed directly as it is
duke@1 2257 * possible with the Tree API or javax.lang.model.*.
duke@1 2258 */
duke@1 2259 private void completeEnclosing(ClassSymbol c) {
duke@1 2260 if (c.owner.kind == PCK) {
duke@1 2261 Symbol owner = c.owner;
duke@1 2262 for (Name name : Convert.enclosingCandidates(Convert.shortName(c.name))) {
duke@1 2263 Symbol encl = owner.members().lookup(name).sym;
duke@1 2264 if (encl == null)
duke@1 2265 encl = classes.get(TypeSymbol.formFlatName(name, owner));
duke@1 2266 if (encl != null)
duke@1 2267 encl.complete();
duke@1 2268 }
duke@1 2269 }
duke@1 2270 }
duke@1 2271
duke@1 2272 /** We can only read a single class file at a time; this
duke@1 2273 * flag keeps track of when we are currently reading a class
duke@1 2274 * file.
duke@1 2275 */
duke@1 2276 private boolean filling = false;
duke@1 2277
duke@1 2278 /** Fill in definition of class `c' from corresponding class or
duke@1 2279 * source file.
duke@1 2280 */
duke@1 2281 private void fillIn(ClassSymbol c) {
duke@1 2282 if (completionFailureName == c.fullname) {
duke@1 2283 throw new CompletionFailure(c, "user-selected completion failure by class name");
duke@1 2284 }
duke@1 2285 currentOwner = c;
duke@1 2286 JavaFileObject classfile = c.classfile;
duke@1 2287 if (classfile != null) {
duke@1 2288 JavaFileObject previousClassFile = currentClassFile;
duke@1 2289 try {
duke@1 2290 assert !filling :
duke@1 2291 "Filling " + classfile.toUri() +
duke@1 2292 " during " + previousClassFile;
duke@1 2293 currentClassFile = classfile;
duke@1 2294 if (verbose) {
duke@1 2295 printVerbose("loading", currentClassFile.toString());
duke@1 2296 }
duke@1 2297 if (classfile.getKind() == JavaFileObject.Kind.CLASS) {
duke@1 2298 filling = true;
duke@1 2299 try {
duke@1 2300 bp = 0;
duke@1 2301 buf = readInputStream(buf, classfile.openInputStream());
duke@1 2302 readClassFile(c);
duke@1 2303 if (!missingTypeVariables.isEmpty() && !foundTypeVariables.isEmpty()) {
duke@1 2304 List<Type> missing = missingTypeVariables;
duke@1 2305 List<Type> found = foundTypeVariables;
duke@1 2306 missingTypeVariables = List.nil();
duke@1 2307 foundTypeVariables = List.nil();
duke@1 2308 filling = false;
duke@1 2309 ClassType ct = (ClassType)currentOwner.type;
duke@1 2310 ct.supertype_field =
duke@1 2311 types.subst(ct.supertype_field, missing, found);
duke@1 2312 ct.interfaces_field =
duke@1 2313 types.subst(ct.interfaces_field, missing, found);
duke@1 2314 } else if (missingTypeVariables.isEmpty() !=
duke@1 2315 foundTypeVariables.isEmpty()) {
duke@1 2316 Name name = missingTypeVariables.head.tsym.name;
duke@1 2317 throw badClassFile("undecl.type.var", name);
duke@1 2318 }
duke@1 2319 } finally {
duke@1 2320 missingTypeVariables = List.nil();
duke@1 2321 foundTypeVariables = List.nil();
duke@1 2322 filling = false;
duke@1 2323 }
duke@1 2324 } else {
duke@1 2325 if (sourceCompleter != null) {
duke@1 2326 sourceCompleter.complete(c);
duke@1 2327 } else {
duke@1 2328 throw new IllegalStateException("Source completer required to read "
duke@1 2329 + classfile.toUri());
duke@1 2330 }
duke@1 2331 }
duke@1 2332 return;
duke@1 2333 } catch (IOException ex) {
duke@1 2334 throw badClassFile("unable.to.access.file", ex.getMessage());
duke@1 2335 } finally {
duke@1 2336 currentClassFile = previousClassFile;
duke@1 2337 }
duke@1 2338 } else {
jjg@12 2339 JCDiagnostic diag =
jjg@12 2340 diagFactory.fragment("class.file.not.found", c.flatname);
duke@1 2341 throw
jjg@12 2342 newCompletionFailure(c, diag);
duke@1 2343 }
duke@1 2344 }
duke@1 2345 // where
duke@1 2346 private static byte[] readInputStream(byte[] buf, InputStream s) throws IOException {
duke@1 2347 try {
duke@1 2348 buf = ensureCapacity(buf, s.available());
duke@1 2349 int r = s.read(buf);
duke@1 2350 int bp = 0;
duke@1 2351 while (r != -1) {
duke@1 2352 bp += r;
duke@1 2353 buf = ensureCapacity(buf, bp);
duke@1 2354 r = s.read(buf, bp, buf.length - bp);
duke@1 2355 }
duke@1 2356 return buf;
duke@1 2357 } finally {
duke@1 2358 try {
duke@1 2359 s.close();
duke@1 2360 } catch (IOException e) {
duke@1 2361 /* Ignore any errors, as this stream may have already
duke@1 2362 * thrown a related exception which is the one that
duke@1 2363 * should be reported.
duke@1 2364 */
duke@1 2365 }
duke@1 2366 }
duke@1 2367 }
duke@1 2368 private static byte[] ensureCapacity(byte[] buf, int needed) {
duke@1 2369 if (buf.length < needed) {
duke@1 2370 byte[] old = buf;
duke@1 2371 buf = new byte[Integer.highestOneBit(needed) << 1];
duke@1 2372 System.arraycopy(old, 0, buf, 0, old.length);
duke@1 2373 }
duke@1 2374 return buf;
duke@1 2375 }
duke@1 2376 /** Static factory for CompletionFailure objects.
duke@1 2377 * In practice, only one can be used at a time, so we share one
duke@1 2378 * to reduce the expense of allocating new exception objects.
duke@1 2379 */
jjg@12 2380 private CompletionFailure newCompletionFailure(TypeSymbol c,
jjg@12 2381 JCDiagnostic diag) {
duke@1 2382 if (!cacheCompletionFailure) {
duke@1 2383 // log.warning("proc.messager",
duke@1 2384 // Log.getLocalizedString("class.file.not.found", c.flatname));
duke@1 2385 // c.debug.printStackTrace();
jjg@12 2386 return new CompletionFailure(c, diag);
duke@1 2387 } else {
duke@1 2388 CompletionFailure result = cachedCompletionFailure;
duke@1 2389 result.sym = c;
jjg@12 2390 result.diag = diag;
duke@1 2391 return result;
duke@1 2392 }
duke@1 2393 }
duke@1 2394 private CompletionFailure cachedCompletionFailure =
jjg@12 2395 new CompletionFailure(null, (JCDiagnostic) null);
duke@1 2396 {
duke@1 2397 cachedCompletionFailure.setStackTrace(new StackTraceElement[0]);
duke@1 2398 }
duke@1 2399
duke@1 2400 /** Load a toplevel class with given fully qualified name
duke@1 2401 * The class is entered into `classes' only if load was successful.
duke@1 2402 */
duke@1 2403 public ClassSymbol loadClass(Name flatname) throws CompletionFailure {
duke@1 2404 boolean absent = classes.get(flatname) == null;
duke@1 2405 ClassSymbol c = enterClass(flatname);
duke@1 2406 if (c.members_field == null && c.completer != null) {
duke@1 2407 try {
duke@1 2408 c.complete();
duke@1 2409 } catch (CompletionFailure ex) {
duke@1 2410 if (absent) classes.remove(flatname);
duke@1 2411 throw ex;
duke@1 2412 }
duke@1 2413 }
duke@1 2414 return c;
duke@1 2415 }
duke@1 2416
duke@1 2417 /************************************************************************
duke@1 2418 * Loading Packages
duke@1 2419 ***********************************************************************/
duke@1 2420
duke@1 2421 /** Check to see if a package exists, given its fully qualified name.
duke@1 2422 */
duke@1 2423 public boolean packageExists(Name fullname) {
duke@1 2424 return enterPackage(fullname).exists();
duke@1 2425 }
duke@1 2426
duke@1 2427 /** Make a package, given its fully qualified name.
duke@1 2428 */
duke@1 2429 public PackageSymbol enterPackage(Name fullname) {
duke@1 2430 PackageSymbol p = packages.get(fullname);
duke@1 2431 if (p == null) {
duke@1 2432 assert !fullname.isEmpty() : "rootPackage missing!";
duke@1 2433 p = new PackageSymbol(
duke@1 2434 Convert.shortName(fullname),
duke@1 2435 enterPackage(Convert.packagePart(fullname)));
duke@1 2436 p.completer = this;
duke@1 2437 packages.put(fullname, p);
duke@1 2438 }
duke@1 2439 return p;
duke@1 2440 }
duke@1 2441
duke@1 2442 /** Make a package, given its unqualified name and enclosing package.
duke@1 2443 */
duke@1 2444 public PackageSymbol enterPackage(Name name, PackageSymbol owner) {
duke@1 2445 return enterPackage(TypeSymbol.formFullName(name, owner));
duke@1 2446 }
duke@1 2447
duke@1 2448 /** Include class corresponding to given class file in package,
duke@1 2449 * unless (1) we already have one the same kind (.class or .java), or
duke@1 2450 * (2) we have one of the other kind, and the given class file
duke@1 2451 * is older.
duke@1 2452 */
duke@1 2453 protected void includeClassFile(PackageSymbol p, JavaFileObject file) {
duke@1 2454 if ((p.flags_field & EXISTS) == 0)
duke@1 2455 for (Symbol q = p; q != null && q.kind == PCK; q = q.owner)
duke@1 2456 q.flags_field |= EXISTS;
duke@1 2457 JavaFileObject.Kind kind = file.getKind();
duke@1 2458 int seen;
duke@1 2459 if (kind == JavaFileObject.Kind.CLASS)
duke@1 2460 seen = CLASS_SEEN;
duke@1 2461 else
duke@1 2462 seen = SOURCE_SEEN;
duke@1 2463 String binaryName = fileManager.inferBinaryName(currentLoc, file);
duke@1 2464 int lastDot = binaryName.lastIndexOf(".");
duke@1 2465 Name classname = names.fromString(binaryName.substring(lastDot + 1));
duke@1 2466 boolean isPkgInfo = classname == names.package_info;
duke@1 2467 ClassSymbol c = isPkgInfo
duke@1 2468 ? p.package_info
duke@1 2469 : (ClassSymbol) p.members_field.lookup(classname).sym;
duke@1 2470 if (c == null) {
duke@1 2471 c = enterClass(classname, p);
duke@1 2472 if (c.classfile == null) // only update the file if's it's newly created
duke@1 2473 c.classfile = file;
duke@1 2474 if (isPkgInfo) {
duke@1 2475 p.package_info = c;
duke@1 2476 } else {
duke@1 2477 if (c.owner == p) // it might be an inner class
duke@1 2478 p.members_field.enter(c);
duke@1 2479 }
duke@1 2480 } else if (c.classfile != null && (c.flags_field & seen) == 0) {
duke@1 2481 // if c.classfile == null, we are currently compiling this class
duke@1 2482 // and no further action is necessary.
duke@1 2483 // if (c.flags_field & seen) != 0, we have already encountered
duke@1 2484 // a file of the same kind; again no further action is necessary.
duke@1 2485 if ((c.flags_field & (CLASS_SEEN | SOURCE_SEEN)) != 0)
duke@1 2486 c.classfile = preferredFileObject(file, c.classfile);
duke@1 2487 }
duke@1 2488 c.flags_field |= seen;
duke@1 2489 }
duke@1 2490
duke@1 2491 /** Implement policy to choose to derive information from a source
duke@1 2492 * file or a class file when both are present. May be overridden
duke@1 2493 * by subclasses.
duke@1 2494 */
duke@1 2495 protected JavaFileObject preferredFileObject(JavaFileObject a,
duke@1 2496 JavaFileObject b) {
duke@1 2497
duke@1 2498 if (preferSource)
duke@1 2499 return (a.getKind() == JavaFileObject.Kind.SOURCE) ? a : b;
duke@1 2500 else {
duke@1 2501 long adate = a.getLastModified();
duke@1 2502 long bdate = b.getLastModified();
duke@1 2503 // 6449326: policy for bad lastModifiedTime in ClassReader
duke@1 2504 //assert adate >= 0 && bdate >= 0;
duke@1 2505 return (adate > bdate) ? a : b;
duke@1 2506 }
duke@1 2507 }
duke@1 2508
duke@1 2509 /**
duke@1 2510 * specifies types of files to be read when filling in a package symbol
duke@1 2511 */
duke@1 2512 protected EnumSet<JavaFileObject.Kind> getPackageFileKinds() {
duke@1 2513 return EnumSet.of(JavaFileObject.Kind.CLASS, JavaFileObject.Kind.SOURCE);
duke@1 2514 }
duke@1 2515
duke@1 2516 /**
duke@1 2517 * this is used to support javadoc
duke@1 2518 */
duke@1 2519 protected void extraFileActions(PackageSymbol pack, JavaFileObject fe) {
duke@1 2520 }
duke@1 2521
duke@1 2522 protected Location currentLoc; // FIXME
duke@1 2523
duke@1 2524 private boolean verbosePath = true;
duke@1 2525
duke@1 2526 /** Load directory of package into members scope.
duke@1 2527 */
duke@1 2528 private void fillIn(PackageSymbol p) throws IOException {
duke@1 2529 if (p.members_field == null) p.members_field = new Scope(p);
duke@1 2530 String packageName = p.fullname.toString();
duke@1 2531
duke@1 2532 Set<JavaFileObject.Kind> kinds = getPackageFileKinds();
duke@1 2533
duke@1 2534 fillIn(p, PLATFORM_CLASS_PATH,
duke@1 2535 fileManager.list(PLATFORM_CLASS_PATH,
duke@1 2536 packageName,
duke@1 2537 EnumSet.of(JavaFileObject.Kind.CLASS),
duke@1 2538 false));
duke@1 2539
duke@1 2540 Set<JavaFileObject.Kind> classKinds = EnumSet.copyOf(kinds);
duke@1 2541 classKinds.remove(JavaFileObject.Kind.SOURCE);
duke@1 2542 boolean wantClassFiles = !classKinds.isEmpty();
duke@1 2543
duke@1 2544 Set<JavaFileObject.Kind> sourceKinds = EnumSet.copyOf(kinds);
duke@1 2545 sourceKinds.remove(JavaFileObject.Kind.CLASS);
duke@1 2546 boolean wantSourceFiles = !sourceKinds.isEmpty();
duke@1 2547
duke@1 2548 boolean haveSourcePath = fileManager.hasLocation(SOURCE_PATH);
duke@1 2549
duke@1 2550 if (verbose && verbosePath) {
duke@1 2551 if (fileManager instanceof StandardJavaFileManager) {
duke@1 2552 StandardJavaFileManager fm = (StandardJavaFileManager)fileManager;
duke@1 2553 if (haveSourcePath && wantSourceFiles) {
duke@1 2554 List<File> path = List.nil();
duke@1 2555 for (File file : fm.getLocation(SOURCE_PATH)) {
duke@1 2556 path = path.prepend(file);
duke@1 2557 }
duke@1 2558 printVerbose("sourcepath", path.reverse().toString());
duke@1 2559 } else if (wantSourceFiles) {
duke@1 2560 List<File> path = List.nil();
duke@1 2561 for (File file : fm.getLocation(CLASS_PATH)) {
duke@1 2562 path = path.prepend(file);
duke@1 2563 }
duke@1 2564 printVerbose("sourcepath", path.reverse().toString());
duke@1 2565 }
duke@1 2566 if (wantClassFiles) {
duke@1 2567 List<File> path = List.nil();
duke@1 2568 for (File file : fm.getLocation(PLATFORM_CLASS_PATH)) {
duke@1 2569 path = path.prepend(file);
duke@1 2570 }
duke@1 2571 for (File file : fm.getLocation(CLASS_PATH)) {
duke@1 2572 path = path.prepend(file);
duke@1 2573 }
duke@1 2574 printVerbose("classpath", path.reverse().toString());
duke@1 2575 }
duke@1 2576 }
duke@1 2577 }
duke@1 2578
duke@1 2579 if (wantSourceFiles && !haveSourcePath) {
duke@1 2580 fillIn(p, CLASS_PATH,
duke@1 2581 fileManager.list(CLASS_PATH,
duke@1 2582 packageName,
duke@1 2583 kinds,
duke@1 2584 false));
duke@1 2585 } else {
duke@1 2586 if (wantClassFiles)
duke@1 2587 fillIn(p, CLASS_PATH,
duke@1 2588 fileManager.list(CLASS_PATH,
duke@1 2589 packageName,
duke@1 2590 classKinds,
duke@1 2591 false));
duke@1 2592 if (wantSourceFiles)
duke@1 2593 fillIn(p, SOURCE_PATH,
duke@1 2594 fileManager.list(SOURCE_PATH,
duke@1 2595 packageName,
duke@1 2596 sourceKinds,
duke@1 2597 false));
duke@1 2598 }
duke@1 2599 verbosePath = false;
duke@1 2600 }
duke@1 2601 // where
duke@1 2602 private void fillIn(PackageSymbol p,
duke@1 2603 Location location,
duke@1 2604 Iterable<JavaFileObject> files)
duke@1 2605 {
duke@1 2606 currentLoc = location;
duke@1 2607 for (JavaFileObject fo : files) {
duke@1 2608 switch (fo.getKind()) {
duke@1 2609 case CLASS:
duke@1 2610 case SOURCE: {
duke@1 2611 // TODO pass binaryName to includeClassFile
duke@1 2612 String binaryName = fileManager.inferBinaryName(currentLoc, fo);
duke@1 2613 String simpleName = binaryName.substring(binaryName.lastIndexOf(".") + 1);
duke@1 2614 if (SourceVersion.isIdentifier(simpleName) ||
jrose@267 2615 fo.getKind() == JavaFileObject.Kind.CLASS ||
duke@1 2616 simpleName.equals("package-info"))
duke@1 2617 includeClassFile(p, fo);
duke@1 2618 break;
duke@1 2619 }
duke@1 2620 default:
duke@1 2621 extraFileActions(p, fo);
duke@1 2622 }
duke@1 2623 }
duke@1 2624 }
duke@1 2625
duke@1 2626 /** Output for "-verbose" option.
duke@1 2627 * @param key The key to look up the correct internationalized string.
duke@1 2628 * @param arg An argument for substitution into the output string.
duke@1 2629 */
duke@1 2630 private void printVerbose(String key, CharSequence arg) {
duke@1 2631 Log.printLines(log.noticeWriter, Log.getLocalizedString("verbose." + key, arg));
duke@1 2632 }
duke@1 2633
duke@1 2634 /** Output for "-checkclassfile" option.
duke@1 2635 * @param key The key to look up the correct internationalized string.
duke@1 2636 * @param arg An argument for substitution into the output string.
duke@1 2637 */
duke@1 2638 private void printCCF(String key, Object arg) {
duke@1 2639 Log.printLines(log.noticeWriter, Log.getLocalizedString(key, arg));
duke@1 2640 }
duke@1 2641
duke@1 2642
duke@1 2643 public interface SourceCompleter {
duke@1 2644 void complete(ClassSymbol sym)
duke@1 2645 throws CompletionFailure;
duke@1 2646 }
duke@1 2647
duke@1 2648 /**
duke@1 2649 * A subclass of JavaFileObject for the sourcefile attribute found in a classfile.
duke@1 2650 * The attribute is only the last component of the original filename, so is unlikely
duke@1 2651 * to be valid as is, so operations other than those to access the name throw
duke@1 2652 * UnsupportedOperationException
duke@1 2653 */
duke@1 2654 private static class SourceFileObject extends BaseFileObject {
duke@1 2655
duke@1 2656 /** The file's name.
duke@1 2657 */
duke@1 2658 private Name name;
jjg@57 2659 private Name flatname;
duke@1 2660
jjg@57 2661 public SourceFileObject(Name name, Name flatname) {
jjg@57 2662 super(null); // no file manager; never referenced for this file object
duke@1 2663 this.name = name;
jjg@57 2664 this.flatname = flatname;
duke@1 2665 }
duke@1 2666
jjg@415 2667 @Override
jjg@415 2668 public URI toUri() {
jjg@415 2669 try {
jjg@415 2670 return new URI(null, name.toString(), null);
jjg@415 2671 } catch (URISyntaxException e) {
jjg@415 2672 throw new CannotCreateUriError(name.toString(), e);
jjg@415 2673 }
jjg@415 2674 }
jjg@415 2675
jjg@415 2676 @Override
jjg@415 2677 public String getName() {
jjg@415 2678 return name.toString();
jjg@415 2679 }
jjg@415 2680
jjg@415 2681 @Override
jjg@415 2682 public String getShortName() {
jjg@415 2683 return getName();
jjg@415 2684 }
jjg@415 2685
jjg@415 2686 @Override
jjg@415 2687 public JavaFileObject.Kind getKind() {
jjg@415 2688 return getKind(getName());
jjg@415 2689 }
jjg@415 2690
jjg@415 2691 @Override
duke@1 2692 public InputStream openInputStream() {
duke@1 2693 throw new UnsupportedOperationException();
duke@1 2694 }
duke@1 2695
jjg@415 2696 @Override
duke@1 2697 public OutputStream openOutputStream() {
duke@1 2698 throw new UnsupportedOperationException();
duke@1 2699 }
duke@1 2700
jjg@415 2701 @Override
jjg@415 2702 public CharBuffer getCharContent(boolean ignoreEncodingErrors) {
duke@1 2703 throw new UnsupportedOperationException();
duke@1 2704 }
duke@1 2705
jjg@415 2706 @Override
jjg@415 2707 public Reader openReader(boolean ignoreEncodingErrors) {
jjg@415 2708 throw new UnsupportedOperationException();
jjg@415 2709 }
jjg@415 2710
jjg@415 2711 @Override
duke@1 2712 public Writer openWriter() {
duke@1 2713 throw new UnsupportedOperationException();
duke@1 2714 }
duke@1 2715
jjg@415 2716 @Override
duke@1 2717 public long getLastModified() {
duke@1 2718 throw new UnsupportedOperationException();
duke@1 2719 }
duke@1 2720
jjg@415 2721 @Override
duke@1 2722 public boolean delete() {
duke@1 2723 throw new UnsupportedOperationException();
duke@1 2724 }
duke@1 2725
jjg@415 2726 @Override
jjg@415 2727 protected String inferBinaryName(Iterable<? extends File> path) {
jjg@415 2728 return flatname.toString();
jjg@415 2729 }
jjg@415 2730
jjg@415 2731 @Override
jjg@415 2732 public boolean isNameCompatible(String simpleName, JavaFileObject.Kind kind) {
jjg@415 2733 return true; // fail-safe mode
duke@1 2734 }
duke@1 2735
jjg@424 2736 /**
jjg@424 2737 * Check if two file objects are equal.
jjg@424 2738 * SourceFileObjects are just placeholder objects for the value of a
jjg@424 2739 * SourceFile attribute, and do not directly represent specific files.
jjg@424 2740 * Two SourceFileObjects are equal if their names are equal.
jjg@424 2741 */
duke@1 2742 @Override
duke@1 2743 public boolean equals(Object other) {
jjg@424 2744 if (this == other)
jjg@424 2745 return true;
jjg@424 2746
duke@1 2747 if (!(other instanceof SourceFileObject))
duke@1 2748 return false;
jjg@424 2749
duke@1 2750 SourceFileObject o = (SourceFileObject) other;
duke@1 2751 return name.equals(o.name);
duke@1 2752 }
duke@1 2753
duke@1 2754 @Override
duke@1 2755 public int hashCode() {
duke@1 2756 return name.hashCode();
duke@1 2757 }
duke@1 2758 }
duke@1 2759 }

mercurial