1 /* 2 * Copyright (c) 2006, 2022, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package build.tools.symbolgenerator; 27 28 import build.tools.symbolgenerator.CreateSymbols.ModuleHeaderDescription.ExportsDescription; 29 import build.tools.symbolgenerator.CreateSymbols 30 .ModuleHeaderDescription 31 .ProvidesDescription; 32 import build.tools.symbolgenerator.CreateSymbols 33 .ModuleHeaderDescription 34 .RequiresDescription; 35 36 import java.io.BufferedInputStream; 37 import java.io.BufferedReader; 38 import java.io.BufferedOutputStream; 39 import java.io.ByteArrayInputStream; 40 import java.io.ByteArrayOutputStream; 41 import java.io.File; 42 import java.io.FileOutputStream; 43 import java.io.IOException; 44 import java.io.InputStream; 45 import java.io.OutputStream; 46 import java.io.StringWriter; 47 import java.io.Writer; 48 import java.nio.charset.StandardCharsets; 49 import java.nio.file.Files; 50 import java.nio.file.FileVisitResult; 51 import java.nio.file.FileVisitor; 52 import java.nio.file.Path; 53 import java.nio.file.Paths; 54 import java.nio.file.attribute.BasicFileAttributes; 55 import java.util.stream.Stream; 56 import java.util.ArrayList; 57 import java.util.Arrays; 58 import java.util.Calendar; 59 import java.util.Collection; 60 import java.util.Collections; 61 import java.util.Comparator; 62 import java.util.EnumSet; 63 import java.util.HashMap; 64 import java.util.HashSet; 65 import java.util.Iterator; 66 import java.util.LinkedHashMap; 67 import java.util.List; 68 import java.util.Locale; 69 import java.util.Map; 70 import java.util.Map.Entry; 71 import java.util.Objects; 72 import java.util.Set; 73 import java.util.TimeZone; 74 import java.util.TreeMap; 75 import java.util.TreeSet; 76 import java.util.function.Function; 77 import java.util.function.Predicate; 78 import java.util.regex.Matcher; 79 import java.util.regex.Pattern; 80 import java.util.stream.Collectors; 81 import java.util.zip.ZipEntry; 82 import java.util.zip.ZipOutputStream; 83 84 import javax.tools.JavaFileManager; 85 import javax.tools.JavaFileManager.Location; 86 import javax.tools.JavaFileObject; 87 import javax.tools.JavaFileObject.Kind; 88 import javax.tools.StandardLocation; 89 90 import com.sun.source.util.JavacTask; 91 import com.sun.tools.classfile.AccessFlags; 92 import com.sun.tools.classfile.Annotation; 93 import com.sun.tools.classfile.Annotation.Annotation_element_value; 94 import com.sun.tools.classfile.Annotation.Array_element_value; 95 import com.sun.tools.classfile.Annotation.Class_element_value; 96 import com.sun.tools.classfile.Annotation.Enum_element_value; 97 import com.sun.tools.classfile.Annotation.Primitive_element_value; 98 import com.sun.tools.classfile.Annotation.element_value; 99 import com.sun.tools.classfile.Annotation.element_value_pair; 100 import com.sun.tools.classfile.AnnotationDefault_attribute; 101 import com.sun.tools.classfile.Attribute; 102 import com.sun.tools.classfile.Attributes; 103 import com.sun.tools.classfile.ClassFile; 104 import com.sun.tools.classfile.ClassWriter; 105 import com.sun.tools.classfile.ConstantPool; 106 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info; 107 import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info; 108 import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info; 109 import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info; 110 import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info; 111 import com.sun.tools.classfile.ConstantPool.CONSTANT_Module_info; 112 import com.sun.tools.classfile.ConstantPool.CONSTANT_Package_info; 113 import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info; 114 import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info; 115 import com.sun.tools.classfile.ConstantPool.CPInfo; 116 import com.sun.tools.classfile.ConstantPool.InvalidIndex; 117 import com.sun.tools.classfile.ConstantPoolException; 118 import com.sun.tools.classfile.ConstantValue_attribute; 119 import com.sun.tools.classfile.Deprecated_attribute; 120 import com.sun.tools.classfile.Descriptor; 121 import com.sun.tools.classfile.Exceptions_attribute; 122 import com.sun.tools.classfile.Field; 123 import com.sun.tools.classfile.InnerClasses_attribute; 124 import com.sun.tools.classfile.InnerClasses_attribute.Info; 125 import com.sun.tools.classfile.Method; 126 import com.sun.tools.classfile.ModulePackages_attribute; 127 import com.sun.tools.classfile.MethodParameters_attribute; 128 import com.sun.tools.classfile.ModuleMainClass_attribute; 129 import com.sun.tools.classfile.ModuleResolution_attribute; 130 import com.sun.tools.classfile.ModuleTarget_attribute; 131 import com.sun.tools.classfile.Module_attribute; 132 import com.sun.tools.classfile.Module_attribute.ExportsEntry; 133 import com.sun.tools.classfile.Module_attribute.OpensEntry; 134 import com.sun.tools.classfile.Module_attribute.ProvidesEntry; 135 import com.sun.tools.classfile.Module_attribute.RequiresEntry; 136 import com.sun.tools.classfile.NestHost_attribute; 137 import com.sun.tools.classfile.NestMembers_attribute; 138 import com.sun.tools.classfile.PermittedSubclasses_attribute; 139 import com.sun.tools.classfile.Record_attribute; 140 import com.sun.tools.classfile.Record_attribute.ComponentInfo; 141 import com.sun.tools.classfile.RuntimeAnnotations_attribute; 142 import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute; 143 import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute; 144 import com.sun.tools.classfile.RuntimeParameterAnnotations_attribute; 145 import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute; 146 import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute; 147 import com.sun.tools.classfile.Signature_attribute; 148 import com.sun.tools.javac.api.JavacTool; 149 import com.sun.tools.javac.jvm.Target; 150 import com.sun.tools.javac.util.Assert; 151 import com.sun.tools.javac.util.Context; 152 import com.sun.tools.javac.util.Pair; 153 import java.util.Optional; 154 155 /** 156 * A tool for processing the .sym.txt files. 157 * 158 * To add historical data for JDK N, N >= 11, do the following: 159 * * cd <open-jdk-checkout>/src/jdk.compiler/share/data/symbols 160 * * <jdk-N>/bin/java --add-exports jdk.jdeps/com.sun.tools.classfile=ALL-UNNAMED \ 161 * --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED \ 162 * --add-exports jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED \ 163 * --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED \ 164 * --add-modules jdk.jdeps \ 165 * ../../../make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java \ 166 * build-description-incremental symbols include.list 167 * * sanity-check the new and updates files in src/jdk.compiler/share/data/symbols and commit them 168 * 169 * The tools allows to: 170 * * convert the .sym.txt into class/sig files for ct.sym 171 * * in cooperation with the adjacent history Probe, construct .sym.txt files for previous platforms 172 * * enhance existing .sym.txt files with a new set .sym.txt for the current platform 173 * 174 * To convert the .sym.txt files to class/sig files from ct.sym, run: 175 * java build.tool.symbolgenerator.CreateSymbols build-ctsym <platform-description-file> <target-directory> 176 * 177 * The <platform-description-file> is a file of this format: 178 * generate platforms <platform-ids-to-generate separate with ':'> 179 * platform version <platform-id1> files <.sym.txt files containing history data for given platform, separate with ':'> 180 * platform version <platform-id2> base <base-platform-id> files <.sym.txt files containing history data for given platform, separate with ':'> 181 * 182 * The content of platform "<base-platform-id>" is also automatically added to the content of 183 * platform "<platform-id2>", unless explicitly excluded in "<platform-id2>"'s .sym.txt files. 184 * 185 * To create the .sym.txt files, first run the history Probe for all the previous platforms: 186 * <jdk-N>/bin/java build.tools.symbolgenerator.Probe <classes-for-N> 187 * 188 * Where <classes-for-N> is a name of a file into which the classes from the bootclasspath of <jdk-N> 189 * will be written. 190 * 191 * Then create the <platform-description-file> file and the .sym.txt files like this: 192 * java build.tools.symbolgenerator.CreateSymbols build-description <target-directory> <path-to-a-JDK-root> <include-list-file> 193 * <platform-id1> <target-file-for-platform1> "<none>" 194 * <platform-id2> <target-file-for-platform2> <diff-against-platform2> 195 * <platform-id3> <target-file-for-platform3> <diff-against-platform3> 196 * ... 197 * 198 * The <include-list-file> is a file that specifies classes that should be included/excluded. 199 * Lines that start with '+' represent class or package that should be included, '-' class or package 200 * that should be excluded. '/' should be used as package name delimiter, packages should end with '/'. 201 * Several include list files may be specified, separated by File.pathSeparator. 202 * 203 * When <diff-against-platformN> is specified, the .sym.txt files for platform N will only contain 204 * differences between platform N and the specified platform. The first platform (denoted F further) 205 * that is specified should use literal value "<none>", to have all the APIs of the platform written to 206 * the .sym.txt files. If there is an existing platform with full .sym.txt files in the repository, 207 * that platform should be used as the first platform to avoid unnecessary changes to the .sym.txt 208 * files. The <diff-against-platformN> for platform N should be determined as follows: if N < F, then 209 * <diff-against-platformN> should be N + 1. If F < N, then <diff-against-platformN> should be N - 1. 210 * If N is a custom/specialized sub-version of another platform N', then <diff-against-platformN> should be N'. 211 * 212 * To generate the .sym.txt files for OpenJDK 7 and 8: 213 * <jdk-7>/bin/java build.tools.symbolgenerator.Probe OpenJDK7.classes 214 * <jdk-8>/bin/java build.tools.symbolgenerator.Probe OpenJDK8.classes 215 * java build.tools.symbolgenerator.CreateSymbols build-description src/jdk.compiler/share/data/symbols 216 * $TOPDIR src/jdk.compiler/share/data/symbols/include.list 217 * 8 OpenJDK8.classes '<none>' 218 * 7 OpenJDK7.classes 8 219 * 220 * Note: the versions are expected to be a single character. 221 * 222 */ 223 public class CreateSymbols { 224 225 //<editor-fold defaultstate="collapsed" desc="ct.sym construction"> 226 /**Create sig files for ct.sym reading the classes description from the directory that contains 227 * {@code ctDescriptionFile}, using the file as a recipe to create the sigfiles. 228 */ 229 @SuppressWarnings("unchecked") 230 public void createSymbols(String ctDescriptionFileExtra, String ctDescriptionFile, String ctSymLocation, 231 long timestamp, String currentVersion, String systemModules) throws IOException { 232 LoadDescriptions data = load(ctDescriptionFileExtra != null ? Paths.get(ctDescriptionFileExtra) 233 : null, 234 Paths.get(ctDescriptionFile)); 235 236 stripNonExistentAnnotations(data); 237 splitHeaders(data.classes); 238 239 Map<String, Map<Character, String>> package2Version2Module = new HashMap<>(); 240 Map<String, Set<FileData>> directory2FileData = new TreeMap<>(); 241 242 for (ModuleDescription md : data.modules.values()) { 243 for (ModuleHeaderDescription mhd : md.header) { 244 List<String> versionsList = 245 Collections.singletonList(mhd.versions); 246 writeModulesForVersions(directory2FileData, 247 md, 248 mhd, 249 versionsList); 250 List<String> packages = new ArrayList<>(); 251 mhd.exports.stream() 252 .map(ExportsDescription::packageName) 253 .forEach(packages::add); 254 if (mhd.extraModulePackages != null) { 255 packages.addAll(mhd.extraModulePackages); 256 } 257 packages.stream().forEach(pkg -> { 258 for (char v : mhd.versions.toCharArray()) { 259 package2Version2Module.computeIfAbsent(pkg, dummy -> new HashMap<>()).put(v, md.name); 260 } 261 }); 262 } 263 } 264 265 for (ClassDescription classDescription : data.classes) { 266 Map<Character, String> version2Module = package2Version2Module.getOrDefault(classDescription.packge().replace('.', '/'), Collections.emptyMap()); 267 for (ClassHeaderDescription header : classDescription.header) { 268 Set<String> jointVersions = new HashSet<>(); 269 jointVersions.add(header.versions); 270 limitJointVersion(jointVersions, classDescription.fields); 271 limitJointVersion(jointVersions, classDescription.methods); 272 Map<String, StringBuilder> module2Versions = new HashMap<>(); 273 for (char v : header.versions.toCharArray()) { 274 String module = version2Module.get(v); 275 if (module == null) { 276 if (v >= '9') { 277 throw new AssertionError("No module for " + classDescription.name + 278 " and version " + v); 279 } 280 module = version2Module.get('9'); 281 if (module == null) { 282 module = "java.base"; 283 } 284 } 285 module2Versions.computeIfAbsent(module, dummy -> new StringBuilder()).append(v); 286 } 287 for (Entry<String, StringBuilder> e : module2Versions.entrySet()) { 288 Set<String> currentVersions = new HashSet<>(jointVersions); 289 limitJointVersion(currentVersions, e.getValue().toString()); 290 currentVersions = currentVersions.stream().filter(vers -> !disjoint(vers, e.getValue().toString())).collect(Collectors.toSet()); 291 writeClassesForVersions(directory2FileData, classDescription, header, e.getKey(), currentVersions); 292 } 293 } 294 } 295 296 currentVersion = Integer.toString(Integer.parseInt(currentVersion), Character.MAX_RADIX); 297 currentVersion = currentVersion.toUpperCase(Locale.ROOT); 298 299 openDirectory(directory2FileData, currentVersion + "/") 300 .add(new FileData(currentVersion + "/system-modules", 301 Files.readAllBytes(Paths.get(systemModules)))); 302 303 try (OutputStream fos = new FileOutputStream(ctSymLocation); 304 OutputStream bos = new BufferedOutputStream(fos); 305 ZipOutputStream jos = new ZipOutputStream(bos)) { 306 for (Entry<String, Set<FileData>> e : directory2FileData.entrySet()) { 307 jos.putNextEntry(createZipEntry(e.getKey(), timestamp)); 308 for (FileData fd : e.getValue()) { 309 jos.putNextEntry(createZipEntry(fd.fileName, timestamp)); 310 jos.write(fd.fileData); 311 } 312 } 313 } 314 } 315 316 private static final String PREVIEW_FEATURE_ANNOTATION_OLD = 317 "Ljdk/internal/PreviewFeature;"; 318 private static final String PREVIEW_FEATURE_ANNOTATION_NEW = 319 "Ljdk/internal/javac/PreviewFeature;"; 320 private static final String PREVIEW_FEATURE_ANNOTATION_INTERNAL = 321 "Ljdk/internal/PreviewFeature+Annotation;"; 322 private static final String VALUE_BASED_ANNOTATION = 323 "Ljdk/internal/ValueBased;"; 324 private static final String VALUE_BASED_ANNOTATION_INTERNAL = 325 "Ljdk/internal/ValueBased+Annotation;"; 326 public static final Set<String> HARDCODED_ANNOTATIONS = new HashSet<>( 327 List.of("Ljdk/Profile+Annotation;", 328 "Lsun/Proprietary+Annotation;", 329 PREVIEW_FEATURE_ANNOTATION_OLD, 330 PREVIEW_FEATURE_ANNOTATION_NEW, 331 VALUE_BASED_ANNOTATION)); 332 333 private void stripNonExistentAnnotations(LoadDescriptions data) { 334 Set<String> allClasses = data.classes.name2Class.keySet(); 335 data.modules.values().forEach(mod -> { 336 stripNonExistentAnnotations(allClasses, mod.header); 337 }); 338 data.classes.classes.forEach(clazz -> { 339 stripNonExistentAnnotations(allClasses, clazz.header); 340 stripNonExistentAnnotations(allClasses, clazz.fields); 341 stripNonExistentAnnotations(allClasses, clazz.methods); 342 }); 343 } 344 345 private void stripNonExistentAnnotations(Set<String> allClasses, Iterable<? extends FeatureDescription> descs) { 346 descs.forEach(d -> stripNonExistentAnnotations(allClasses, d)); 347 } 348 349 private void stripNonExistentAnnotations(Set<String> allClasses, FeatureDescription d) { 350 stripNonExistentAnnotations(allClasses, d.classAnnotations); 351 stripNonExistentAnnotations(allClasses, d.runtimeAnnotations); 352 } 353 354 private void stripNonExistentAnnotations(Set<String> allClasses, List<AnnotationDescription> annotations) { 355 if (annotations != null) 356 annotations.removeIf(ann -> !HARDCODED_ANNOTATIONS.contains(ann.annotationType) && 357 !allClasses.contains(ann.annotationType.substring(1, ann.annotationType.length() - 1))); 358 } 359 360 private ZipEntry createZipEntry(String name, long timestamp) { 361 ZipEntry ze = new ZipEntry(name); 362 363 ze.setTime(timestamp); 364 return ze; 365 } 366 367 public static String EXTENSION = ".sig"; 368 369 LoadDescriptions load(Path ctDescriptionWithExtraContent, Path ctDescriptionOpen) throws IOException { 370 Map<String, PlatformInput> platforms = new LinkedHashMap<>(); 371 372 if (ctDescriptionWithExtraContent != null && Files.isRegularFile(ctDescriptionWithExtraContent)) { 373 try (LineBasedReader reader = new LineBasedReader(ctDescriptionWithExtraContent)) { 374 while (reader.hasNext()) { 375 switch (reader.lineKey) { 376 case "generate": 377 //ignore 378 reader.moveNext(); 379 break; 380 case "platform": 381 PlatformInput platform = PlatformInput.load(ctDescriptionWithExtraContent, 382 reader); 383 platforms.put(platform.version, platform); 384 reader.moveNext(); 385 break; 386 default: 387 throw new IllegalStateException("Unknown key: " + reader.lineKey); 388 } 389 } 390 } 391 } 392 393 Set<String> generatePlatforms = null; 394 395 try (LineBasedReader reader = new LineBasedReader(ctDescriptionOpen)) { 396 while (reader.hasNext()) { 397 switch (reader.lineKey) { 398 case "generate": 399 String[] platformsAttr = reader.attributes.get("platforms").split(":"); 400 generatePlatforms = new HashSet<>(List.of(platformsAttr)); 401 reader.moveNext(); 402 break; 403 case "platform": 404 PlatformInput platform = PlatformInput.load(ctDescriptionOpen, reader); 405 if (!platforms.containsKey(platform.version)) 406 platforms.put(platform.version, platform); 407 reader.moveNext(); 408 break; 409 default: 410 throw new IllegalStateException("Unknown key: " + reader.lineKey); 411 } 412 } 413 } 414 415 Map<String, ClassDescription> classes = new LinkedHashMap<>(); 416 Map<String, ModuleDescription> modules = new LinkedHashMap<>(); 417 418 for (PlatformInput platform : platforms.values()) { 419 for (ClassDescription cd : classes.values()) { 420 addNewVersion(cd.header, platform.basePlatform, platform.version); 421 addNewVersion(cd.fields, platform.basePlatform, platform.version); 422 addNewVersion(cd.methods, platform.basePlatform, platform.version); 423 } 424 for (ModuleDescription md : modules.values()) { 425 addNewVersion(md.header, platform.basePlatform, platform.version); 426 } 427 for (String input : platform.files) { 428 Path inputFile = platform.ctDescription.getParent().resolve(input); 429 try (LineBasedReader reader = new LineBasedReader(inputFile)) { 430 while (reader.hasNext()) { 431 String nameAttr = reader.attributes.get("name"); 432 switch (reader.lineKey) { 433 case "class": case "-class": 434 ClassDescription cd = 435 classes.computeIfAbsent(nameAttr, 436 n -> new ClassDescription()); 437 if ("-class".equals(reader.lineKey)) { 438 removeVersion(cd.header, h -> true, 439 platform.version); 440 reader.moveNext(); 441 continue; 442 } 443 cd.read(reader, platform.basePlatform, 444 platform.version); 445 break; 446 case "module": { 447 ModuleDescription md = 448 modules.computeIfAbsent(nameAttr, 449 n -> new ModuleDescription()); 450 md.read(reader, platform.basePlatform, 451 platform.version); 452 break; 453 } 454 case "-module": { 455 ModuleDescription md = 456 modules.computeIfAbsent(nameAttr, 457 n -> new ModuleDescription()); 458 removeVersion(md.header, h -> true, 459 platform.version); 460 reader.moveNext(); 461 break; 462 } 463 } 464 } 465 } 466 } 467 } 468 469 ClassList result = new ClassList(); 470 471 classes.values().forEach(result::add); 472 return new LoadDescriptions(result, 473 modules, 474 new ArrayList<>(platforms.values())); 475 } 476 477 private static void removeVersion(LoadDescriptions load, String deletePlatform) { 478 for (Iterator<ClassDescription> it = load.classes.iterator(); it.hasNext();) { 479 ClassDescription desc = it.next(); 480 Iterator<ClassHeaderDescription> chdIt = desc.header.iterator(); 481 482 while (chdIt.hasNext()) { 483 ClassHeaderDescription chd = chdIt.next(); 484 485 chd.versions = removeVersion(chd.versions, deletePlatform); 486 if (chd.versions.isEmpty()) { 487 chdIt.remove(); 488 } 489 } 490 491 if (desc.header.isEmpty()) { 492 it.remove(); 493 continue; 494 } 495 496 Iterator<MethodDescription> methodIt = desc.methods.iterator(); 497 498 while (methodIt.hasNext()) { 499 MethodDescription method = methodIt.next(); 500 501 method.versions = removeVersion(method.versions, deletePlatform); 502 if (method.versions.isEmpty()) 503 methodIt.remove(); 504 } 505 506 Iterator<FieldDescription> fieldIt = desc.fields.iterator(); 507 508 while (fieldIt.hasNext()) { 509 FieldDescription field = fieldIt.next(); 510 511 field.versions = removeVersion(field.versions, deletePlatform); 512 if (field.versions.isEmpty()) 513 fieldIt.remove(); 514 } 515 } 516 517 for (Iterator<ModuleDescription> it = load.modules.values().iterator(); it.hasNext();) { 518 ModuleDescription desc = it.next(); 519 Iterator<ModuleHeaderDescription> mhdIt = desc.header.iterator(); 520 521 while (mhdIt.hasNext()) { 522 ModuleHeaderDescription mhd = mhdIt.next(); 523 524 mhd.versions = removeVersion(mhd.versions, deletePlatform); 525 if (mhd.versions.isEmpty()) 526 mhdIt.remove(); 527 } 528 529 if (desc.header.isEmpty()) { 530 it.remove(); 531 continue; 532 } 533 } 534 } 535 536 static final class LoadDescriptions { 537 public final ClassList classes; 538 public final Map<String, ModuleDescription> modules; 539 public final List<PlatformInput> versions; 540 541 public LoadDescriptions(ClassList classes, 542 Map<String, ModuleDescription> modules, 543 List<PlatformInput> versions) { 544 this.classes = classes; 545 this.modules = modules; 546 this.versions = versions; 547 } 548 549 } 550 551 static final class LineBasedReader implements AutoCloseable { 552 private final BufferedReader input; 553 public String lineKey; 554 public Map<String, String> attributes = new HashMap<>(); 555 556 public LineBasedReader(Path input) throws IOException { 557 this.input = Files.newBufferedReader(input); 558 moveNext(); 559 } 560 561 public void moveNext() throws IOException { 562 String line = input.readLine(); 563 564 if (line == null) { 565 lineKey = null; 566 return ; 567 } 568 569 if (line.trim().isEmpty() || line.startsWith("#")) { 570 moveNext(); 571 return ; 572 } 573 574 String[] parts = line.split(" "); 575 576 lineKey = parts[0]; 577 attributes.clear(); 578 579 for (int i = 1; i < parts.length; i += 2) { 580 attributes.put(parts[i], unquote(parts[i + 1])); 581 } 582 } 583 584 public boolean hasNext() { 585 return lineKey != null; 586 } 587 588 @Override 589 public void close() throws IOException { 590 input.close(); 591 } 592 } 593 594 private static String reduce(String original, String other) { 595 Set<String> otherSet = new HashSet<>(); 596 597 for (char v : other.toCharArray()) { 598 otherSet.add("" + v); 599 } 600 601 return reduce(original, otherSet); 602 } 603 604 private static String reduce(String original, Set<String> generate) { 605 StringBuilder sb = new StringBuilder(); 606 607 for (char v : original.toCharArray()) { 608 if (generate.contains("" + v)) { 609 sb.append(v); 610 } 611 } 612 return sb.toString(); 613 } 614 615 private static String removeVersion(String original, String remove) { 616 StringBuilder sb = new StringBuilder(); 617 618 for (char v : original.toCharArray()) { 619 if (v != remove.charAt(0)) { 620 sb.append(v); 621 } 622 } 623 return sb.toString(); 624 } 625 626 private static class PlatformInput { 627 public final String version; 628 public final String basePlatform; 629 public final List<String> files; 630 public final Path ctDescription; 631 public PlatformInput(Path ctDescription, String version, String basePlatform, List<String> files) { 632 this.ctDescription = ctDescription; 633 this.version = version; 634 this.basePlatform = basePlatform; 635 this.files = files; 636 } 637 638 public static PlatformInput load(Path ctDescription, LineBasedReader in) throws IOException { 639 return new PlatformInput(ctDescription, 640 in.attributes.get("version"), 641 in.attributes.get("base"), 642 List.of(in.attributes.get("files").split(":"))); 643 } 644 } 645 646 static void addNewVersion(Collection<? extends FeatureDescription> features, 647 String baselineVersion, 648 String version) { 649 features.stream() 650 .filter(f -> f.versions.contains(baselineVersion)) 651 .forEach(f -> f.versions += version); 652 } 653 654 static <T extends FeatureDescription> void removeVersion(Collection<T> features, 655 Predicate<T> shouldRemove, 656 String version) { 657 for (T existing : features) { 658 if (shouldRemove.test(existing) && existing.versions.endsWith(version)) { 659 existing.versions = existing.versions.replace(version, ""); 660 return; 661 } 662 } 663 } 664 665 /**Changes to class header of an outer class (like adding a new type parameter) may affect 666 * its innerclasses. So if the outer class's header is different for versions A and B, need to 667 * split its innerclasses headers to also be different for versions A and B. 668 */ 669 static void splitHeaders(ClassList classes) { 670 Set<String> ctVersions = new HashSet<>(); 671 672 for (ClassDescription cd : classes) { 673 for (ClassHeaderDescription header : cd.header) { 674 for (char c : header.versions.toCharArray()) { 675 ctVersions.add("" + c); 676 } 677 } 678 } 679 680 classes.sort(); 681 682 for (ClassDescription cd : classes) { 683 Map<String, String> outerSignatures2Version = new HashMap<>(); 684 685 for (String version : ctVersions) { //XXX 686 ClassDescription outer = cd; 687 String outerSignatures = ""; 688 689 while ((outer = classes.enclosingClass(outer)) != null) { 690 for (ClassHeaderDescription outerHeader : outer.header) { 691 if (outerHeader.versions.contains(version)) { 692 outerSignatures += outerHeader.signature; 693 } 694 } 695 } 696 697 outerSignatures2Version.compute(outerSignatures, 698 (key, value) -> value != null ? value + version : version); 699 } 700 701 List<ClassHeaderDescription> newHeaders = new ArrayList<>(); 702 703 HEADER_LOOP: for (ClassHeaderDescription header : cd.header) { 704 for (String versions : outerSignatures2Version.values()) { 705 if (containsAll(versions, header.versions)) { 706 newHeaders.add(header); 707 continue HEADER_LOOP; 708 } 709 if (disjoint(versions, header.versions)) { 710 continue; 711 } 712 ClassHeaderDescription newHeader = new ClassHeaderDescription(); 713 newHeader.classAnnotations = header.classAnnotations; 714 newHeader.deprecated = header.deprecated; 715 newHeader.extendsAttr = header.extendsAttr; 716 newHeader.flags = header.flags; 717 newHeader.implementsAttr = header.implementsAttr; 718 newHeader.innerClasses = header.innerClasses; 719 newHeader.runtimeAnnotations = header.runtimeAnnotations; 720 newHeader.signature = header.signature; 721 newHeader.versions = reduce(header.versions, versions); 722 723 newHeaders.add(newHeader); 724 } 725 } 726 727 cd.header = newHeaders; 728 } 729 } 730 731 void limitJointVersion(Set<String> jointVersions, List<? extends FeatureDescription> features) { 732 for (FeatureDescription feature : features) { 733 limitJointVersion(jointVersions, feature.versions); 734 } 735 } 736 737 void limitJointVersion(Set<String> jointVersions, String versions) { 738 for (String version : jointVersions) { 739 if (!containsAll(versions, version) && 740 !disjoint(versions, version)) { 741 StringBuilder featurePart = new StringBuilder(); 742 StringBuilder otherPart = new StringBuilder(); 743 for (char v : version.toCharArray()) { 744 if (versions.indexOf(v) != (-1)) { 745 featurePart.append(v); 746 } else { 747 otherPart.append(v); 748 } 749 } 750 jointVersions.remove(version); 751 if (featurePart.length() == 0 || otherPart.length() == 0) { 752 throw new AssertionError(); 753 } 754 jointVersions.add(featurePart.toString()); 755 jointVersions.add(otherPart.toString()); 756 break; 757 } 758 } 759 } 760 761 private static boolean containsAll(String versions, String subVersions) { 762 for (char c : subVersions.toCharArray()) { 763 if (versions.indexOf(c) == (-1)) 764 return false; 765 } 766 return true; 767 } 768 769 private static boolean disjoint(String version1, String version2) { 770 for (char c : version2.toCharArray()) { 771 if (version1.indexOf(c) != (-1)) 772 return false; 773 } 774 return true; 775 } 776 777 void writeClassesForVersions(Map<String, Set<FileData>> directory2FileData, 778 ClassDescription classDescription, 779 ClassHeaderDescription header, 780 String module, 781 Iterable<String> versions) 782 throws IOException { 783 for (String ver : versions) { 784 writeClass(directory2FileData, classDescription, header, module, ver); 785 } 786 } 787 788 void writeModulesForVersions(Map<String, Set<FileData>> directory2FileData, 789 ModuleDescription moduleDescription, 790 ModuleHeaderDescription header, 791 Iterable<String> versions) 792 throws IOException { 793 for (String ver : versions) { 794 writeModule(directory2FileData, moduleDescription, header, ver); 795 } 796 } 797 798 //<editor-fold defaultstate="collapsed" desc="Class Writing"> 799 void writeModule(Map<String, Set<FileData>> directory2FileData, 800 ModuleDescription moduleDescription, 801 ModuleHeaderDescription header, 802 String version) throws IOException { 803 List<CPInfo> constantPool = new ArrayList<>(); 804 constantPool.add(null); 805 int currentClass = addClass(constantPool, "module-info"); 806 int superclass = 0; 807 int[] interfaces = new int[0]; 808 AccessFlags flags = new AccessFlags(header.flags); 809 Map<String, Attribute> attributesMap = new HashMap<>(); 810 addAttributes(moduleDescription, header, constantPool, attributesMap); 811 Attributes attributes = new Attributes(attributesMap); 812 CPInfo[] cpData = constantPool.toArray(new CPInfo[constantPool.size()]); 813 ConstantPool cp = new ConstantPool(cpData); 814 ClassFile classFile = new ClassFile(0xCAFEBABE, 815 Target.DEFAULT.minorVersion, 816 Target.DEFAULT.majorVersion, 817 cp, 818 flags, 819 currentClass, 820 superclass, 821 interfaces, 822 new Field[0], 823 new Method[0], 824 attributes); 825 826 doWrite(directory2FileData, version, moduleDescription.name, "module-info" + EXTENSION, classFile); 827 } 828 829 void writeClass(Map<String, Set<FileData>> directory2FileData, 830 ClassDescription classDescription, 831 ClassHeaderDescription header, 832 String module, 833 String version) throws IOException { 834 List<CPInfo> constantPool = new ArrayList<>(); 835 constantPool.add(null); 836 List<Method> methods = new ArrayList<>(); 837 for (MethodDescription methDesc : classDescription.methods) { 838 if (disjoint(methDesc.versions, version)) 839 continue; 840 Descriptor descriptor = new Descriptor(addString(constantPool, methDesc.descriptor)); 841 //TODO: LinkedHashMap to avoid param annotations vs. Signature problem in javac's ClassReader: 842 Map<String, Attribute> attributesMap = new LinkedHashMap<>(); 843 addAttributes(methDesc, constantPool, attributesMap); 844 Attributes attributes = new Attributes(attributesMap); 845 AccessFlags flags = new AccessFlags(methDesc.flags); 846 int nameString = addString(constantPool, methDesc.name); 847 methods.add(new Method(flags, nameString, descriptor, attributes)); 848 } 849 List<Field> fields = new ArrayList<>(); 850 for (FieldDescription fieldDesc : classDescription.fields) { 851 if (disjoint(fieldDesc.versions, version)) 852 continue; 853 Descriptor descriptor = new Descriptor(addString(constantPool, fieldDesc.descriptor)); 854 Map<String, Attribute> attributesMap = new HashMap<>(); 855 addAttributes(fieldDesc, constantPool, attributesMap); 856 Attributes attributes = new Attributes(attributesMap); 857 AccessFlags flags = new AccessFlags(fieldDesc.flags); 858 int nameString = addString(constantPool, fieldDesc.name); 859 fields.add(new Field(flags, nameString, descriptor, attributes)); 860 } 861 int currentClass = addClass(constantPool, classDescription.name); 862 int superclass = header.extendsAttr != null ? addClass(constantPool, header.extendsAttr) : 0; 863 int[] interfaces = new int[header.implementsAttr.size()]; 864 int i = 0; 865 for (String intf : header.implementsAttr) { 866 interfaces[i++] = addClass(constantPool, intf); 867 } 868 AccessFlags flags = new AccessFlags(header.flags); 869 Map<String, Attribute> attributesMap = new HashMap<>(); 870 addAttributes(header, constantPool, attributesMap); 871 Attributes attributes = new Attributes(attributesMap); 872 ConstantPool cp = new ConstantPool(constantPool.toArray(new CPInfo[constantPool.size()])); 873 ClassFile classFile = new ClassFile(0xCAFEBABE, 874 Target.DEFAULT.minorVersion, 875 Target.DEFAULT.majorVersion, 876 cp, 877 flags, 878 currentClass, 879 superclass, 880 interfaces, 881 fields.toArray(new Field[0]), 882 methods.toArray(new Method[0]), 883 attributes); 884 885 doWrite(directory2FileData, version, module, classDescription.name + EXTENSION, classFile); 886 } 887 888 private void doWrite(Map<String, Set<FileData>> directory2FileData, 889 String version, 890 String moduleName, 891 String fileName, 892 ClassFile classFile) throws IOException { 893 int lastSlash = fileName.lastIndexOf('/'); 894 String pack = lastSlash != (-1) ? fileName.substring(0, lastSlash + 1) : "/"; 895 String directory = version + "/" + moduleName + "/" + pack; 896 String fullFileName = version + "/" + moduleName + "/" + fileName; 897 try (ByteArrayOutputStream out = new ByteArrayOutputStream()) { 898 ClassWriter w = new ClassWriter(); 899 900 w.write(classFile, out); 901 902 openDirectory(directory2FileData, directory) 903 .add(new FileData(fullFileName, out.toByteArray())); 904 } 905 } 906 907 private Set<FileData> openDirectory(Map<String, Set<FileData>> directory2FileData, 908 String directory) { 909 Comparator<FileData> fileCompare = (fd1, fd2) -> fd1.fileName.compareTo(fd2.fileName); 910 return directory2FileData.computeIfAbsent(directory, d -> new TreeSet<>(fileCompare)); 911 } 912 913 private static class FileData { 914 public final String fileName; 915 public final byte[] fileData; 916 917 public FileData(String fileName, byte[] fileData) { 918 this.fileName = fileName; 919 this.fileData = fileData; 920 } 921 922 } 923 924 private void addAttributes(ModuleDescription md, 925 ModuleHeaderDescription header, 926 List<CPInfo> cp, 927 Map<String, Attribute> attributes) { 928 addGenericAttributes(header, cp, attributes); 929 if (header.moduleResolution != null) { 930 int attrIdx = addString(cp, Attribute.ModuleResolution); 931 final ModuleResolution_attribute resIdx = 932 new ModuleResolution_attribute(attrIdx, 933 header.moduleResolution); 934 attributes.put(Attribute.ModuleResolution, resIdx); 935 } 936 if (header.moduleTarget != null) { 937 int attrIdx = addString(cp, Attribute.ModuleTarget); 938 int targetIdx = addString(cp, header.moduleTarget); 939 attributes.put(Attribute.ModuleTarget, 940 new ModuleTarget_attribute(attrIdx, targetIdx)); 941 } 942 if (header.moduleMainClass != null) { 943 int attrIdx = addString(cp, Attribute.ModuleMainClass); 944 int targetIdx = addString(cp, header.moduleMainClass); 945 attributes.put(Attribute.ModuleMainClass, 946 new ModuleMainClass_attribute(attrIdx, targetIdx)); 947 } 948 int attrIdx = addString(cp, Attribute.Module); 949 attributes.put(Attribute.Module, 950 new Module_attribute(attrIdx, 951 addModuleName(cp, md.name), 952 0, 953 0, 954 header.requires 955 .stream() 956 .map(r -> createRequiresEntry(cp, r)) 957 .collect(Collectors.toList()) 958 .toArray(new RequiresEntry[0]), 959 header.exports 960 .stream() 961 .map(e -> createExportsEntry(cp, e)) 962 .collect(Collectors.toList()) 963 .toArray(new ExportsEntry[0]), 964 header.opens 965 .stream() 966 .map(e -> createOpensEntry(cp, e)) 967 .collect(Collectors.toList()) 968 .toArray(new OpensEntry[0]), 969 header.uses 970 .stream() 971 .mapToInt(u -> addClassName(cp, u)) 972 .toArray(), 973 header.provides 974 .stream() 975 .map(p -> createProvidesEntry(cp, p)) 976 .collect(Collectors.toList()) 977 .toArray(new ProvidesEntry[0]))); 978 addInnerClassesAttribute(header, cp, attributes); 979 } 980 981 private static RequiresEntry createRequiresEntry(List<CPInfo> cp, 982 RequiresDescription r) { 983 final int idx = addModuleName(cp, r.moduleName); 984 return new RequiresEntry(idx, 985 r.flags, 986 r.version != null 987 ? addString(cp, r.version) 988 : 0); 989 } 990 991 private static ExportsEntry createExportsEntry(List<CPInfo> cp, 992 ExportsDescription export) { 993 int[] to; 994 if (export.isQualified()) { 995 to = export.to.stream() 996 .mapToInt(module -> addModuleName(cp, module)) 997 .toArray(); 998 } else { 999 to = new int[0]; 1000 } 1001 return new ExportsEntry(addPackageName(cp, export.packageName()), 0, to); 1002 } 1003 1004 private static OpensEntry createOpensEntry(List<CPInfo> cp, String e) { 1005 return new OpensEntry(addPackageName(cp, e), 0, new int[0]); 1006 } 1007 1008 private static ProvidesEntry createProvidesEntry(List<CPInfo> cp, 1009 ModuleHeaderDescription.ProvidesDescription p) { 1010 final int idx = addClassName(cp, p.interfaceName); 1011 return new ProvidesEntry(idx, p.implNames 1012 .stream() 1013 .mapToInt(i -> addClassName(cp, i)) 1014 .toArray()); 1015 } 1016 1017 private void addAttributes(ClassHeaderDescription header, 1018 List<CPInfo> constantPool, Map<String, Attribute> attributes) { 1019 addGenericAttributes(header, constantPool, attributes); 1020 if (header.nestHost != null) { 1021 int attributeString = addString(constantPool, Attribute.NestHost); 1022 int nestHost = addClass(constantPool, header.nestHost); 1023 attributes.put(Attribute.NestHost, 1024 new NestHost_attribute(attributeString, nestHost)); 1025 } 1026 if (header.nestMembers != null && !header.nestMembers.isEmpty()) { 1027 int attributeString = addString(constantPool, Attribute.NestMembers); 1028 int[] nestMembers = new int[header.nestMembers.size()]; 1029 int i = 0; 1030 for (String intf : header.nestMembers) { 1031 nestMembers[i++] = addClass(constantPool, intf); 1032 } 1033 attributes.put(Attribute.NestMembers, 1034 new NestMembers_attribute(attributeString, nestMembers)); 1035 } 1036 if (header.isRecord) { 1037 assert header.recordComponents != null; 1038 int attributeString = addString(constantPool, Attribute.Record); 1039 ComponentInfo[] recordComponents = new ComponentInfo[header.recordComponents.size()]; 1040 int i = 0; 1041 for (RecordComponentDescription rcd : header.recordComponents) { 1042 int name = addString(constantPool, rcd.name); 1043 Descriptor desc = new Descriptor(addString(constantPool, rcd.descriptor)); 1044 Map<String, Attribute> nestedAttrs = new HashMap<>(); 1045 addGenericAttributes(rcd, constantPool, nestedAttrs); 1046 Attributes attrs = new Attributes(nestedAttrs); 1047 recordComponents[i++] = new ComponentInfo(name, desc, attrs); 1048 } 1049 attributes.put(Attribute.Record, 1050 new Record_attribute(attributeString, recordComponents)); 1051 } 1052 if (header.isSealed) { 1053 int attributeString = addString(constantPool, Attribute.PermittedSubclasses); 1054 int[] subclasses = new int[header.permittedSubclasses.size()]; 1055 int i = 0; 1056 for (String intf : header.permittedSubclasses) { 1057 subclasses[i++] = addClass(constantPool, intf); 1058 } 1059 attributes.put(Attribute.PermittedSubclasses, 1060 new PermittedSubclasses_attribute(attributeString, subclasses)); 1061 } 1062 addInnerClassesAttribute(header, constantPool, attributes); 1063 } 1064 1065 private void addInnerClassesAttribute(HeaderDescription header, 1066 List<CPInfo> constantPool, Map<String, Attribute> attributes) { 1067 if (header.innerClasses != null && !header.innerClasses.isEmpty()) { 1068 Info[] innerClasses = new Info[header.innerClasses.size()]; 1069 int i = 0; 1070 for (InnerClassInfo info : header.innerClasses) { 1071 innerClasses[i++] = 1072 new Info(info.innerClass == null ? 0 : addClass(constantPool, info.innerClass), 1073 info.outerClass == null ? 0 : addClass(constantPool, info.outerClass), 1074 info.innerClassName == null ? 0 : addString(constantPool, info.innerClassName), 1075 new AccessFlags(info.innerClassFlags)); 1076 } 1077 int attributeString = addString(constantPool, Attribute.InnerClasses); 1078 attributes.put(Attribute.InnerClasses, 1079 new InnerClasses_attribute(attributeString, innerClasses)); 1080 } 1081 } 1082 1083 private void addAttributes(MethodDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) { 1084 addGenericAttributes(desc, constantPool, attributes); 1085 if (desc.thrownTypes != null) { 1086 int[] exceptions = new int[desc.thrownTypes.size()]; 1087 int i = 0; 1088 for (String exc : desc.thrownTypes) { 1089 exceptions[i++] = addClass(constantPool, exc); 1090 } 1091 int attributeString = addString(constantPool, Attribute.Exceptions); 1092 attributes.put(Attribute.Exceptions, 1093 new Exceptions_attribute(attributeString, exceptions)); 1094 } 1095 if (desc.annotationDefaultValue != null) { 1096 int attributeString = addString(constantPool, Attribute.AnnotationDefault); 1097 element_value attributeValue = createAttributeValue(constantPool, 1098 desc.annotationDefaultValue); 1099 attributes.put(Attribute.AnnotationDefault, 1100 new AnnotationDefault_attribute(attributeString, attributeValue)); 1101 } 1102 if (desc.classParameterAnnotations != null && !desc.classParameterAnnotations.isEmpty()) { 1103 int attributeString = 1104 addString(constantPool, Attribute.RuntimeInvisibleParameterAnnotations); 1105 Annotation[][] annotations = 1106 createParameterAnnotations(constantPool, desc.classParameterAnnotations); 1107 attributes.put(Attribute.RuntimeInvisibleParameterAnnotations, 1108 new RuntimeInvisibleParameterAnnotations_attribute(attributeString, 1109 annotations)); 1110 } 1111 if (desc.runtimeParameterAnnotations != null && !desc.runtimeParameterAnnotations.isEmpty()) { 1112 int attributeString = 1113 addString(constantPool, Attribute.RuntimeVisibleParameterAnnotations); 1114 Annotation[][] annotations = 1115 createParameterAnnotations(constantPool, desc.runtimeParameterAnnotations); 1116 attributes.put(Attribute.RuntimeVisibleParameterAnnotations, 1117 new RuntimeVisibleParameterAnnotations_attribute(attributeString, 1118 annotations)); 1119 } 1120 if (desc.methodParameters != null && !desc.methodParameters.isEmpty()) { 1121 int attributeString = 1122 addString(constantPool, Attribute.MethodParameters); 1123 MethodParameters_attribute.Entry[] entries = 1124 desc.methodParameters 1125 .stream() 1126 .map(p -> new MethodParameters_attribute.Entry(addString(constantPool, p.name), 1127 p.flags)) 1128 .toArray(s -> new MethodParameters_attribute.Entry[s]); 1129 attributes.put(Attribute.MethodParameters, 1130 new MethodParameters_attribute(attributeString, entries)); 1131 } 1132 } 1133 1134 private void addAttributes(FieldDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) { 1135 addGenericAttributes(desc, constantPool, attributes); 1136 if (desc.constantValue != null) { 1137 Pair<Integer, Character> constantPoolEntry = 1138 addConstant(constantPool, desc.constantValue, false); 1139 Assert.checkNonNull(constantPoolEntry); 1140 int constantValueString = addString(constantPool, Attribute.ConstantValue); 1141 attributes.put(Attribute.ConstantValue, 1142 new ConstantValue_attribute(constantValueString, constantPoolEntry.fst)); 1143 } 1144 } 1145 1146 private void addGenericAttributes(FeatureDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) { 1147 if (desc.deprecated) { 1148 int attributeString = addString(constantPool, Attribute.Deprecated); 1149 attributes.put(Attribute.Deprecated, 1150 new Deprecated_attribute(attributeString)); 1151 } 1152 if (desc.signature != null) { 1153 int attributeString = addString(constantPool, Attribute.Signature); 1154 int signatureString = addString(constantPool, desc.signature); 1155 attributes.put(Attribute.Signature, 1156 new Signature_attribute(attributeString, signatureString)); 1157 } 1158 if (desc.classAnnotations != null && !desc.classAnnotations.isEmpty()) { 1159 int attributeString = addString(constantPool, Attribute.RuntimeInvisibleAnnotations); 1160 Annotation[] annotations = createAnnotations(constantPool, desc.classAnnotations); 1161 attributes.put(Attribute.RuntimeInvisibleAnnotations, 1162 new RuntimeInvisibleAnnotations_attribute(attributeString, annotations)); 1163 } 1164 if (desc.runtimeAnnotations != null && !desc.runtimeAnnotations.isEmpty()) { 1165 int attributeString = addString(constantPool, Attribute.RuntimeVisibleAnnotations); 1166 Annotation[] annotations = createAnnotations(constantPool, desc.runtimeAnnotations); 1167 attributes.put(Attribute.RuntimeVisibleAnnotations, 1168 new RuntimeVisibleAnnotations_attribute(attributeString, annotations)); 1169 } 1170 } 1171 1172 private Annotation[] createAnnotations(List<CPInfo> constantPool, List<AnnotationDescription> desc) { 1173 Annotation[] result = new Annotation[desc.size()]; 1174 int i = 0; 1175 1176 for (AnnotationDescription ad : desc) { 1177 result[i++] = createAnnotation(constantPool, ad); 1178 } 1179 1180 return result; 1181 } 1182 1183 private Annotation[][] createParameterAnnotations(List<CPInfo> constantPool, List<List<AnnotationDescription>> desc) { 1184 Annotation[][] result = new Annotation[desc.size()][]; 1185 int i = 0; 1186 1187 for (List<AnnotationDescription> paramAnnos : desc) { 1188 result[i++] = createAnnotations(constantPool, paramAnnos); 1189 } 1190 1191 return result; 1192 } 1193 1194 private Annotation createAnnotation(List<CPInfo> constantPool, AnnotationDescription desc) { 1195 String annotationType = desc.annotationType; 1196 Map<String, Object> values = desc.values; 1197 1198 if (PREVIEW_FEATURE_ANNOTATION_NEW.equals(annotationType)) { 1199 //the non-public PreviewFeature annotation will not be available in ct.sym, 1200 //replace with purely synthetic javac-internal annotation: 1201 annotationType = PREVIEW_FEATURE_ANNOTATION_INTERNAL; 1202 } 1203 1204 if (PREVIEW_FEATURE_ANNOTATION_OLD.equals(annotationType)) { 1205 //the non-public PreviewFeature annotation will not be available in ct.sym, 1206 //replace with purely synthetic javac-internal annotation: 1207 annotationType = PREVIEW_FEATURE_ANNOTATION_INTERNAL; 1208 values = new HashMap<>(values); 1209 Boolean essentialAPI = (Boolean) values.remove("essentialAPI"); 1210 values.put("reflective", essentialAPI != null && !essentialAPI); 1211 } 1212 1213 if (VALUE_BASED_ANNOTATION.equals(annotationType)) { 1214 //the non-public ValueBased annotation will not be available in ct.sym, 1215 //replace with purely synthetic javac-internal annotation: 1216 annotationType = VALUE_BASED_ANNOTATION_INTERNAL; 1217 } 1218 1219 return new Annotation(null, 1220 addString(constantPool, annotationType), 1221 createElementPairs(constantPool, values)); 1222 } 1223 1224 private element_value_pair[] createElementPairs(List<CPInfo> constantPool, Map<String, Object> annotationAttributes) { 1225 element_value_pair[] pairs = new element_value_pair[annotationAttributes.size()]; 1226 int i = 0; 1227 1228 for (Entry<String, Object> e : annotationAttributes.entrySet()) { 1229 int elementNameString = addString(constantPool, e.getKey()); 1230 element_value value = createAttributeValue(constantPool, e.getValue()); 1231 pairs[i++] = new element_value_pair(elementNameString, value); 1232 } 1233 1234 return pairs; 1235 } 1236 1237 private element_value createAttributeValue(List<CPInfo> constantPool, Object value) { 1238 Pair<Integer, Character> constantPoolEntry = addConstant(constantPool, value, true); 1239 if (constantPoolEntry != null) { 1240 return new Primitive_element_value(constantPoolEntry.fst, constantPoolEntry.snd); 1241 } else if (value instanceof EnumConstant) { 1242 EnumConstant ec = (EnumConstant) value; 1243 return new Enum_element_value(addString(constantPool, ec.type), 1244 addString(constantPool, ec.constant), 1245 'e'); 1246 } else if (value instanceof ClassConstant) { 1247 ClassConstant cc = (ClassConstant) value; 1248 return new Class_element_value(addString(constantPool, cc.type), 'c'); 1249 } else if (value instanceof AnnotationDescription) { 1250 Annotation annotation = createAnnotation(constantPool, ((AnnotationDescription) value)); 1251 return new Annotation_element_value(annotation, '@'); 1252 } else if (value instanceof Collection) { 1253 @SuppressWarnings("unchecked") 1254 Collection<Object> array = (Collection<Object>) value; 1255 element_value[] values = new element_value[array.size()]; 1256 int i = 0; 1257 1258 for (Object elem : array) { 1259 values[i++] = createAttributeValue(constantPool, elem); 1260 } 1261 1262 return new Array_element_value(values, '['); 1263 } 1264 throw new IllegalStateException(value.getClass().getName()); 1265 } 1266 1267 private static Pair<Integer, Character> addConstant(List<CPInfo> constantPool, Object value, boolean annotation) { 1268 if (value instanceof Boolean) { 1269 return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info(((Boolean) value) ? 1 : 0)), 'Z'); 1270 } else if (value instanceof Byte) { 1271 return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((byte) value)), 'B'); 1272 } else if (value instanceof Character) { 1273 return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((char) value)), 'C'); 1274 } else if (value instanceof Short) { 1275 return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((short) value)), 'S'); 1276 } else if (value instanceof Integer) { 1277 return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((int) value)), 'I'); 1278 } else if (value instanceof Long) { 1279 return Pair.of(addToCP(constantPool, new CONSTANT_Long_info((long) value)), 'J'); 1280 } else if (value instanceof Float) { 1281 return Pair.of(addToCP(constantPool, new CONSTANT_Float_info((float) value)), 'F'); 1282 } else if (value instanceof Double) { 1283 return Pair.of(addToCP(constantPool, new CONSTANT_Double_info((double) value)), 'D'); 1284 } else if (value instanceof String) { 1285 int stringIndex = addString(constantPool, (String) value); 1286 if (annotation) { 1287 return Pair.of(stringIndex, 's'); 1288 } else { 1289 return Pair.of(addToCP(constantPool, new CONSTANT_String_info(null, stringIndex)), 's'); 1290 } 1291 } 1292 1293 return null; 1294 } 1295 1296 private static int addString(List<CPInfo> constantPool, String string) { 1297 Assert.checkNonNull(string); 1298 1299 int i = 0; 1300 for (CPInfo info : constantPool) { 1301 if (info instanceof CONSTANT_Utf8_info) { 1302 if (((CONSTANT_Utf8_info) info).value.equals(string)) { 1303 return i; 1304 } 1305 } 1306 i++; 1307 } 1308 1309 return addToCP(constantPool, new CONSTANT_Utf8_info(string)); 1310 } 1311 1312 private static int addInt(List<CPInfo> constantPool, int value) { 1313 int i = 0; 1314 for (CPInfo info : constantPool) { 1315 if (info instanceof CONSTANT_Integer_info) { 1316 if (((CONSTANT_Integer_info) info).value == value) { 1317 return i; 1318 } 1319 } 1320 i++; 1321 } 1322 1323 return addToCP(constantPool, new CONSTANT_Integer_info(value)); 1324 } 1325 1326 private static int addModuleName(List<CPInfo> constantPool, String moduleName) { 1327 int nameIdx = addString(constantPool, moduleName); 1328 int i = 0; 1329 for (CPInfo info : constantPool) { 1330 if (info instanceof CONSTANT_Module_info) { 1331 if (((CONSTANT_Module_info) info).name_index == nameIdx) { 1332 return i; 1333 } 1334 } 1335 i++; 1336 } 1337 1338 return addToCP(constantPool, new CONSTANT_Module_info(null, nameIdx)); 1339 } 1340 1341 private static int addPackageName(List<CPInfo> constantPool, String packageName) { 1342 int nameIdx = addString(constantPool, packageName); 1343 int i = 0; 1344 for (CPInfo info : constantPool) { 1345 if (info instanceof CONSTANT_Package_info) { 1346 if (((CONSTANT_Package_info) info).name_index == nameIdx) { 1347 return i; 1348 } 1349 } 1350 i++; 1351 } 1352 1353 return addToCP(constantPool, new CONSTANT_Package_info(null, nameIdx)); 1354 } 1355 1356 private static int addClassName(List<CPInfo> constantPool, String className) { 1357 int nameIdx = addString(constantPool, className); 1358 int i = 0; 1359 for (CPInfo info : constantPool) { 1360 if (info instanceof CONSTANT_Class_info) { 1361 if (((CONSTANT_Class_info) info).name_index == nameIdx) { 1362 return i; 1363 } 1364 } 1365 i++; 1366 } 1367 1368 return addToCP(constantPool, new CONSTANT_Class_info(null, nameIdx)); 1369 } 1370 1371 private static int addToCP(List<CPInfo> constantPool, CPInfo entry) { 1372 int result = constantPool.size(); 1373 1374 constantPool.add(entry); 1375 1376 if (entry.size() > 1) { 1377 constantPool.add(null); 1378 } 1379 1380 return result; 1381 } 1382 1383 private static int addClass(List<CPInfo> constantPool, String className) { 1384 int classNameIndex = addString(constantPool, className); 1385 1386 int i = 0; 1387 for (CPInfo info : constantPool) { 1388 if (info instanceof CONSTANT_Class_info) { 1389 if (((CONSTANT_Class_info) info).name_index == classNameIndex) { 1390 return i; 1391 } 1392 } 1393 i++; 1394 } 1395 1396 return addToCP(constantPool, new CONSTANT_Class_info(null, classNameIndex)); 1397 } 1398 //</editor-fold> 1399 //</editor-fold> 1400 1401 //<editor-fold defaultstate="collapsed" desc="Create Symbol Description"> 1402 public void createBaseLine(List<VersionDescription> versions, 1403 ExcludeIncludeList excludesIncludes, 1404 Path descDest, 1405 String[] args) throws IOException { 1406 ClassList classes = new ClassList(); 1407 Map<String, ModuleDescription> modules = new HashMap<>(); 1408 1409 for (VersionDescription desc : versions) { 1410 Iterable<byte[]> classFileData = loadClassData(desc.classes); 1411 1412 loadVersionClasses(classes, modules, classFileData, excludesIncludes, desc.version, null); 1413 } 1414 1415 List<PlatformInput> platforms = 1416 versions.stream() 1417 .map(desc -> new PlatformInput(null, 1418 desc.version, 1419 desc.primaryBaseline, 1420 null)) 1421 .collect(Collectors.toList()); 1422 1423 dumpDescriptions(classes, modules, platforms, Set.of(), descDest.resolve("symbols"), args); 1424 } 1425 //where: 1426 public static String DO_NOT_MODIFY = 1427 "#\n" + 1428 "# Copyright (c) {YEAR}, Oracle and/or its affiliates. All rights reserved.\n" + 1429 "# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\n" + 1430 "#\n" + 1431 "# This code is free software; you can redistribute it and/or modify it\n" + 1432 "# under the terms of the GNU General Public License version 2 only, as\n" + 1433 "# published by the Free Software Foundation. Oracle designates this\n" + 1434 "# particular file as subject to the \"Classpath\" exception as provided\n" + 1435 "# by Oracle in the LICENSE file that accompanied this code.\n" + 1436 "#\n" + 1437 "# This code is distributed in the hope that it will be useful, but WITHOUT\n" + 1438 "# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n" + 1439 "# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License\n" + 1440 "# version 2 for more details (a copy is included in the LICENSE file that\n" + 1441 "# accompanied this code).\n" + 1442 "#\n" + 1443 "# You should have received a copy of the GNU General Public License version\n" + 1444 "# 2 along with this work; if not, write to the Free Software Foundation,\n" + 1445 "# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\n" + 1446 "#\n" + 1447 "# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA\n" + 1448 "# or visit www.oracle.com if you need additional information or have any\n" + 1449 "# questions.\n" + 1450 "#\n" + 1451 "# ##########################################################\n" + 1452 "# ### THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT. ###\n" + 1453 "# ##########################################################\n" + 1454 "#\n"; 1455 1456 private Iterable<byte[]> loadClassData(String path) { 1457 List<byte[]> classFileData = new ArrayList<>(); 1458 1459 try (BufferedReader descIn = 1460 Files.newBufferedReader(Paths.get(path))) { 1461 String line; 1462 while ((line = descIn.readLine()) != null) { 1463 ByteArrayOutputStream data = new ByteArrayOutputStream(); 1464 for (int i = 0; i < line.length(); i += 2) { 1465 String hex = line.substring(i, i + 2); 1466 data.write(Integer.parseInt(hex, 16)); 1467 } 1468 classFileData.add(data.toByteArray()); 1469 } 1470 } catch (IOException ex) { 1471 throw new IllegalStateException(ex); 1472 } 1473 1474 return classFileData; 1475 } 1476 1477 private void loadVersionClasses(ClassList classes, 1478 Map<String, ModuleDescription> modules, 1479 Iterable<byte[]> classData, 1480 ExcludeIncludeList excludesIncludes, 1481 String version, 1482 String baseline) { 1483 Map<String, ModuleDescription> currentVersionModules = 1484 new HashMap<>(); 1485 1486 for (byte[] classFileData : classData) { 1487 try (InputStream in = new ByteArrayInputStream(classFileData)) { 1488 inspectModuleInfoClassFile(in, 1489 currentVersionModules, version); 1490 } catch (IOException | ConstantPoolException ex) { 1491 throw new IllegalStateException(ex); 1492 } 1493 } 1494 1495 ExcludeIncludeList currentEIList = excludesIncludes; 1496 1497 if (!currentVersionModules.isEmpty()) { 1498 Set<String> privateIncludes = 1499 enhancedIncludesListBasedOnClassHeaders(classes, classData); 1500 Set<String> includes = new HashSet<>(); 1501 1502 for (ModuleDescription md : currentVersionModules.values()) { 1503 md.header.get(0).exports.stream() 1504 .filter(e -> !e.isQualified()) 1505 .map(e -> e.packageName + '/') 1506 .forEach(includes::add); 1507 } 1508 1509 currentEIList = new ExcludeIncludeList(includes, 1510 privateIncludes, 1511 Collections.emptySet()); 1512 } 1513 1514 ClassList currentVersionClasses = new ClassList(); 1515 1516 for (byte[] classFileData : classData) { 1517 try (InputStream in = new ByteArrayInputStream(classFileData)) { 1518 inspectClassFile(in, currentVersionClasses, 1519 currentEIList, version); 1520 } catch (IOException | ConstantPoolException ex) { 1521 throw new IllegalStateException(ex); 1522 } 1523 } 1524 1525 ModuleDescription unsupported = 1526 currentVersionModules.get("jdk.unsupported"); 1527 1528 if (unsupported != null) { 1529 for (ClassDescription cd : currentVersionClasses.classes) { 1530 if (unsupported.header 1531 .get(0) 1532 .exports 1533 .stream() 1534 .map(ed -> ed.packageName) 1535 .anyMatch(pack -> pack.equals(cd.packge().replace('.', '/')))) { 1536 ClassHeaderDescription ch = cd.header.get(0); 1537 if (ch.classAnnotations == null) { 1538 ch.classAnnotations = new ArrayList<>(); 1539 } 1540 AnnotationDescription ad; 1541 ad = new AnnotationDescription(PROPERITARY_ANNOTATION, 1542 Collections.emptyMap()); 1543 ch.classAnnotations.add(ad); 1544 } 1545 } 1546 } 1547 1548 Set<String> includedClasses = new HashSet<>(); 1549 boolean modified; 1550 1551 do { 1552 modified = false; 1553 1554 for (ClassDescription clazz : currentVersionClasses) { 1555 ClassHeaderDescription header = clazz.header.get(0); 1556 1557 if (includeEffectiveAccess(currentVersionClasses, clazz) && currentEIList.accepts(clazz.name, false)) { 1558 modified |= include(includedClasses, currentVersionClasses, clazz.name); 1559 } 1560 1561 if (includedClasses.contains(clazz.name)) { 1562 modified |= include(includedClasses, currentVersionClasses, header.extendsAttr); 1563 for (String i : header.implementsAttr) { 1564 modified |= include(includedClasses, currentVersionClasses, i); 1565 } 1566 1567 modified |= includeOutputType(Collections.singleton(header), 1568 h -> "", 1569 includedClasses, 1570 currentVersionClasses); 1571 modified |= includeOutputType(clazz.fields, 1572 f -> f.descriptor, 1573 includedClasses, 1574 currentVersionClasses); 1575 modified |= includeOutputType(clazz.methods, 1576 m -> m.descriptor, 1577 includedClasses, 1578 currentVersionClasses); 1579 } 1580 } 1581 } while (modified); 1582 1583 Set<String> allIncludedPackages = new HashSet<>(); 1584 1585 for (ClassDescription clazz : currentVersionClasses) { 1586 if (!includedClasses.contains(clazz.name)) { 1587 continue; 1588 } 1589 1590 ClassHeaderDescription header = clazz.header.get(0); 1591 1592 if (header.nestMembers != null) { 1593 Iterator<String> nestMemberIt = header.nestMembers.iterator(); 1594 1595 while(nestMemberIt.hasNext()) { 1596 String member = nestMemberIt.next(); 1597 if (!includedClasses.contains(member)) 1598 nestMemberIt.remove(); 1599 } 1600 } 1601 1602 if (header.innerClasses != null) { 1603 Iterator<InnerClassInfo> innerClassIt = header.innerClasses.iterator(); 1604 1605 while(innerClassIt.hasNext()) { 1606 InnerClassInfo ici = innerClassIt.next(); 1607 if (!includedClasses.contains(ici.innerClass)) 1608 innerClassIt.remove(); 1609 } 1610 } 1611 1612 ClassDescription existing = classes.find(clazz.name, true); 1613 1614 if (existing != null) { 1615 addClassHeader(existing, header, version, baseline); 1616 for (MethodDescription currentMethod : clazz.methods) { 1617 addMethod(existing, currentMethod, version, baseline); 1618 } 1619 for (FieldDescription currentField : clazz.fields) { 1620 addField(existing, currentField, version, baseline); 1621 } 1622 } else { 1623 classes.add(clazz); 1624 } 1625 1626 allIncludedPackages.add(clazz.packge().replace('.', '/')); 1627 } 1628 1629 for (ModuleDescription module : currentVersionModules.values()) { 1630 ModuleHeaderDescription header = module.header.get(0); 1631 1632 if (header.innerClasses != null) { 1633 Iterator<InnerClassInfo> innerClassIt = 1634 header.innerClasses.iterator(); 1635 1636 while(innerClassIt.hasNext()) { 1637 InnerClassInfo ici = innerClassIt.next(); 1638 if (!includedClasses.contains(ici.innerClass)) 1639 innerClassIt.remove(); 1640 } 1641 } 1642 1643 header.exports.removeIf(ed -> ed.isQualified() && 1644 !allIncludedPackages.contains(ed.packageName())); 1645 1646 if (header.extraModulePackages != null) { 1647 header.extraModulePackages.retainAll(allIncludedPackages); 1648 } 1649 1650 ModuleDescription existing = modules.get(module.name); 1651 1652 if (existing != null) { 1653 addModuleHeader(existing, header, version); 1654 } else { 1655 modules.put(module.name, module); 1656 } 1657 } 1658 } 1659 //where: 1660 private static final String PROPERITARY_ANNOTATION = 1661 "Lsun/Proprietary+Annotation;"; 1662 1663 private void dumpDescriptions(ClassList classes, 1664 Map<String, ModuleDescription> modules, 1665 List<PlatformInput> versions, 1666 Set<String> forceWriteVersions, 1667 Path ctDescriptionFile, 1668 String[] args) throws IOException { 1669 classes.sort(); 1670 1671 Map<String, String> package2Modules = new HashMap<>(); 1672 1673 versions.stream() 1674 .filter(v -> "9".compareTo(v.version) <= 0) 1675 .sorted((v1, v2) -> v1.version.compareTo(v2.version)) 1676 .forEach(v -> { 1677 for (ModuleDescription md : modules.values()) { 1678 md.header 1679 .stream() 1680 .filter(h -> h.versions.contains(v.version)) 1681 .flatMap(h -> { 1682 List<String> packages = new ArrayList<>(); 1683 h.exports.stream() 1684 .map(ExportsDescription::packageName) 1685 .forEach(packages::add); 1686 if (h.extraModulePackages != null) { 1687 packages.addAll(h.extraModulePackages); 1688 } 1689 return packages.stream(); 1690 }) 1691 .map(p -> p.replace('/', '.')) 1692 .forEach(p -> package2Modules.putIfAbsent(p, md.name)); 1693 } 1694 }); 1695 1696 package2Modules.put("java.awt.dnd.peer", "java.desktop"); 1697 package2Modules.put("java.awt.peer", "java.desktop"); 1698 package2Modules.put("jdk", "java.base"); 1699 1700 Map<String, List<ClassDescription>> module2Classes = new HashMap<>(); 1701 1702 for (ClassDescription clazz : classes) { 1703 String pack = clazz.packge(); 1704 String module = package2Modules.get(pack); 1705 1706 if (module == null) { 1707 module = "java.base"; 1708 1709 OUTER: while (!pack.isEmpty()) { 1710 for (Entry<String, String> p2M : package2Modules.entrySet()) { 1711 if (p2M.getKey().startsWith(pack)) { 1712 module = p2M.getValue(); 1713 break OUTER; 1714 } 1715 } 1716 int dot = pack.lastIndexOf('.'); 1717 if (dot == (-1)) 1718 break; 1719 pack = pack.substring(0, dot); 1720 } 1721 } 1722 module2Classes.computeIfAbsent(module, m -> new ArrayList<>()) 1723 .add(clazz); 1724 } 1725 1726 modules.keySet() 1727 .stream() 1728 .filter(m -> !module2Classes.containsKey(m)) 1729 .forEach(m -> module2Classes.put(m, Collections.emptyList())); 1730 1731 Files.createDirectories(ctDescriptionFile.getParent()); 1732 1733 int year = Calendar.getInstance(TimeZone.getTimeZone("UTF"), Locale.ROOT) 1734 .get(Calendar.YEAR); 1735 1736 try (Writer symbolsOut = Files.newBufferedWriter(ctDescriptionFile)) { 1737 Map<PlatformInput, List<String>> outputFiles = new LinkedHashMap<>(); 1738 1739 for (PlatformInput desc : versions) { 1740 List<String> files = desc.files; 1741 1742 if (files == null || forceWriteVersions.contains(desc.version)) { 1743 files = new ArrayList<>(); 1744 for (Entry<String, List<ClassDescription>> e : module2Classes.entrySet()) { 1745 StringWriter data = new StringWriter(); 1746 ModuleDescription module = modules.get(e.getKey()); 1747 1748 if (module != null) { //module == null should only be in tests. 1749 module.write(data, desc.basePlatform, desc.version); 1750 } 1751 1752 for (ClassDescription clazz : e.getValue()) { 1753 clazz.write(data, desc.basePlatform, desc.version); 1754 } 1755 1756 String fileName = e.getKey() + "-" + desc.version + ".sym.txt"; 1757 Path f = ctDescriptionFile.getParent().resolve(fileName); 1758 1759 String dataString = data.toString(); 1760 1761 if (!dataString.isEmpty()) { 1762 String existingYear = null; 1763 boolean hasChange = true; 1764 if (Files.isReadable(f)) { 1765 String oldContent = Files.readString(f, StandardCharsets.UTF_8); 1766 int yearPos = DO_NOT_MODIFY.indexOf("{YEAR}"); 1767 String headerPattern = 1768 Pattern.quote(DO_NOT_MODIFY.substring(0, yearPos)) + 1769 "([0-9]+)(, [0-9]+)?" + 1770 Pattern.quote(DO_NOT_MODIFY.substring(yearPos + "{YEAR}".length())); 1771 String pattern = headerPattern + 1772 Pattern.quote(dataString); 1773 Matcher m = Pattern.compile(pattern, Pattern.MULTILINE).matcher(oldContent); 1774 if (m.matches()) { 1775 hasChange = false; 1776 } else { 1777 m = Pattern.compile(headerPattern).matcher(oldContent); 1778 if (m.find()) { 1779 existingYear = m.group(1); 1780 } 1781 } 1782 } 1783 if (hasChange) { 1784 try (Writer out = Files.newBufferedWriter(f, StandardCharsets.UTF_8)) { 1785 String currentYear = String.valueOf(year); 1786 String yearSpec = (existingYear != null && !currentYear.equals(existingYear) ? existingYear + ", " : "") + currentYear; 1787 out.append(DO_NOT_MODIFY.replace("{YEAR}", yearSpec)); 1788 out.write(dataString); 1789 } 1790 } 1791 files.add(f.getFileName().toString()); 1792 } 1793 } 1794 } 1795 1796 outputFiles.put(desc, files); 1797 } 1798 symbolsOut.append(DO_NOT_MODIFY.replace("{YEAR}", "2015, " + year)); 1799 symbolsOut.append("#command used to generate this file:\n"); 1800 symbolsOut.append("#") 1801 .append(CreateSymbols.class.getName()) 1802 .append(" ") 1803 .append(Arrays.stream(args) 1804 .collect(Collectors.joining(" "))) 1805 .append("\n"); 1806 symbolsOut.append("#\n"); 1807 symbolsOut.append("generate platforms ") 1808 .append(versions.stream() 1809 .map(v -> v.version) 1810 .sorted() 1811 .collect(Collectors.joining(":"))) 1812 .append("\n"); 1813 for (Entry<PlatformInput, List<String>> versionFileEntry : outputFiles.entrySet()) { 1814 symbolsOut.append("platform version ") 1815 .append(versionFileEntry.getKey().version); 1816 if (versionFileEntry.getKey().basePlatform != null) { 1817 symbolsOut.append(" base ") 1818 .append(versionFileEntry.getKey().basePlatform); 1819 } 1820 symbolsOut.append(" files ") 1821 .append(versionFileEntry.getValue() 1822 .stream() 1823 .map(p -> p) 1824 .sorted() 1825 .collect(Collectors.joining(":"))) 1826 .append("\n"); 1827 } 1828 } 1829 } 1830 1831 private void incrementalUpdate(String ctDescriptionFile, 1832 String excludeFile, 1833 String platformVersion, 1834 Iterable<byte[]> classBytes, 1835 Function<LoadDescriptions, String> baseline, 1836 String[] args) throws IOException { 1837 String currentVersion = 1838 Integer.toString(Integer.parseInt(platformVersion), Character.MAX_RADIX); 1839 String version = currentVersion.toUpperCase(Locale.ROOT); 1840 Path ctDescriptionPath = Paths.get(ctDescriptionFile).toAbsolutePath(); 1841 LoadDescriptions data = load(null, ctDescriptionPath); 1842 1843 ClassList classes = data.classes; 1844 Map<String, ModuleDescription> modules = data.modules; 1845 List<PlatformInput> versions = data.versions; 1846 1847 ExcludeIncludeList excludeList = 1848 ExcludeIncludeList.create(excludeFile); 1849 1850 loadVersionClasses(classes, modules, classBytes, excludeList, "$", version); 1851 1852 removeVersion(data, version); 1853 1854 for (ModuleDescription md : data.modules.values()) { 1855 for (ModuleHeaderDescription header : md.header) { 1856 header.versions = header.versions.replace("$", version); 1857 } 1858 } 1859 1860 for (ClassDescription clazzDesc : data.classes) { 1861 for (ClassHeaderDescription header : clazzDesc.header) { 1862 header.versions = header.versions.replace("$", version); 1863 } 1864 for (MethodDescription method : clazzDesc.methods) { 1865 method.versions = method.versions.replace("$", version); 1866 } 1867 for (FieldDescription field : clazzDesc.fields) { 1868 field.versions = field.versions.replace("$", version); 1869 } 1870 } 1871 1872 if (versions.stream().noneMatch(inp -> version.equals(inp.version))) { 1873 versions.add(new PlatformInput(null, version, baseline.apply(data), null)); 1874 } 1875 1876 Set<String> writeVersions = new HashSet<>(); 1877 1878 writeVersions.add(version); 1879 1880 //re-write all platforms that have version as their basline: 1881 versions.stream() 1882 .filter(inp -> version.equals(inp.basePlatform)) 1883 .map(inp -> inp.version) 1884 .forEach(writeVersions::add); 1885 dumpDescriptions(classes, modules, versions, writeVersions, ctDescriptionPath, args); 1886 } 1887 1888 public void createIncrementalBaseLineFromDataFile(String ctDescriptionFile, 1889 String excludeFile, 1890 String version, 1891 String dataFile, 1892 String baseline, 1893 String[] args) throws IOException { 1894 incrementalUpdate(ctDescriptionFile, excludeFile, version, loadClassData(dataFile), x -> baseline, args); 1895 } 1896 1897 public void createIncrementalBaseLine(String ctDescriptionFile, 1898 String excludeFile, 1899 String[] args) throws IOException { 1900 String specVersion = System.getProperty("java.specification.version"); 1901 Iterable<byte[]> classBytes = dumpCurrentClasses(); 1902 Function<LoadDescriptions, String> baseline = data -> { 1903 if (data.versions.isEmpty()) { 1904 return null; 1905 } else { 1906 return data.versions.stream() 1907 .sorted((v1, v2) -> v2.version.compareTo(v1.version)) 1908 .findFirst() 1909 .get() 1910 .version; 1911 } 1912 }; 1913 incrementalUpdate(ctDescriptionFile, excludeFile, specVersion, classBytes, baseline, args); 1914 } 1915 1916 private List<byte[]> dumpCurrentClasses() throws IOException { 1917 JavacTool tool = JavacTool.create(); 1918 Context ctx = new Context(); 1919 String version = System.getProperty("java.specification.version"); 1920 JavacTask task = tool.getTask(null, null, null, 1921 List.of("--release", version), 1922 null, null, ctx); 1923 task.getElements().getTypeElement("java.lang.Object"); 1924 JavaFileManager fm = ctx.get(JavaFileManager.class); 1925 1926 List<byte[]> data = new ArrayList<>(); 1927 for (Location modLoc : LOCATIONS) { 1928 for (Set<JavaFileManager.Location> module : 1929 fm.listLocationsForModules(modLoc)) { 1930 for (JavaFileManager.Location loc : module) { 1931 Iterable<JavaFileObject> files = 1932 fm.list(loc, 1933 "", 1934 EnumSet.of(Kind.CLASS), 1935 true); 1936 1937 for (JavaFileObject jfo : files) { 1938 try (InputStream is = jfo.openInputStream(); 1939 InputStream in = 1940 new BufferedInputStream(is)) { 1941 ByteArrayOutputStream baos = 1942 new ByteArrayOutputStream(); 1943 1944 in.transferTo(baos); 1945 data.add(baos.toByteArray()); 1946 } 1947 } 1948 } 1949 } 1950 } 1951 1952 return data; 1953 } 1954 //where: 1955 private static final List<StandardLocation> LOCATIONS = 1956 List.of(StandardLocation.SYSTEM_MODULES, 1957 StandardLocation.UPGRADE_MODULE_PATH); 1958 1959 //<editor-fold defaultstate="collapsed" desc="Class Reading"> 1960 //non-final for tests: 1961 public static String PROFILE_ANNOTATION = "Ljdk/Profile+Annotation;"; 1962 public static boolean ALLOW_NON_EXISTING_CLASSES = false; 1963 1964 private void inspectClassFile(InputStream in, ClassList classes, ExcludeIncludeList excludesIncludes, String version) throws IOException, ConstantPoolException { 1965 ClassFile cf = ClassFile.read(in); 1966 1967 if (cf.access_flags.is(AccessFlags.ACC_MODULE)) { 1968 return ; 1969 } 1970 1971 if (!excludesIncludes.accepts(cf.getName(), true)) { 1972 return ; 1973 } 1974 1975 ClassHeaderDescription headerDesc = new ClassHeaderDescription(); 1976 1977 headerDesc.flags = cf.access_flags.flags; 1978 1979 if (cf.super_class != 0) { 1980 headerDesc.extendsAttr = cf.getSuperclassName(); 1981 } 1982 List<String> interfaces = new ArrayList<>(); 1983 for (int i = 0; i < cf.interfaces.length; i++) { 1984 interfaces.add(cf.getInterfaceName(i)); 1985 } 1986 headerDesc.implementsAttr = interfaces; 1987 for (Attribute attr : cf.attributes) { 1988 if (!readAttribute(cf, headerDesc, attr)) 1989 return ; 1990 } 1991 1992 ClassDescription clazzDesc = null; 1993 1994 for (ClassDescription cd : classes) { 1995 if (cd.name.equals(cf.getName())) { 1996 clazzDesc = cd; 1997 break; 1998 } 1999 } 2000 2001 if (clazzDesc == null) { 2002 clazzDesc = new ClassDescription(); 2003 clazzDesc.name = cf.getName(); 2004 classes.add(clazzDesc); 2005 } 2006 2007 addClassHeader(clazzDesc, headerDesc, version, null); 2008 2009 for (Method m : cf.methods) { 2010 if (!include(m.access_flags.flags)) 2011 continue; 2012 MethodDescription methDesc = new MethodDescription(); 2013 methDesc.flags = m.access_flags.flags; 2014 methDesc.name = m.getName(cf.constant_pool); 2015 methDesc.descriptor = m.descriptor.getValue(cf.constant_pool); 2016 for (Attribute attr : m.attributes) { 2017 readAttribute(cf, methDesc, attr); 2018 } 2019 addMethod(clazzDesc, methDesc, version, null); 2020 } 2021 for (Field f : cf.fields) { 2022 if (!include(f.access_flags.flags)) 2023 continue; 2024 FieldDescription fieldDesc = new FieldDescription(); 2025 fieldDesc.flags = f.access_flags.flags; 2026 fieldDesc.name = f.getName(cf.constant_pool); 2027 fieldDesc.descriptor = f.descriptor.getValue(cf.constant_pool); 2028 for (Attribute attr : f.attributes) { 2029 readAttribute(cf, fieldDesc, attr); 2030 } 2031 addField(clazzDesc, fieldDesc, version, null); 2032 } 2033 } 2034 2035 private void inspectModuleInfoClassFile(InputStream in, 2036 Map<String, ModuleDescription> modules, 2037 String version) throws IOException, ConstantPoolException { 2038 ClassFile cf = ClassFile.read(in); 2039 2040 if (!cf.access_flags.is(AccessFlags.ACC_MODULE)) { 2041 return ; 2042 } 2043 2044 ModuleHeaderDescription headerDesc = new ModuleHeaderDescription(); 2045 2046 headerDesc.versions = version; 2047 headerDesc.flags = cf.access_flags.flags; 2048 2049 for (Attribute attr : cf.attributes) { 2050 if (!readAttribute(cf, headerDesc, attr)) 2051 return ; 2052 } 2053 2054 String name = headerDesc.name; 2055 2056 ModuleDescription moduleDesc = modules.get(name); 2057 2058 if (moduleDesc == null) { 2059 moduleDesc = new ModuleDescription(); 2060 moduleDesc.name = name; 2061 modules.put(moduleDesc.name, moduleDesc); 2062 } 2063 2064 addModuleHeader(moduleDesc, headerDesc, version); 2065 } 2066 2067 private Set<String> enhancedIncludesListBasedOnClassHeaders(ClassList classes, 2068 Iterable<byte[]> classData) { 2069 Set<String> additionalIncludes = new HashSet<>(); 2070 2071 for (byte[] classFileData : classData) { 2072 try (InputStream in = new ByteArrayInputStream(classFileData)) { 2073 ClassFile cf = ClassFile.read(in); 2074 2075 if (cf.access_flags.is(AccessFlags.ACC_MODULE)) { 2076 continue; 2077 } 2078 2079 Set<String> additionalClasses = new HashSet<>(); 2080 2081 if (cf.super_class != 0) { 2082 additionalClasses.add(cf.getSuperclassName()); 2083 } 2084 for (int i = 0; i < cf.interfaces.length; i++) { 2085 additionalClasses.add(cf.getInterfaceName(i)); 2086 } 2087 2088 for (String additional : additionalClasses) { 2089 int dollar; 2090 2091 additionalIncludes.add(additional); 2092 2093 while ((dollar = additional.lastIndexOf('$')) != (-1)) { 2094 additional = additional.substring(0, dollar); 2095 additionalIncludes.add(additional); 2096 } 2097 } 2098 } catch (IOException | ConstantPoolException ex) { 2099 throw new IllegalStateException(ex); 2100 } 2101 } 2102 2103 return additionalIncludes; 2104 } 2105 2106 private void addModuleHeader(ModuleDescription moduleDesc, 2107 ModuleHeaderDescription headerDesc, 2108 String version) { 2109 //normalize: 2110 boolean existed = false; 2111 for (ModuleHeaderDescription existing : moduleDesc.header) { 2112 if (existing.equals(headerDesc)) { 2113 headerDesc = existing; 2114 existed = true; 2115 } 2116 } 2117 2118 headerDesc.versions += version; 2119 2120 if (!existed) { 2121 moduleDesc.header.add(headerDesc); 2122 } 2123 } 2124 2125 private boolean include(int accessFlags) { 2126 return (accessFlags & (AccessFlags.ACC_PUBLIC | AccessFlags.ACC_PROTECTED)) != 0; 2127 } 2128 2129 private void addClassHeader(ClassDescription clazzDesc, ClassHeaderDescription headerDesc, String version, String baseline) { 2130 //normalize: 2131 boolean existed = false; 2132 for (ClassHeaderDescription existing : clazzDesc.header) { 2133 if (existing.equals(headerDesc) && (!existed || (baseline != null && existing.versions.contains(baseline)))) { 2134 headerDesc = existing; 2135 existed = true; 2136 } 2137 } 2138 2139 if (!existed) { 2140 //check if the only difference between the 7 and 8 version is the Profile annotation 2141 //if so, copy it to the pre-8 version, so save space 2142 for (ClassHeaderDescription existing : clazzDesc.header) { 2143 List<AnnotationDescription> annots = existing.classAnnotations; 2144 2145 if (annots != null) { 2146 for (AnnotationDescription ad : annots) { 2147 if (PROFILE_ANNOTATION.equals(ad.annotationType)) { 2148 existing.classAnnotations = new ArrayList<>(annots); 2149 existing.classAnnotations.remove(ad); 2150 if (existing.equals(headerDesc)) { 2151 headerDesc = existing; 2152 existed = true; 2153 } 2154 existing.classAnnotations = annots; 2155 break; 2156 } 2157 } 2158 } 2159 } 2160 } 2161 2162 headerDesc.versions += version; 2163 2164 if (!existed) { 2165 clazzDesc.header.add(headerDesc); 2166 } 2167 } 2168 2169 private void addMethod(ClassDescription clazzDesc, MethodDescription methDesc, String version, String baseline) { 2170 //normalize: 2171 boolean methodExisted = false; 2172 for (MethodDescription existing : clazzDesc.methods) { 2173 if (existing.equals(methDesc) && (!methodExisted || (baseline != null && existing.versions.contains(baseline)))) { 2174 methodExisted = true; 2175 methDesc = existing; 2176 } 2177 } 2178 methDesc.versions += version; 2179 if (!methodExisted) { 2180 clazzDesc.methods.add(methDesc); 2181 } 2182 } 2183 2184 private void addField(ClassDescription clazzDesc, FieldDescription fieldDesc, String version, String baseline) { 2185 boolean fieldExisted = false; 2186 for (FieldDescription existing : clazzDesc.fields) { 2187 if (existing.equals(fieldDesc) && (!fieldExisted || (baseline != null && existing.versions.contains(baseline)))) { 2188 fieldExisted = true; 2189 fieldDesc = existing; 2190 } 2191 } 2192 fieldDesc.versions += version; 2193 if (!fieldExisted) { 2194 clazzDesc.fields.add(fieldDesc); 2195 } 2196 } 2197 2198 private boolean readAttribute(ClassFile cf, FeatureDescription feature, Attribute attr) throws ConstantPoolException { 2199 String attrName = attr.getName(cf.constant_pool); 2200 switch (attrName) { 2201 case Attribute.AnnotationDefault: 2202 assert feature instanceof MethodDescription; 2203 element_value defaultValue = ((AnnotationDefault_attribute) attr).default_value; 2204 ((MethodDescription) feature).annotationDefaultValue = 2205 convertElementValue(cf.constant_pool, defaultValue); 2206 break; 2207 case "Deprecated": 2208 feature.deprecated = true; 2209 break; 2210 case "Exceptions": 2211 assert feature instanceof MethodDescription; 2212 List<String> thrownTypes = new ArrayList<>(); 2213 Exceptions_attribute exceptionAttr = (Exceptions_attribute) attr; 2214 for (int i = 0; i < exceptionAttr.exception_index_table.length; i++) { 2215 thrownTypes.add(exceptionAttr.getException(i, cf.constant_pool)); 2216 } 2217 ((MethodDescription) feature).thrownTypes = thrownTypes; 2218 break; 2219 case Attribute.InnerClasses: 2220 if (feature instanceof ModuleHeaderDescription) 2221 break; //XXX 2222 assert feature instanceof ClassHeaderDescription; 2223 List<InnerClassInfo> innerClasses = new ArrayList<>(); 2224 InnerClasses_attribute innerClassesAttr = (InnerClasses_attribute) attr; 2225 for (int i = 0; i < innerClassesAttr.number_of_classes; i++) { 2226 CONSTANT_Class_info outerClassInfo = 2227 innerClassesAttr.classes[i].getOuterClassInfo(cf.constant_pool); 2228 InnerClassInfo info = new InnerClassInfo(); 2229 CONSTANT_Class_info innerClassInfo = 2230 innerClassesAttr.classes[i].getInnerClassInfo(cf.constant_pool); 2231 info.innerClass = innerClassInfo != null ? innerClassInfo.getName() : null; 2232 info.outerClass = outerClassInfo != null ? outerClassInfo.getName() : null; 2233 info.innerClassName = innerClassesAttr.classes[i].getInnerName(cf.constant_pool); 2234 info.innerClassFlags = innerClassesAttr.classes[i].inner_class_access_flags.flags; 2235 innerClasses.add(info); 2236 } 2237 ((ClassHeaderDescription) feature).innerClasses = innerClasses; 2238 break; 2239 case "RuntimeInvisibleAnnotations": 2240 feature.classAnnotations = annotations2Description(cf.constant_pool, attr); 2241 break; 2242 case "RuntimeVisibleAnnotations": 2243 feature.runtimeAnnotations = annotations2Description(cf.constant_pool, attr); 2244 break; 2245 case "Signature": 2246 feature.signature = ((Signature_attribute) attr).getSignature(cf.constant_pool); 2247 break; 2248 case "ConstantValue": 2249 assert feature instanceof FieldDescription; 2250 Object value = convertConstantValue(cf.constant_pool.get(((ConstantValue_attribute) attr).constantvalue_index), ((FieldDescription) feature).descriptor); 2251 if (((FieldDescription) feature).descriptor.equals("C")) { 2252 value = (char) (int) value; 2253 } 2254 ((FieldDescription) feature).constantValue = value; 2255 break; 2256 case "SourceFile": 2257 //ignore, not needed 2258 break; 2259 case "BootstrapMethods": 2260 //ignore, not needed 2261 break; 2262 case "Code": 2263 //ignore, not needed 2264 break; 2265 case "EnclosingMethod": 2266 return false; 2267 case "Synthetic": 2268 break; 2269 case "RuntimeVisibleParameterAnnotations": 2270 assert feature instanceof MethodDescription; 2271 ((MethodDescription) feature).runtimeParameterAnnotations = 2272 parameterAnnotations2Description(cf.constant_pool, attr); 2273 break; 2274 case "RuntimeInvisibleParameterAnnotations": 2275 assert feature instanceof MethodDescription; 2276 ((MethodDescription) feature).classParameterAnnotations = 2277 parameterAnnotations2Description(cf.constant_pool, attr); 2278 break; 2279 case Attribute.Module: { 2280 assert feature instanceof ModuleHeaderDescription; 2281 ModuleHeaderDescription header = 2282 (ModuleHeaderDescription) feature; 2283 Module_attribute mod = (Module_attribute) attr; 2284 2285 header.name = cf.constant_pool 2286 .getModuleInfo(mod.module_name) 2287 .getName(); 2288 2289 header.exports = 2290 Arrays.stream(mod.exports) 2291 .map(ee -> ExportsDescription.create(cf, ee)) 2292 .collect(Collectors.toList()); 2293 if (header.extraModulePackages != null) { 2294 header.exports.forEach(ed -> header.extraModulePackages.remove(ed.packageName())); 2295 } 2296 header.requires = 2297 Arrays.stream(mod.requires) 2298 .map(r -> RequiresDescription.create(cf, r)) 2299 .collect(Collectors.toList()); 2300 header.uses = Arrays.stream(mod.uses_index) 2301 .mapToObj(use -> getClassName(cf, use)) 2302 .collect(Collectors.toList()); 2303 header.provides = 2304 Arrays.stream(mod.provides) 2305 .map(p -> ProvidesDescription.create(cf, p)) 2306 .collect(Collectors.toList()); 2307 break; 2308 } 2309 case Attribute.ModuleTarget: { 2310 assert feature instanceof ModuleHeaderDescription; 2311 ModuleHeaderDescription header = 2312 (ModuleHeaderDescription) feature; 2313 ModuleTarget_attribute mod = (ModuleTarget_attribute) attr; 2314 if (mod.target_platform_index != 0) { 2315 header.moduleTarget = 2316 cf.constant_pool 2317 .getUTF8Value(mod.target_platform_index); 2318 } 2319 break; 2320 } 2321 case Attribute.ModuleResolution: { 2322 assert feature instanceof ModuleHeaderDescription; 2323 ModuleHeaderDescription header = 2324 (ModuleHeaderDescription) feature; 2325 ModuleResolution_attribute mod = 2326 (ModuleResolution_attribute) attr; 2327 header.moduleResolution = mod.resolution_flags; 2328 break; 2329 } 2330 case Attribute.ModulePackages: 2331 assert feature instanceof ModuleHeaderDescription; 2332 ModuleHeaderDescription header = 2333 (ModuleHeaderDescription) feature; 2334 ModulePackages_attribute mod = 2335 (ModulePackages_attribute) attr; 2336 header.extraModulePackages = new ArrayList<>(); 2337 for (int i = 0; i < mod.packages_count; i++) { 2338 String packageName = getPackageName(cf, mod.packages_index[i]); 2339 if (header.exports == null || 2340 header.exports.stream().noneMatch(ed -> ed.packageName().equals(packageName))) { 2341 header.extraModulePackages.add(packageName); 2342 } 2343 } 2344 break; 2345 case Attribute.ModuleHashes: 2346 break; 2347 case Attribute.NestHost: { 2348 assert feature instanceof ClassHeaderDescription; 2349 NestHost_attribute nestHost = (NestHost_attribute) attr; 2350 ClassHeaderDescription chd = (ClassHeaderDescription) feature; 2351 chd.nestHost = nestHost.getNestTop(cf.constant_pool).getName(); 2352 break; 2353 } 2354 case Attribute.NestMembers: { 2355 assert feature instanceof ClassHeaderDescription; 2356 NestMembers_attribute nestMembers = (NestMembers_attribute) attr; 2357 ClassHeaderDescription chd = (ClassHeaderDescription) feature; 2358 chd.nestMembers = Arrays.stream(nestMembers.members_indexes) 2359 .mapToObj(i -> getClassName(cf, i)) 2360 .collect(Collectors.toList()); 2361 break; 2362 } 2363 case Attribute.Record: { 2364 assert feature instanceof ClassHeaderDescription; 2365 Record_attribute record = (Record_attribute) attr; 2366 List<RecordComponentDescription> components = new ArrayList<>(); 2367 for (ComponentInfo info : record.component_info_arr) { 2368 RecordComponentDescription rcd = new RecordComponentDescription(); 2369 rcd.name = info.getName(cf.constant_pool); 2370 rcd.descriptor = info.descriptor.getValue(cf.constant_pool); 2371 for (Attribute nestedAttr : info.attributes) { 2372 readAttribute(cf, rcd, nestedAttr); 2373 } 2374 components.add(rcd); 2375 } 2376 ClassHeaderDescription chd = (ClassHeaderDescription) feature; 2377 chd.isRecord = true; 2378 chd.recordComponents = components; 2379 break; 2380 } 2381 case Attribute.MethodParameters: { 2382 assert feature instanceof MethodDescription; 2383 MethodParameters_attribute params = (MethodParameters_attribute) attr; 2384 MethodDescription method = (MethodDescription) feature; 2385 method.methodParameters = new ArrayList<>(); 2386 for (MethodParameters_attribute.Entry e : params.method_parameter_table) { 2387 String name = cf.constant_pool.getUTF8Value(e.name_index); 2388 MethodDescription.MethodParam param = 2389 new MethodDescription.MethodParam(e.flags, name); 2390 method.methodParameters.add(param); 2391 } 2392 break; 2393 } 2394 case Attribute.PermittedSubclasses: { 2395 assert feature instanceof ClassHeaderDescription; 2396 PermittedSubclasses_attribute permittedSubclasses = (PermittedSubclasses_attribute) attr; 2397 ClassHeaderDescription chd = (ClassHeaderDescription) feature; 2398 chd.permittedSubclasses = Arrays.stream(permittedSubclasses.subtypes) 2399 .mapToObj(i -> getClassName(cf, i)) 2400 .collect(Collectors.toList()); 2401 chd.isSealed = true; 2402 break; 2403 } 2404 case Attribute.ModuleMainClass: { 2405 ModuleMainClass_attribute moduleMainClass = (ModuleMainClass_attribute) attr; 2406 assert feature instanceof ModuleHeaderDescription; 2407 ModuleHeaderDescription mhd = (ModuleHeaderDescription) feature; 2408 mhd.moduleMainClass = moduleMainClass.getMainClassName(cf.constant_pool); 2409 break; 2410 } 2411 default: 2412 throw new IllegalStateException("Unhandled attribute: " + 2413 attrName); 2414 } 2415 2416 return true; 2417 } 2418 2419 private static String getClassName(ClassFile cf, int idx) { 2420 try { 2421 return cf.constant_pool.getClassInfo(idx).getName(); 2422 } catch (InvalidIndex ex) { 2423 throw new IllegalStateException(ex); 2424 } catch (ConstantPool.UnexpectedEntry ex) { 2425 throw new IllegalStateException(ex); 2426 } catch (ConstantPoolException ex) { 2427 throw new IllegalStateException(ex); 2428 } 2429 } 2430 2431 private static String getPackageName(ClassFile cf, int idx) { 2432 try { 2433 return cf.constant_pool.getPackageInfo(idx).getName(); 2434 } catch (InvalidIndex ex) { 2435 throw new IllegalStateException(ex); 2436 } catch (ConstantPool.UnexpectedEntry ex) { 2437 throw new IllegalStateException(ex); 2438 } catch (ConstantPoolException ex) { 2439 throw new IllegalStateException(ex); 2440 } 2441 } 2442 2443 private static String getModuleName(ClassFile cf, int idx) { 2444 try { 2445 return cf.constant_pool.getModuleInfo(idx).getName(); 2446 } catch (InvalidIndex ex) { 2447 throw new IllegalStateException(ex); 2448 } catch (ConstantPool.UnexpectedEntry ex) { 2449 throw new IllegalStateException(ex); 2450 } catch (ConstantPoolException ex) { 2451 throw new IllegalStateException(ex); 2452 } 2453 } 2454 2455 public static String INJECTED_VERSION = null; 2456 2457 private static String getVersion(ClassFile cf, int idx) { 2458 if (INJECTED_VERSION != null) { 2459 return INJECTED_VERSION; 2460 } 2461 if (idx == 0) 2462 return null; 2463 try { 2464 return ((CONSTANT_Utf8_info) cf.constant_pool.get(idx)).value; 2465 } catch (InvalidIndex ex) { 2466 throw new IllegalStateException(ex); 2467 } 2468 } 2469 2470 Object convertConstantValue(CPInfo info, String descriptor) throws ConstantPoolException { 2471 if (info instanceof CONSTANT_Integer_info) { 2472 if ("Z".equals(descriptor)) 2473 return ((CONSTANT_Integer_info) info).value == 1; 2474 else 2475 return ((CONSTANT_Integer_info) info).value; 2476 } else if (info instanceof CONSTANT_Long_info) { 2477 return ((CONSTANT_Long_info) info).value; 2478 } else if (info instanceof CONSTANT_Float_info) { 2479 return ((CONSTANT_Float_info) info).value; 2480 } else if (info instanceof CONSTANT_Double_info) { 2481 return ((CONSTANT_Double_info) info).value; 2482 } else if (info instanceof CONSTANT_String_info) { 2483 return ((CONSTANT_String_info) info).getString(); 2484 } 2485 throw new IllegalStateException(info.getClass().getName()); 2486 } 2487 2488 Object convertElementValue(ConstantPool cp, element_value val) throws InvalidIndex, ConstantPoolException { 2489 switch (val.tag) { 2490 case 'Z': 2491 return ((CONSTANT_Integer_info) cp.get(((Primitive_element_value) val).const_value_index)).value != 0; 2492 case 'B': 2493 return (byte) ((CONSTANT_Integer_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2494 case 'C': 2495 return (char) ((CONSTANT_Integer_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2496 case 'S': 2497 return (short) ((CONSTANT_Integer_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2498 case 'I': 2499 return ((CONSTANT_Integer_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2500 case 'J': 2501 return ((CONSTANT_Long_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2502 case 'F': 2503 return ((CONSTANT_Float_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2504 case 'D': 2505 return ((CONSTANT_Double_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2506 case 's': 2507 return ((CONSTANT_Utf8_info) cp.get(((Primitive_element_value) val).const_value_index)).value; 2508 2509 case 'e': 2510 return new EnumConstant(cp.getUTF8Value(((Enum_element_value) val).type_name_index), 2511 cp.getUTF8Value(((Enum_element_value) val).const_name_index)); 2512 case 'c': 2513 return new ClassConstant(cp.getUTF8Value(((Class_element_value) val).class_info_index)); 2514 2515 case '@': 2516 return annotation2Description(cp, ((Annotation_element_value) val).annotation_value); 2517 2518 case '[': 2519 List<Object> values = new ArrayList<>(); 2520 for (element_value elem : ((Array_element_value) val).values) { 2521 values.add(convertElementValue(cp, elem)); 2522 } 2523 return values; 2524 default: 2525 throw new IllegalStateException("Currently unhandled tag: " + val.tag); 2526 } 2527 } 2528 2529 private List<AnnotationDescription> annotations2Description(ConstantPool cp, Attribute attr) throws ConstantPoolException { 2530 RuntimeAnnotations_attribute annotationsAttr = (RuntimeAnnotations_attribute) attr; 2531 List<AnnotationDescription> descs = new ArrayList<>(); 2532 for (Annotation a : annotationsAttr.annotations) { 2533 descs.add(annotation2Description(cp, a)); 2534 } 2535 return descs; 2536 } 2537 2538 private List<List<AnnotationDescription>> parameterAnnotations2Description(ConstantPool cp, Attribute attr) throws ConstantPoolException { 2539 RuntimeParameterAnnotations_attribute annotationsAttr = 2540 (RuntimeParameterAnnotations_attribute) attr; 2541 List<List<AnnotationDescription>> descs = new ArrayList<>(); 2542 for (Annotation[] attrAnnos : annotationsAttr.parameter_annotations) { 2543 List<AnnotationDescription> paramDescs = new ArrayList<>(); 2544 for (Annotation ann : attrAnnos) { 2545 paramDescs.add(annotation2Description(cp, ann)); 2546 } 2547 descs.add(paramDescs); 2548 } 2549 return descs; 2550 } 2551 2552 private AnnotationDescription annotation2Description(ConstantPool cp, Annotation a) throws ConstantPoolException { 2553 String annotationType = cp.getUTF8Value(a.type_index); 2554 Map<String, Object> values = new HashMap<>(); 2555 2556 for (element_value_pair e : a.element_value_pairs) { 2557 values.put(cp.getUTF8Value(e.element_name_index), convertElementValue(cp, e.value)); 2558 } 2559 2560 return new AnnotationDescription(annotationType, values); 2561 } 2562 //</editor-fold> 2563 2564 protected boolean includeEffectiveAccess(ClassList classes, ClassDescription clazz) { 2565 if (!include(clazz.header.get(0).flags)) 2566 return false; 2567 for (ClassDescription outer : classes.enclosingClasses(clazz)) { 2568 if (!include(outer.header.get(0).flags)) 2569 return false; 2570 } 2571 return true; 2572 } 2573 2574 boolean include(Set<String> includedClasses, ClassList classes, String clazzName) { 2575 if (clazzName == null) 2576 return false; 2577 2578 ClassDescription desc = classes.find(clazzName, true); 2579 2580 if (desc == null) { 2581 return false; 2582 } 2583 2584 boolean modified = includedClasses.add(clazzName); 2585 2586 for (ClassDescription outer : classes.enclosingClasses(desc)) { 2587 modified |= includedClasses.add(outer.name); 2588 } 2589 2590 return modified; 2591 } 2592 2593 <T extends FeatureDescription> boolean includeOutputType(Iterable<T> features, 2594 Function<T, String> feature2Descriptor, 2595 Set<String> includedClasses, 2596 ClassList classes) { 2597 boolean modified = false; 2598 2599 for (T feature : features) { 2600 CharSequence sig = 2601 feature.signature != null ? feature.signature : feature2Descriptor.apply(feature); 2602 Matcher m = OUTPUT_TYPE_PATTERN.matcher(sig); 2603 while (m.find()) { 2604 modified |= include(includedClasses, classes, m.group(1)); 2605 } 2606 } 2607 2608 return modified; 2609 } 2610 2611 static final Pattern OUTPUT_TYPE_PATTERN = Pattern.compile("L([^;<]+)(;|<)"); 2612 2613 public static class VersionDescription { 2614 public final String classes; 2615 public final String version; 2616 public final String primaryBaseline; 2617 2618 public VersionDescription(String classes, String version, String primaryBaseline) { 2619 this.classes = classes; 2620 this.version = version; 2621 this.primaryBaseline = "<none>".equals(primaryBaseline) ? null : primaryBaseline; 2622 } 2623 2624 } 2625 2626 public static class ExcludeIncludeList { 2627 public final Set<String> includeList; 2628 public final Set<String> privateIncludeList; 2629 public final Set<String> excludeList; 2630 2631 protected ExcludeIncludeList(Set<String> includeList, Set<String> excludeList) { 2632 this(includeList, Set.of(), excludeList); 2633 } 2634 2635 protected ExcludeIncludeList(Set<String> includeList, Set<String> privateIncludeList, 2636 Set<String> excludeList) { 2637 this.includeList = includeList; 2638 this.privateIncludeList = privateIncludeList; 2639 this.excludeList = excludeList; 2640 } 2641 2642 public static ExcludeIncludeList create(String files) throws IOException { 2643 Set<String> includeList = new HashSet<>(); 2644 Set<String> excludeList = new HashSet<>(); 2645 for (String file : files.split(File.pathSeparator)) { 2646 try (Stream<String> lines = Files.lines(Paths.get(file))) { 2647 lines.map(l -> l.substring(0, l.indexOf('#') != (-1) ? l.indexOf('#') : l.length())) 2648 .filter(l -> !l.trim().isEmpty()) 2649 .forEach(l -> { 2650 Set<String> target = l.startsWith("+") ? includeList : excludeList; 2651 target.add(l.substring(1)); 2652 }); 2653 } 2654 } 2655 return new ExcludeIncludeList(includeList, excludeList); 2656 } 2657 2658 public boolean accepts(String className, boolean includePrivateClasses) { 2659 return (matches(includeList, className) || 2660 (includePrivateClasses && matches(privateIncludeList, className))) && 2661 !matches(excludeList, className); 2662 } 2663 2664 private static boolean matches(Set<String> list, String className) { 2665 if (list.contains(className)) 2666 return true; 2667 String pack = className.substring(0, className.lastIndexOf('/') + 1); 2668 return list.contains(pack); 2669 } 2670 } 2671 //</editor-fold> 2672 2673 //<editor-fold defaultstate="collapsed" desc="Class Data Structures"> 2674 static boolean checkChange(String versions, String version, 2675 String baselineVersion) { 2676 return versions.contains(version) ^ 2677 (baselineVersion != null && 2678 versions.contains(baselineVersion)); 2679 } 2680 2681 static abstract class FeatureDescription { 2682 int flagsNormalization = ~0; 2683 int flags; 2684 boolean deprecated; 2685 String signature; 2686 String versions = ""; 2687 List<AnnotationDescription> classAnnotations; 2688 List<AnnotationDescription> runtimeAnnotations; 2689 2690 protected void writeAttributes(Appendable output) throws IOException { 2691 if (flags != 0) 2692 output.append(" flags " + Integer.toHexString(flags)); 2693 if (deprecated) { 2694 output.append(" deprecated true"); 2695 } 2696 if (signature != null) { 2697 output.append(" signature " + quote(signature, false)); 2698 } 2699 if (classAnnotations != null && !classAnnotations.isEmpty()) { 2700 output.append(" classAnnotations "); 2701 for (AnnotationDescription a : classAnnotations) { 2702 output.append(quote(a.toString(), false)); 2703 } 2704 } 2705 if (runtimeAnnotations != null && !runtimeAnnotations.isEmpty()) { 2706 output.append(" runtimeAnnotations "); 2707 for (AnnotationDescription a : runtimeAnnotations) { 2708 output.append(quote(a.toString(), false)); 2709 } 2710 } 2711 } 2712 2713 protected boolean shouldIgnore(String baselineVersion, String version) { 2714 return (!versions.contains(version) && 2715 (baselineVersion == null || !versions.contains(baselineVersion))) || 2716 (baselineVersion != null && 2717 versions.contains(baselineVersion) && versions.contains(version)); 2718 } 2719 2720 public abstract void write(Appendable output, String baselineVersion, String version) throws IOException; 2721 2722 protected void readAttributes(LineBasedReader reader) { 2723 String inFlags = reader.attributes.get("flags"); 2724 if (inFlags != null && !inFlags.isEmpty()) { 2725 flags = Integer.parseInt(inFlags, 16); 2726 } 2727 String inDeprecated = reader.attributes.get("deprecated"); 2728 if ("true".equals(inDeprecated)) { 2729 deprecated = true; 2730 } 2731 signature = reader.attributes.get("signature"); 2732 String inClassAnnotations = reader.attributes.get("classAnnotations"); 2733 if (inClassAnnotations != null) { 2734 classAnnotations = parseAnnotations(inClassAnnotations, new int[1]); 2735 } 2736 String inRuntimeAnnotations = reader.attributes.get("runtimeAnnotations"); 2737 if (inRuntimeAnnotations != null) { 2738 runtimeAnnotations = parseAnnotations(inRuntimeAnnotations, new int[1]); 2739 } 2740 } 2741 2742 public abstract boolean read(LineBasedReader reader) throws IOException; 2743 2744 @Override 2745 public int hashCode() { 2746 int hash = 3; 2747 hash = 89 * hash + (this.flags & flagsNormalization); 2748 hash = 89 * hash + (this.deprecated ? 1 : 0); 2749 hash = 89 * hash + Objects.hashCode(this.signature); 2750 hash = 89 * hash + listHashCode(this.classAnnotations); 2751 hash = 89 * hash + listHashCode(this.runtimeAnnotations); 2752 return hash; 2753 } 2754 2755 @Override 2756 public boolean equals(Object obj) { 2757 if (obj == null) { 2758 return false; 2759 } 2760 if (getClass() != obj.getClass()) { 2761 return false; 2762 } 2763 final FeatureDescription other = (FeatureDescription) obj; 2764 if ((this.flags & flagsNormalization) != (other.flags & flagsNormalization)) { 2765 return false; 2766 } 2767 if (this.deprecated != other.deprecated) { 2768 return false; 2769 } 2770 if (!Objects.equals(this.signature, other.signature)) { 2771 return false; 2772 } 2773 if (!listEquals(this.classAnnotations, other.classAnnotations)) { 2774 return false; 2775 } 2776 if (!listEquals(this.runtimeAnnotations, other.runtimeAnnotations)) { 2777 return false; 2778 } 2779 return true; 2780 } 2781 2782 } 2783 2784 public static class ModuleDescription { 2785 String name; 2786 List<ModuleHeaderDescription> header = new ArrayList<>(); 2787 2788 public void write(Appendable output, String baselineVersion, 2789 String version) throws IOException { 2790 boolean inBaseline = false; 2791 boolean inVersion = false; 2792 for (ModuleHeaderDescription mhd : header) { 2793 if (baselineVersion != null && 2794 mhd.versions.contains(baselineVersion)) { 2795 inBaseline = true; 2796 } 2797 if (mhd.versions.contains(version)) { 2798 inVersion = true; 2799 } 2800 } 2801 if (!inVersion && !inBaseline) 2802 return ; 2803 if (!inVersion) { 2804 output.append("-module name " + name + "\n\n"); 2805 return; 2806 } 2807 boolean hasChange = hasChange(header, version, baselineVersion); 2808 if (!hasChange) 2809 return; 2810 2811 output.append("module name " + name + "\n"); 2812 for (ModuleHeaderDescription header : header) { 2813 header.write(output, baselineVersion, version); 2814 } 2815 output.append("\n"); 2816 } 2817 2818 boolean hasChange(List<? extends FeatureDescription> hasChange, 2819 String version, String baseline) { 2820 return hasChange.stream() 2821 .map(fd -> fd.versions) 2822 .anyMatch(versions -> checkChange(versions, 2823 version, 2824 baseline)); 2825 } 2826 2827 public void read(LineBasedReader reader, String baselineVersion, 2828 String version) throws IOException { 2829 if (!"module".equals(reader.lineKey)) 2830 return ; 2831 2832 name = reader.attributes.get("name"); 2833 2834 reader.moveNext(); 2835 2836 OUTER: while (reader.hasNext()) { 2837 switch (reader.lineKey) { 2838 case "header": 2839 removeVersion(header, h -> true, version); 2840 ModuleHeaderDescription mhd = 2841 new ModuleHeaderDescription(); 2842 mhd.read(reader); 2843 mhd.name = name; 2844 mhd.versions = version; 2845 header.add(mhd); 2846 break; 2847 case "class": 2848 case "-class": 2849 case "module": 2850 case "-module": 2851 break OUTER; 2852 default: 2853 throw new IllegalStateException(reader.lineKey); 2854 } 2855 } 2856 } 2857 } 2858 2859 static class ModuleHeaderDescription extends HeaderDescription { 2860 String name; 2861 List<ExportsDescription> exports = new ArrayList<>(); 2862 List<String> opens = new ArrayList<>(); 2863 List<String> extraModulePackages = new ArrayList<>(); 2864 List<RequiresDescription> requires = new ArrayList<>(); 2865 List<String> uses = new ArrayList<>(); 2866 List<ProvidesDescription> provides = new ArrayList<>(); 2867 Integer moduleResolution; 2868 String moduleTarget; 2869 String moduleMainClass; 2870 2871 @Override 2872 public int hashCode() { 2873 int hash = super.hashCode(); 2874 hash = 83 * hash + Objects.hashCode(this.name); 2875 hash = 83 * hash + Objects.hashCode(this.exports); 2876 hash = 83 * hash + Objects.hashCode(this.opens); 2877 hash = 83 * hash + Objects.hashCode(this.extraModulePackages); 2878 hash = 83 * hash + Objects.hashCode(this.requires); 2879 hash = 83 * hash + Objects.hashCode(this.uses); 2880 hash = 83 * hash + Objects.hashCode(this.provides); 2881 hash = 83 * hash + Objects.hashCode(this.moduleResolution); 2882 hash = 83 * hash + Objects.hashCode(this.moduleTarget); 2883 hash = 83 * hash + Objects.hashCode(this.moduleMainClass); 2884 return hash; 2885 } 2886 2887 @Override 2888 public boolean equals(Object obj) { 2889 if (this == obj) { 2890 return true; 2891 } 2892 if (!super.equals(obj)) { 2893 return false; 2894 } 2895 final ModuleHeaderDescription other = 2896 (ModuleHeaderDescription) obj; 2897 if (!Objects.equals(this.name, other.name)) { 2898 return false; 2899 } 2900 if (!listEquals(this.exports, other.exports)) { 2901 return false; 2902 } 2903 if (!listEquals(this.opens, other.opens)) { 2904 return false; 2905 } 2906 if (!listEquals(this.extraModulePackages, other.extraModulePackages)) { 2907 return false; 2908 } 2909 if (!listEquals(this.requires, other.requires)) { 2910 return false; 2911 } 2912 if (!listEquals(this.uses, other.uses)) { 2913 return false; 2914 } 2915 if (!listEquals(this.provides, other.provides)) { 2916 return false; 2917 } 2918 if (!Objects.equals(this.moduleTarget, other.moduleTarget)) { 2919 return false; 2920 } 2921 if (!Objects.equals(this.moduleResolution, 2922 other.moduleResolution)) { 2923 return false; 2924 } 2925 if (!Objects.equals(this.moduleMainClass, 2926 other.moduleMainClass)) { 2927 return false; 2928 } 2929 return true; 2930 } 2931 2932 @Override 2933 public void write(Appendable output, String baselineVersion, 2934 String version) throws IOException { 2935 if (!versions.contains(version) || 2936 (baselineVersion != null && versions.contains(baselineVersion) 2937 && versions.contains(version))) 2938 return ; 2939 output.append("header"); 2940 if (exports != null && !exports.isEmpty()) { 2941 List<String> exportsList = 2942 exports.stream() 2943 .map(exp -> exp.serialize()) 2944 .collect(Collectors.toList()); 2945 output.append(" exports " + serializeList(exportsList)); 2946 } 2947 if (opens != null && !opens.isEmpty()) 2948 output.append(" opens " + serializeList(opens)); 2949 if (extraModulePackages != null && !extraModulePackages.isEmpty()) 2950 output.append(" extraModulePackages " + serializeList(extraModulePackages)); 2951 if (requires != null && !requires.isEmpty()) { 2952 List<String> requiresList = 2953 requires.stream() 2954 .map(req -> req.serialize()) 2955 .collect(Collectors.toList()); 2956 output.append(" requires " + serializeList(requiresList)); 2957 } 2958 if (uses != null && !uses.isEmpty()) 2959 output.append(" uses " + serializeList(uses)); 2960 if (provides != null && !provides.isEmpty()) { 2961 List<String> providesList = 2962 provides.stream() 2963 .map(p -> p.serialize()) 2964 .collect(Collectors.toList()); 2965 output.append(" provides " + serializeList(providesList)); 2966 } 2967 if (moduleTarget != null) 2968 output.append(" target " + quote(moduleTarget, true)); 2969 if (moduleResolution != null) 2970 output.append(" resolution " + 2971 quote(Integer.toHexString(moduleResolution), 2972 true)); 2973 if (moduleMainClass != null) 2974 output.append(" moduleMainClass " + quote(moduleMainClass, true)); 2975 writeAttributes(output); 2976 output.append("\n"); 2977 writeInnerClasses(output, baselineVersion, version); 2978 } 2979 2980 private static Map<String, String> splitAttributes(String data) { 2981 String[] parts = data.split(" "); 2982 2983 Map<String, String> attributes = new HashMap<>(); 2984 2985 for (int i = 0; i < parts.length; i += 2) { 2986 attributes.put(parts[i], unquote(parts[i + 1])); 2987 } 2988 2989 return attributes; 2990 } 2991 2992 @Override 2993 public boolean read(LineBasedReader reader) throws IOException { 2994 if (!"header".equals(reader.lineKey)) 2995 return false; 2996 2997 List<String> exportsList = deserializeList(reader.attributes.get("exports"), false); 2998 exports = exportsList.stream() 2999 .map(ExportsDescription::deserialize) 3000 .collect(Collectors.toList()); 3001 opens = deserializeList(reader.attributes.get("opens")); 3002 extraModulePackages = deserializeList(reader.attributes.get("extraModulePackages")); 3003 List<String> requiresList = 3004 deserializeList(reader.attributes.get("requires")); 3005 requires = requiresList.stream() 3006 .map(RequiresDescription::deserialize) 3007 .collect(Collectors.toList()); 3008 uses = deserializeList(reader.attributes.get("uses")); 3009 List<String> providesList = 3010 deserializeList(reader.attributes.get("provides"), false); 3011 provides = providesList.stream() 3012 .map(ProvidesDescription::deserialize) 3013 .collect(Collectors.toList()); 3014 3015 moduleTarget = reader.attributes.get("target"); 3016 3017 if (reader.attributes.containsKey("resolution")) { 3018 final String resolutionFlags = 3019 reader.attributes.get("resolution"); 3020 moduleResolution = Integer.parseInt(resolutionFlags, 16); 3021 } 3022 3023 moduleMainClass = reader.attributes.get("moduleMainClass"); 3024 3025 readAttributes(reader); 3026 reader.moveNext(); 3027 readInnerClasses(reader); 3028 3029 return true; 3030 } 3031 3032 record ExportsDescription(String packageName, List<String> to) { 3033 public String serialize() { 3034 return packageName + 3035 (isQualified() ? "[" + quote(serializeList(to), true, true) + "]" 3036 : ""); 3037 } 3038 3039 public static ExportsDescription deserialize(String data) { 3040 int bracket = data.indexOf("["); 3041 String packageName; 3042 List<String> to; 3043 if (bracket != (-1)) { 3044 packageName = data.substring(0, bracket); 3045 to = deserializeList(unquote(data.substring(bracket + 1, data.length() - 1))); 3046 } else { 3047 packageName = data; 3048 to = null; 3049 } 3050 3051 return new ExportsDescription(packageName, to); 3052 } 3053 3054 public static ExportsDescription create(ClassFile cf, 3055 ExportsEntry ee) { 3056 String packageName = getPackageName(cf, ee.exports_index); 3057 List<String> to = null; 3058 if (ee.exports_to_count > 0) { 3059 to = new ArrayList<>(); 3060 for (int moduleIndex : ee.exports_to_index) { 3061 to.add(getModuleName(cf, moduleIndex)); 3062 } 3063 } 3064 return new ExportsDescription(packageName, to); 3065 } 3066 3067 public boolean isQualified() { 3068 return to != null && !to.isEmpty(); 3069 } 3070 } 3071 3072 static class RequiresDescription { 3073 final String moduleName; 3074 final int flags; 3075 final String version; 3076 3077 public RequiresDescription(String moduleName, int flags, 3078 String version) { 3079 this.moduleName = moduleName; 3080 this.flags = flags; 3081 this.version = version; 3082 } 3083 3084 public String serialize() { 3085 String versionKeyValue = version != null 3086 ? " version " + quote(version, true) 3087 : ""; 3088 return "name " + quote(moduleName, true) + 3089 " flags " + quote(Integer.toHexString(flags), true) + 3090 versionKeyValue; 3091 } 3092 3093 public static RequiresDescription deserialize(String data) { 3094 Map<String, String> attributes = splitAttributes(data); 3095 3096 String ver = attributes.containsKey("version") 3097 ? attributes.get("version") 3098 : null; 3099 int flags = Integer.parseInt(attributes.get("flags"), 16); 3100 return new RequiresDescription(attributes.get("name"), 3101 flags, 3102 ver); 3103 } 3104 3105 public static RequiresDescription create(ClassFile cf, 3106 RequiresEntry req) { 3107 String mod = getModuleName(cf, req.requires_index); 3108 String ver = getVersion(cf, req.requires_version_index); 3109 return new RequiresDescription(mod, 3110 req.requires_flags, 3111 ver); 3112 } 3113 3114 @Override 3115 public int hashCode() { 3116 int hash = 7; 3117 hash = 53 * hash + Objects.hashCode(this.moduleName); 3118 hash = 53 * hash + this.flags; 3119 hash = 53 * hash + Objects.hashCode(this.version); 3120 return hash; 3121 } 3122 3123 @Override 3124 public boolean equals(Object obj) { 3125 if (this == obj) { 3126 return true; 3127 } 3128 if (obj == null) { 3129 return false; 3130 } 3131 if (getClass() != obj.getClass()) { 3132 return false; 3133 } 3134 final RequiresDescription other = (RequiresDescription) obj; 3135 if (this.flags != other.flags) { 3136 return false; 3137 } 3138 if (!Objects.equals(this.moduleName, other.moduleName)) { 3139 return false; 3140 } 3141 if (!Objects.equals(this.version, other.version)) { 3142 return false; 3143 } 3144 return true; 3145 } 3146 3147 } 3148 3149 static class ProvidesDescription { 3150 final String interfaceName; 3151 final List<String> implNames; 3152 3153 public ProvidesDescription(String interfaceName, 3154 List<String> implNames) { 3155 this.interfaceName = interfaceName; 3156 this.implNames = implNames; 3157 } 3158 3159 public String serialize() { 3160 return "interface " + quote(interfaceName, true) + 3161 " impls " + quote(serializeList(implNames), true, true); 3162 } 3163 3164 public static ProvidesDescription deserialize(String data) { 3165 Map<String, String> attributes = splitAttributes(data); 3166 List<String> implsList = 3167 deserializeList(attributes.get("impls"), 3168 false); 3169 return new ProvidesDescription(attributes.get("interface"), 3170 implsList); 3171 } 3172 3173 public static ProvidesDescription create(ClassFile cf, 3174 ProvidesEntry prov) { 3175 String api = getClassName(cf, prov.provides_index); 3176 List<String> impls = 3177 Arrays.stream(prov.with_index) 3178 .mapToObj(wi -> getClassName(cf, wi)) 3179 .collect(Collectors.toList()); 3180 return new ProvidesDescription(api, impls); 3181 } 3182 3183 @Override 3184 public int hashCode() { 3185 int hash = 5; 3186 hash = 53 * hash + Objects.hashCode(this.interfaceName); 3187 hash = 53 * hash + Objects.hashCode(this.implNames); 3188 return hash; 3189 } 3190 3191 @Override 3192 public boolean equals(Object obj) { 3193 if (this == obj) { 3194 return true; 3195 } 3196 if (obj == null) { 3197 return false; 3198 } 3199 if (getClass() != obj.getClass()) { 3200 return false; 3201 } 3202 final ProvidesDescription other = (ProvidesDescription) obj; 3203 if (!Objects.equals(this.interfaceName, other.interfaceName)) { 3204 return false; 3205 } 3206 if (!Objects.equals(this.implNames, other.implNames)) { 3207 return false; 3208 } 3209 return true; 3210 } 3211 } 3212 } 3213 3214 public static class ClassDescription { 3215 String name; 3216 List<ClassHeaderDescription> header = new ArrayList<>(); 3217 List<MethodDescription> methods = new ArrayList<>(); 3218 List<FieldDescription> fields = new ArrayList<>(); 3219 3220 public void write(Appendable output, String baselineVersion, 3221 String version) throws IOException { 3222 boolean inBaseline = false; 3223 boolean inVersion = false; 3224 for (ClassHeaderDescription chd : header) { 3225 if (baselineVersion != null && 3226 chd.versions.contains(baselineVersion)) { 3227 inBaseline = true; 3228 } 3229 if (chd.versions.contains(version)) { 3230 inVersion = true; 3231 } 3232 } 3233 if (!inVersion && !inBaseline) 3234 return ; 3235 if (!inVersion) { 3236 output.append("-class name " + name + "\n\n"); 3237 return; 3238 } 3239 boolean hasChange = hasChange(header, version, baselineVersion) || 3240 hasChange(fields, version, baselineVersion) || 3241 hasChange(methods, version, baselineVersion); 3242 if (!hasChange) 3243 return; 3244 3245 output.append("class name " + name + "\n"); 3246 for (ClassHeaderDescription header : header) { 3247 header.write(output, baselineVersion, version); 3248 } 3249 for (FieldDescription field : fields) { 3250 if (!field.versions.contains(version)) { 3251 field.write(output, baselineVersion, version); 3252 } 3253 } 3254 for (MethodDescription method : methods) { 3255 if (!method.versions.contains(version)) { 3256 method.write(output, baselineVersion, version); 3257 } 3258 } 3259 for (FieldDescription field : fields) { 3260 if (field.versions.contains(version)) { 3261 field.write(output, baselineVersion, version); 3262 } 3263 } 3264 for (MethodDescription method : methods) { 3265 if (method.versions.contains(version)) { 3266 method.write(output, baselineVersion, version); 3267 } 3268 } 3269 output.append("\n"); 3270 } 3271 3272 boolean hasChange(List<? extends FeatureDescription> hasChange, 3273 String version, 3274 String baseline) { 3275 return hasChange.stream() 3276 .map(fd -> fd.versions) 3277 .anyMatch(versions -> checkChange(versions, 3278 version, 3279 baseline)); 3280 } 3281 3282 public void read(LineBasedReader reader, String baselineVersion, 3283 String version) throws IOException { 3284 if (!"class".equals(reader.lineKey)) 3285 return ; 3286 3287 name = reader.attributes.get("name"); 3288 3289 reader.moveNext(); 3290 3291 OUTER: while (reader.hasNext()) { 3292 switch (reader.lineKey) { 3293 case "header": 3294 removeVersion(header, h -> true, version); 3295 ClassHeaderDescription chd = new ClassHeaderDescription(); 3296 chd.read(reader); 3297 chd.versions = version; 3298 header.add(chd); 3299 break; 3300 case "field": 3301 FieldDescription field = new FieldDescription(); 3302 field.read(reader); 3303 field.versions += version; 3304 fields.add(field); 3305 break; 3306 case "-field": { 3307 removeVersion(fields, 3308 f -> Objects.equals(f.name, reader.attributes.get("name")) && 3309 Objects.equals(f.descriptor, reader.attributes.get("descriptor")), 3310 version); 3311 reader.moveNext(); 3312 break; 3313 } 3314 case "method": 3315 MethodDescription method = new MethodDescription(); 3316 method.read(reader); 3317 method.versions += version; 3318 methods.add(method); 3319 break; 3320 case "-method": { 3321 removeVersion(methods, 3322 m -> Objects.equals(m.name, reader.attributes.get("name")) && 3323 Objects.equals(m.descriptor, reader.attributes.get("descriptor")), 3324 version); 3325 reader.moveNext(); 3326 break; 3327 } 3328 case "class": 3329 case "-class": 3330 case "module": 3331 case "-module": 3332 break OUTER; 3333 default: 3334 throw new IllegalStateException(reader.lineKey); 3335 } 3336 } 3337 } 3338 3339 public String packge() { 3340 String pack; 3341 int lastSlash = name.lastIndexOf('/'); 3342 if (lastSlash != (-1)) { 3343 pack = name.substring(0, lastSlash).replace('/', '.'); 3344 } else { 3345 pack = ""; 3346 } 3347 3348 return pack; 3349 } 3350 3351 @Override 3352 public String toString() { 3353 return name; 3354 } 3355 3356 } 3357 3358 static class ClassHeaderDescription extends HeaderDescription { 3359 String extendsAttr; 3360 List<String> implementsAttr; 3361 String nestHost; 3362 List<String> nestMembers; 3363 boolean isRecord; 3364 List<RecordComponentDescription> recordComponents; 3365 boolean isSealed; 3366 List<String> permittedSubclasses; 3367 3368 @Override 3369 public int hashCode() { 3370 int hash = super.hashCode(); 3371 hash = 17 * hash + Objects.hashCode(this.extendsAttr); 3372 hash = 17 * hash + Objects.hashCode(this.implementsAttr); 3373 hash = 17 * hash + Objects.hashCode(this.nestHost); 3374 hash = 17 * hash + Objects.hashCode(this.nestMembers); 3375 hash = 17 * hash + Objects.hashCode(this.isRecord); 3376 hash = 17 * hash + Objects.hashCode(this.recordComponents); 3377 hash = 17 * hash + Objects.hashCode(this.isSealed); 3378 hash = 17 * hash + Objects.hashCode(this.permittedSubclasses); 3379 return hash; 3380 } 3381 3382 @Override 3383 public boolean equals(Object obj) { 3384 if (obj == null) { 3385 return false; 3386 } 3387 if (!super.equals(obj)) { 3388 return false; 3389 } 3390 final ClassHeaderDescription other = (ClassHeaderDescription) obj; 3391 if (!Objects.equals(this.extendsAttr, other.extendsAttr)) { 3392 return false; 3393 } 3394 if (!Objects.equals(this.implementsAttr, other.implementsAttr)) { 3395 return false; 3396 } 3397 if (!Objects.equals(this.nestHost, other.nestHost)) { 3398 return false; 3399 } 3400 if (!listEquals(this.nestMembers, other.nestMembers)) { 3401 return false; 3402 } 3403 if (this.isRecord != other.isRecord) { 3404 return false; 3405 } 3406 if (!listEquals(this.recordComponents, other.recordComponents)) { 3407 return false; 3408 } 3409 if (this.isSealed != other.isSealed) { 3410 return false; 3411 } 3412 if (!listEquals(this.permittedSubclasses, other.permittedSubclasses)) { 3413 return false; 3414 } 3415 return true; 3416 } 3417 3418 @Override 3419 public void write(Appendable output, String baselineVersion, String version) throws IOException { 3420 if (!versions.contains(version) || 3421 (baselineVersion != null && versions.contains(baselineVersion) && versions.contains(version))) 3422 return ; 3423 output.append("header"); 3424 if (extendsAttr != null) 3425 output.append(" extends " + extendsAttr); 3426 if (implementsAttr != null && !implementsAttr.isEmpty()) 3427 output.append(" implements " + serializeList(implementsAttr)); 3428 if (nestHost != null) 3429 output.append(" nestHost " + nestHost); 3430 if (nestMembers != null && !nestMembers.isEmpty()) 3431 output.append(" nestMembers " + serializeList(nestMembers)); 3432 if (isRecord) { 3433 output.append(" record true"); 3434 } 3435 if (isSealed) { 3436 output.append(" sealed true"); 3437 } 3438 writeAttributes(output); 3439 output.append("\n"); 3440 writeRecordComponents(output, baselineVersion, version); 3441 writeInnerClasses(output, baselineVersion, version); 3442 } 3443 3444 @Override 3445 public boolean read(LineBasedReader reader) throws IOException { 3446 if (!"header".equals(reader.lineKey)) 3447 return false; 3448 3449 extendsAttr = reader.attributes.get("extends"); 3450 String elementsList = reader.attributes.get("implements"); 3451 implementsAttr = deserializeList(elementsList); 3452 3453 nestHost = reader.attributes.get("nestHost"); 3454 String nestMembersList = reader.attributes.get("nestMembers"); 3455 nestMembers = deserializeList(nestMembersList); 3456 isRecord = reader.attributes.containsKey("record"); 3457 3458 readAttributes(reader); 3459 reader.moveNext(); 3460 if (isRecord) { 3461 readRecordComponents(reader); 3462 } 3463 readInnerClasses(reader); 3464 3465 isSealed = reader.attributes.containsKey("permittedSubclasses"); 3466 if (isSealed) { 3467 String subclassesList = reader.attributes.get("permittedSubclasses"); 3468 permittedSubclasses = deserializeList(subclassesList); 3469 } 3470 return true; 3471 } 3472 3473 protected void writeRecordComponents(Appendable output, 3474 String baselineVersion, 3475 String version) throws IOException { 3476 if (recordComponents != null) { 3477 for (RecordComponentDescription rcd : recordComponents) { 3478 rcd.write(output, "", ""); 3479 } 3480 } 3481 } 3482 3483 protected void readRecordComponents(LineBasedReader reader) throws IOException { 3484 recordComponents = new ArrayList<>(); 3485 3486 while ("recordcomponent".equals(reader.lineKey)) { 3487 RecordComponentDescription rcd = new RecordComponentDescription(); 3488 rcd.read(reader); 3489 recordComponents.add(rcd); 3490 } 3491 } 3492 } 3493 3494 static abstract class HeaderDescription extends FeatureDescription { 3495 List<InnerClassInfo> innerClasses; 3496 3497 @Override 3498 public int hashCode() { 3499 int hash = super.hashCode(); 3500 hash = 19 * hash + Objects.hashCode(this.innerClasses); 3501 return hash; 3502 } 3503 3504 @Override 3505 public boolean equals(Object obj) { 3506 if (obj == null) { 3507 return false; 3508 } 3509 if (!super.equals(obj)) { 3510 return false; 3511 } 3512 final HeaderDescription other = (HeaderDescription) obj; 3513 if (!listEquals(this.innerClasses, other.innerClasses)) { 3514 return false; 3515 } 3516 return true; 3517 } 3518 3519 protected void writeInnerClasses(Appendable output, 3520 String baselineVersion, 3521 String version) throws IOException { 3522 if (innerClasses != null && !innerClasses.isEmpty()) { 3523 for (InnerClassInfo ici : innerClasses) { 3524 output.append("innerclass"); 3525 output.append(" innerClass " + ici.innerClass); 3526 output.append(" outerClass " + ici.outerClass); 3527 output.append(" innerClassName " + ici.innerClassName); 3528 output.append(" flags " + Integer.toHexString(ici.innerClassFlags)); 3529 output.append("\n"); 3530 } 3531 } 3532 } 3533 3534 protected void readInnerClasses(LineBasedReader reader) throws IOException { 3535 innerClasses = new ArrayList<>(); 3536 3537 while ("innerclass".equals(reader.lineKey)) { 3538 InnerClassInfo info = new InnerClassInfo(); 3539 3540 info.innerClass = reader.attributes.get("innerClass"); 3541 info.outerClass = reader.attributes.get("outerClass"); 3542 info.innerClassName = reader.attributes.get("innerClassName"); 3543 3544 String inFlags = reader.attributes.get("flags"); 3545 if (inFlags != null && !inFlags.isEmpty()) 3546 info.innerClassFlags = Integer.parseInt(inFlags, 16); 3547 3548 innerClasses.add(info); 3549 3550 reader.moveNext(); 3551 } 3552 } 3553 3554 } 3555 3556 static class MethodDescription extends FeatureDescription { 3557 static int METHODS_FLAGS_NORMALIZATION = ~0; 3558 String name; 3559 String descriptor; 3560 List<String> thrownTypes; 3561 Object annotationDefaultValue; 3562 List<List<AnnotationDescription>> classParameterAnnotations; 3563 List<List<AnnotationDescription>> runtimeParameterAnnotations; 3564 List<MethodParam> methodParameters; 3565 3566 public MethodDescription() { 3567 flagsNormalization = METHODS_FLAGS_NORMALIZATION; 3568 } 3569 3570 @Override 3571 public int hashCode() { 3572 int hash = super.hashCode(); 3573 hash = 59 * hash + Objects.hashCode(this.name); 3574 hash = 59 * hash + Objects.hashCode(this.descriptor); 3575 hash = 59 * hash + Objects.hashCode(this.thrownTypes); 3576 hash = 59 * hash + Objects.hashCode(this.annotationDefaultValue); 3577 return hash; 3578 } 3579 3580 @Override 3581 public boolean equals(Object obj) { 3582 if (obj == null) { 3583 return false; 3584 } 3585 if (!super.equals(obj)) { 3586 return false; 3587 } 3588 final MethodDescription other = (MethodDescription) obj; 3589 if (!Objects.equals(this.name, other.name)) { 3590 return false; 3591 } 3592 if (!Objects.equals(this.descriptor, other.descriptor)) { 3593 return false; 3594 } 3595 if (!Objects.equals(this.thrownTypes, other.thrownTypes)) { 3596 return false; 3597 } 3598 if (!Objects.equals(this.annotationDefaultValue, other.annotationDefaultValue)) { 3599 return false; 3600 } 3601 return true; 3602 } 3603 3604 @Override 3605 public void write(Appendable output, String baselineVersion, String version) throws IOException { 3606 if (shouldIgnore(baselineVersion, version)) 3607 return ; 3608 if (!versions.contains(version)) { 3609 output.append("-method"); 3610 output.append(" name " + quote(name, false)); 3611 output.append(" descriptor " + quote(descriptor, false)); 3612 output.append("\n"); 3613 return ; 3614 } 3615 output.append("method"); 3616 output.append(" name " + quote(name, false)); 3617 output.append(" descriptor " + quote(descriptor, false)); 3618 if (thrownTypes != null) 3619 output.append(" thrownTypes " + serializeList(thrownTypes)); 3620 if (annotationDefaultValue != null) 3621 output.append(" annotationDefaultValue " + quote(AnnotationDescription.dumpAnnotationValue(annotationDefaultValue), false)); 3622 writeAttributes(output); 3623 if (classParameterAnnotations != null && !classParameterAnnotations.isEmpty()) { 3624 output.append(" classParameterAnnotations "); 3625 for (List<AnnotationDescription> pa : classParameterAnnotations) { 3626 for (AnnotationDescription a : pa) { 3627 output.append(quote(a.toString(), false)); 3628 } 3629 output.append(";"); 3630 } 3631 } 3632 if (runtimeParameterAnnotations != null && !runtimeParameterAnnotations.isEmpty()) { 3633 output.append(" runtimeParameterAnnotations "); 3634 for (List<AnnotationDescription> pa : runtimeParameterAnnotations) { 3635 for (AnnotationDescription a : pa) { 3636 output.append(quote(a.toString(), false)); 3637 } 3638 output.append(";"); 3639 } 3640 } 3641 if (methodParameters != null && !methodParameters.isEmpty()) { 3642 Function<MethodParam, String> param2String = 3643 p -> Integer.toHexString(p.flags) + ":" + p.name; 3644 List<String> paramsAsStrings = 3645 methodParameters.stream() 3646 .map(param2String) 3647 .collect(Collectors.toList()); 3648 output.append(" methodParameters " + serializeList(paramsAsStrings)); 3649 } 3650 output.append("\n"); 3651 } 3652 3653 @Override 3654 public boolean read(LineBasedReader reader) throws IOException { 3655 if (!"method".equals(reader.lineKey)) 3656 return false; 3657 3658 name = reader.attributes.get("name"); 3659 descriptor = reader.attributes.get("descriptor"); 3660 3661 String thrownTypesValue = reader.attributes.get("thrownTypes"); 3662 3663 if (thrownTypesValue != null) { 3664 thrownTypes = deserializeList(thrownTypesValue); 3665 } 3666 3667 String inAnnotationDefaultValue = reader.attributes.get("annotationDefaultValue"); 3668 3669 if (inAnnotationDefaultValue != null) { 3670 annotationDefaultValue = parseAnnotationValue(inAnnotationDefaultValue, new int[1]); 3671 } 3672 3673 readAttributes(reader); 3674 3675 String inClassParamAnnotations = reader.attributes.get("classParameterAnnotations"); 3676 if (inClassParamAnnotations != null) { 3677 List<List<AnnotationDescription>> annos = new ArrayList<>(); 3678 int[] pointer = new int[1]; 3679 do { 3680 annos.add(parseAnnotations(inClassParamAnnotations, pointer)); 3681 assert pointer[0] == inClassParamAnnotations.length() || inClassParamAnnotations.charAt(pointer[0]) == ';'; 3682 } while (++pointer[0] < inClassParamAnnotations.length()); 3683 classParameterAnnotations = annos; 3684 } 3685 3686 String inRuntimeParamAnnotations = reader.attributes.get("runtimeParameterAnnotations"); 3687 if (inRuntimeParamAnnotations != null) { 3688 List<List<AnnotationDescription>> annos = new ArrayList<>(); 3689 int[] pointer = new int[1]; 3690 do { 3691 annos.add(parseAnnotations(inRuntimeParamAnnotations, pointer)); 3692 assert pointer[0] == inRuntimeParamAnnotations.length() || inRuntimeParamAnnotations.charAt(pointer[0]) == ';'; 3693 } while (++pointer[0] < inRuntimeParamAnnotations.length()); 3694 runtimeParameterAnnotations = annos; 3695 } 3696 3697 String inMethodParameters = reader.attributes.get("methodParameters"); 3698 if (inMethodParameters != null) { 3699 Function<String, MethodParam> string2Param = 3700 p -> { 3701 int sep = p.indexOf(':'); 3702 return new MethodParam(Integer.parseInt(p.substring(0, sep)), 3703 p.substring(sep + 1)); 3704 }; 3705 methodParameters = 3706 deserializeList(inMethodParameters).stream() 3707 .map(string2Param) 3708 .collect(Collectors.toList()); 3709 } 3710 3711 reader.moveNext(); 3712 3713 return true; 3714 } 3715 3716 public static class MethodParam { 3717 public final int flags; 3718 public final String name; 3719 3720 public MethodParam(int flags, String name) { 3721 this.flags = flags; 3722 this.name = name; 3723 } 3724 } 3725 } 3726 3727 static class FieldDescription extends FeatureDescription { 3728 String name; 3729 String descriptor; 3730 Object constantValue; 3731 String keyName = "field"; 3732 3733 @Override 3734 public int hashCode() { 3735 int hash = super.hashCode(); 3736 hash = 59 * hash + Objects.hashCode(this.name); 3737 hash = 59 * hash + Objects.hashCode(this.descriptor); 3738 hash = 59 * hash + Objects.hashCode(this.constantValue); 3739 return hash; 3740 } 3741 3742 @Override 3743 public boolean equals(Object obj) { 3744 if (obj == null) { 3745 return false; 3746 } 3747 if (!super.equals(obj)) { 3748 return false; 3749 } 3750 final FieldDescription other = (FieldDescription) obj; 3751 if (!Objects.equals(this.name, other.name)) { 3752 return false; 3753 } 3754 if (!Objects.equals(this.descriptor, other.descriptor)) { 3755 return false; 3756 } 3757 if (!Objects.equals(this.constantValue, other.constantValue)) { 3758 return false; 3759 } 3760 return true; 3761 } 3762 3763 @Override 3764 public void write(Appendable output, String baselineVersion, String version) throws IOException { 3765 if (shouldIgnore(baselineVersion, version)) 3766 return ; 3767 if (!versions.contains(version)) { 3768 output.append("-" + keyName); 3769 output.append(" name " + quote(name, false)); 3770 output.append(" descriptor " + quote(descriptor, false)); 3771 output.append("\n"); 3772 return ; 3773 } 3774 output.append(keyName); 3775 output.append(" name " + name); 3776 output.append(" descriptor " + descriptor); 3777 if (constantValue != null) { 3778 output.append(" constantValue " + quote(constantValue.toString(), false)); 3779 } 3780 writeAttributes(output); 3781 output.append("\n"); 3782 } 3783 3784 @Override 3785 public boolean read(LineBasedReader reader) throws IOException { 3786 if (!keyName.equals(reader.lineKey)) 3787 return false; 3788 3789 name = reader.attributes.get("name"); 3790 descriptor = reader.attributes.get("descriptor"); 3791 3792 String inConstantValue = reader.attributes.get("constantValue"); 3793 3794 if (inConstantValue != null) { 3795 switch (descriptor) { 3796 case "Z": constantValue = "true".equals(inConstantValue); break; 3797 case "B": constantValue = Integer.parseInt(inConstantValue); break; 3798 case "C": constantValue = inConstantValue.charAt(0); break; 3799 case "S": constantValue = Integer.parseInt(inConstantValue); break; 3800 case "I": constantValue = Integer.parseInt(inConstantValue); break; 3801 case "J": constantValue = Long.parseLong(inConstantValue); break; 3802 case "F": constantValue = Float.parseFloat(inConstantValue); break; 3803 case "D": constantValue = Double.parseDouble(inConstantValue); break; 3804 case "Ljava/lang/String;": constantValue = inConstantValue; break; 3805 default: 3806 throw new IllegalStateException("Unrecognized field type: " + descriptor); 3807 } 3808 } 3809 3810 readAttributes(reader); 3811 3812 reader.moveNext(); 3813 3814 return true; 3815 } 3816 3817 } 3818 3819 static final class RecordComponentDescription extends FieldDescription { 3820 3821 public RecordComponentDescription() { 3822 this.keyName = "recordcomponent"; 3823 } 3824 3825 @Override 3826 protected boolean shouldIgnore(String baselineVersion, String version) { 3827 return false; 3828 } 3829 3830 } 3831 3832 static final class AnnotationDescription { 3833 String annotationType; 3834 Map<String, Object> values; 3835 3836 public AnnotationDescription(String annotationType, Map<String, Object> values) { 3837 this.annotationType = annotationType; 3838 this.values = values; 3839 } 3840 3841 @Override 3842 public int hashCode() { 3843 int hash = 7; 3844 hash = 47 * hash + Objects.hashCode(this.annotationType); 3845 hash = 47 * hash + Objects.hashCode(this.values); 3846 return hash; 3847 } 3848 3849 @Override 3850 public boolean equals(Object obj) { 3851 if (obj == null) { 3852 return false; 3853 } 3854 if (getClass() != obj.getClass()) { 3855 return false; 3856 } 3857 final AnnotationDescription other = (AnnotationDescription) obj; 3858 if (!Objects.equals(this.annotationType, other.annotationType)) { 3859 return false; 3860 } 3861 if (!Objects.equals(this.values, other.values)) { 3862 return false; 3863 } 3864 return true; 3865 } 3866 3867 @Override 3868 public String toString() { 3869 StringBuilder result = new StringBuilder(); 3870 result.append("@" + annotationType); 3871 if (!values.isEmpty()) { 3872 result.append("("); 3873 boolean first = true; 3874 for (Entry<String, Object> e : values.entrySet()) { 3875 if (!first) { 3876 result.append(","); 3877 } 3878 first = false; 3879 result.append(e.getKey()); 3880 result.append("="); 3881 result.append(dumpAnnotationValue(e.getValue())); 3882 result.append(""); 3883 } 3884 result.append(")"); 3885 } 3886 return result.toString(); 3887 } 3888 3889 private static String dumpAnnotationValue(Object value) { 3890 if (value instanceof List) { 3891 StringBuilder result = new StringBuilder(); 3892 3893 result.append("{"); 3894 3895 for (Object element : ((List) value)) { 3896 result.append(dumpAnnotationValue(element)); 3897 } 3898 3899 result.append("}"); 3900 3901 return result.toString(); 3902 } 3903 3904 if (value instanceof String) { 3905 return "\"" + quote((String) value, true) + "\""; 3906 } else if (value instanceof Boolean) { 3907 return "Z" + value; 3908 } else if (value instanceof Byte) { 3909 return "B" + value; 3910 } if (value instanceof Character) { 3911 return "C" + value; 3912 } if (value instanceof Short) { 3913 return "S" + value; 3914 } if (value instanceof Integer) { 3915 return "I" + value; 3916 } if (value instanceof Long) { 3917 return "J" + value; 3918 } if (value instanceof Float) { 3919 return "F" + value; 3920 } if (value instanceof Double) { 3921 return "D" + value; 3922 } else { 3923 return value.toString(); 3924 } 3925 } 3926 } 3927 3928 static final class EnumConstant { 3929 String type; 3930 String constant; 3931 3932 public EnumConstant(String type, String constant) { 3933 this.type = type; 3934 this.constant = constant; 3935 } 3936 3937 @Override 3938 public String toString() { 3939 return "e" + type + constant + ";"; 3940 } 3941 3942 @Override 3943 public int hashCode() { 3944 int hash = 7; 3945 hash = 19 * hash + Objects.hashCode(this.type); 3946 hash = 19 * hash + Objects.hashCode(this.constant); 3947 return hash; 3948 } 3949 3950 @Override 3951 public boolean equals(Object obj) { 3952 if (obj == null) { 3953 return false; 3954 } 3955 if (getClass() != obj.getClass()) { 3956 return false; 3957 } 3958 final EnumConstant other = (EnumConstant) obj; 3959 if (!Objects.equals(this.type, other.type)) { 3960 return false; 3961 } 3962 if (!Objects.equals(this.constant, other.constant)) { 3963 return false; 3964 } 3965 return true; 3966 } 3967 3968 } 3969 3970 static final class ClassConstant { 3971 String type; 3972 3973 public ClassConstant(String type) { 3974 this.type = type; 3975 } 3976 3977 @Override 3978 public String toString() { 3979 return "c" + type; 3980 } 3981 3982 @Override 3983 public int hashCode() { 3984 int hash = 3; 3985 hash = 53 * hash + Objects.hashCode(this.type); 3986 return hash; 3987 } 3988 3989 @Override 3990 public boolean equals(Object obj) { 3991 if (obj == null) { 3992 return false; 3993 } 3994 if (getClass() != obj.getClass()) { 3995 return false; 3996 } 3997 final ClassConstant other = (ClassConstant) obj; 3998 if (!Objects.equals(this.type, other.type)) { 3999 return false; 4000 } 4001 return true; 4002 } 4003 4004 } 4005 4006 static final class InnerClassInfo { 4007 String innerClass; 4008 String outerClass; 4009 String innerClassName; 4010 int innerClassFlags; 4011 4012 @Override 4013 public int hashCode() { 4014 int hash = 3; 4015 hash = 11 * hash + Objects.hashCode(this.innerClass); 4016 hash = 11 * hash + Objects.hashCode(this.outerClass); 4017 hash = 11 * hash + Objects.hashCode(this.innerClassName); 4018 hash = 11 * hash + Objects.hashCode(this.innerClassFlags); 4019 return hash; 4020 } 4021 4022 @Override 4023 public boolean equals(Object obj) { 4024 if (obj == null) { 4025 return false; 4026 } 4027 if (getClass() != obj.getClass()) { 4028 return false; 4029 } 4030 final InnerClassInfo other = (InnerClassInfo) obj; 4031 if (!Objects.equals(this.innerClass, other.innerClass)) { 4032 return false; 4033 } 4034 if (!Objects.equals(this.outerClass, other.outerClass)) { 4035 return false; 4036 } 4037 if (!Objects.equals(this.innerClassName, other.innerClassName)) { 4038 return false; 4039 } 4040 if (!Objects.equals(this.innerClassFlags, other.innerClassFlags)) { 4041 return false; 4042 } 4043 return true; 4044 } 4045 4046 } 4047 4048 public static final class ClassList implements Iterable<ClassDescription> { 4049 private final List<ClassDescription> classes = new ArrayList<>(); 4050 private final Map<String, ClassDescription> name2Class = new HashMap<>(); 4051 private final Map<ClassDescription, ClassDescription> inner2Outter = new HashMap<>(); 4052 4053 @Override 4054 public Iterator<ClassDescription> iterator() { 4055 return classes.iterator(); 4056 } 4057 4058 public void add(ClassDescription desc) { 4059 classes.add(desc); 4060 name2Class.put(desc.name, desc); 4061 } 4062 4063 public ClassDescription find(String name) { 4064 return find(name, ALLOW_NON_EXISTING_CLASSES); 4065 } 4066 4067 public ClassDescription find(String name, boolean allowNull) { 4068 ClassDescription desc = name2Class.get(name); 4069 4070 if (desc != null || allowNull) 4071 return desc; 4072 4073 throw new IllegalStateException("Cannot find: " + name); 4074 } 4075 4076 private static final ClassDescription NONE = new ClassDescription(); 4077 4078 public ClassDescription enclosingClass(ClassDescription clazz) { 4079 if (clazz == null) 4080 return null; 4081 ClassDescription desc = inner2Outter.computeIfAbsent(clazz, c -> { 4082 ClassHeaderDescription header = clazz.header.get(0); 4083 4084 if (header.innerClasses != null) { 4085 for (InnerClassInfo ici : header.innerClasses) { 4086 if (ici.innerClass.equals(clazz.name)) { 4087 return find(ici.outerClass); 4088 } 4089 } 4090 } 4091 4092 return NONE; 4093 }); 4094 4095 return desc != NONE ? desc : null; 4096 } 4097 4098 public Iterable<ClassDescription> enclosingClasses(ClassDescription clazz) { 4099 List<ClassDescription> result = new ArrayList<>(); 4100 ClassDescription outer = enclosingClass(clazz); 4101 4102 while (outer != null) { 4103 result.add(outer); 4104 outer = enclosingClass(outer); 4105 } 4106 4107 return result; 4108 } 4109 4110 public void sort() { 4111 Collections.sort(classes, (cd1, cd2) -> cd1.name.compareTo(cd2.name)); 4112 } 4113 } 4114 4115 private static int listHashCode(Collection<?> c) { 4116 return c == null || c.isEmpty() ? 0 : c.hashCode(); 4117 } 4118 4119 private static boolean listEquals(Collection<?> c1, Collection<?> c2) { 4120 if (c1 == c2) return true; 4121 if (c1 == null && c2.isEmpty()) return true; 4122 if (c2 == null && c1.isEmpty()) return true; 4123 return Objects.equals(c1, c2); 4124 } 4125 4126 private static String serializeList(List<String> list) { 4127 StringBuilder result = new StringBuilder(); 4128 String sep = ""; 4129 4130 for (Object o : list) { 4131 result.append(sep); 4132 result.append(o); 4133 sep = ","; 4134 } 4135 4136 return quote(result.toString(), false); 4137 } 4138 4139 private static List<String> deserializeList(String serialized) { 4140 return deserializeList(serialized, true); 4141 } 4142 4143 private static List<String> deserializeList(String serialized, 4144 boolean unquote) { 4145 serialized = unquote ? unquote(serialized) : serialized; 4146 if (serialized == null) 4147 return new ArrayList<>(); 4148 return new ArrayList<>(List.of(serialized.split(","))); 4149 } 4150 4151 private static String quote(String value, boolean quoteQuotes) { 4152 return quote(value, quoteQuotes, false); 4153 } 4154 4155 private static String quote(String value, boolean quoteQuotes, 4156 boolean quoteCommas) { 4157 StringBuilder result = new StringBuilder(); 4158 4159 for (char c : value.toCharArray()) { 4160 if (c <= 32 || c >= 127 || c == '\\' || 4161 (quoteQuotes && c == '"') || (quoteCommas && c == ',')) { 4162 result.append("\\u" + String.format("%04X", (int) c) + ";"); 4163 } else { 4164 result.append(c); 4165 } 4166 } 4167 4168 return result.toString(); 4169 } 4170 4171 private static final Pattern unicodePattern = 4172 Pattern.compile("\\\\u([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])"); 4173 4174 private static String unquote(String value) { 4175 if (value == null) 4176 return null; 4177 4178 StringBuilder result = new StringBuilder(); 4179 Matcher m = unicodePattern.matcher(value); 4180 int lastStart = 0; 4181 4182 while (m.find(lastStart)) { 4183 result.append(value.substring(lastStart, m.start())); 4184 result.append((char) Integer.parseInt(m.group(1), 16)); 4185 lastStart = m.end() + 1; 4186 } 4187 4188 result.append(value.substring(lastStart, value.length())); 4189 4190 return result.toString(); 4191 } 4192 4193 private static String readDigits(String value, int[] valuePointer) { 4194 int start = valuePointer[0]; 4195 4196 if (value.charAt(valuePointer[0]) == '-') 4197 valuePointer[0]++; 4198 4199 while (valuePointer[0] < value.length() && Character.isDigit(value.charAt(valuePointer[0]))) 4200 valuePointer[0]++; 4201 4202 return value.substring(start, valuePointer[0]); 4203 } 4204 4205 private static String className(String value, int[] valuePointer) { 4206 int start = valuePointer[0]; 4207 while (value.charAt(valuePointer[0]++) != ';') 4208 ; 4209 return value.substring(start, valuePointer[0]); 4210 } 4211 4212 private static Object parseAnnotationValue(String value, int[] valuePointer) { 4213 switch (value.charAt(valuePointer[0]++)) { 4214 case 'Z': 4215 if ("true".equals(value.substring(valuePointer[0], valuePointer[0] + 4))) { 4216 valuePointer[0] += 4; 4217 return true; 4218 } else if ("false".equals(value.substring(valuePointer[0], valuePointer[0] + 5))) { 4219 valuePointer[0] += 5; 4220 return false; 4221 } else { 4222 throw new IllegalStateException("Unrecognized boolean structure: " + value); 4223 } 4224 case 'B': return Byte.parseByte(readDigits(value, valuePointer)); 4225 case 'C': return value.charAt(valuePointer[0]++); 4226 case 'S': return Short.parseShort(readDigits(value, valuePointer)); 4227 case 'I': return Integer.parseInt(readDigits(value, valuePointer)); 4228 case 'J': return Long.parseLong(readDigits(value, valuePointer)); 4229 case 'F': return Float.parseFloat(readDigits(value, valuePointer)); 4230 case 'D': return Double.parseDouble(readDigits(value, valuePointer)); 4231 case 'c': 4232 return new ClassConstant(className(value, valuePointer)); 4233 case 'e': 4234 return new EnumConstant(className(value, valuePointer), className(value, valuePointer).replaceFirst(";$", "")); 4235 case '{': 4236 List<Object> elements = new ArrayList<>(); //TODO: a good test for this would be highly desirable 4237 while (value.charAt(valuePointer[0]) != '}') { 4238 elements.add(parseAnnotationValue(value, valuePointer)); 4239 } 4240 valuePointer[0]++; 4241 return elements; 4242 case '"': 4243 int start = valuePointer[0]; 4244 while (value.charAt(valuePointer[0]) != '"') 4245 valuePointer[0]++; 4246 return unquote(value.substring(start, valuePointer[0]++)); 4247 case '@': 4248 return parseAnnotation(value, valuePointer); 4249 default: 4250 throw new IllegalStateException("Unrecognized signature type: " + value.charAt(valuePointer[0] - 1) + "; value=" + value); 4251 } 4252 } 4253 4254 public static List<AnnotationDescription> parseAnnotations(String encoded, int[] pointer) { 4255 ArrayList<AnnotationDescription> result = new ArrayList<>(); 4256 4257 while (pointer[0] < encoded.length() && encoded.charAt(pointer[0]) == '@') { 4258 pointer[0]++; 4259 result.add(parseAnnotation(encoded, pointer)); 4260 } 4261 4262 return result; 4263 } 4264 4265 private static AnnotationDescription parseAnnotation(String value, int[] valuePointer) { 4266 String className = className(value, valuePointer); 4267 Map<String, Object> attribute2Value = new HashMap<>(); 4268 4269 if (valuePointer[0] < value.length() && value.charAt(valuePointer[0]) == '(') { 4270 while (value.charAt(valuePointer[0]) != ')') { 4271 int nameStart = ++valuePointer[0]; 4272 4273 while (value.charAt(valuePointer[0]++) != '='); 4274 4275 String name = value.substring(nameStart, valuePointer[0] - 1); 4276 4277 attribute2Value.put(name, parseAnnotationValue(value, valuePointer)); 4278 } 4279 4280 valuePointer[0]++; 4281 } 4282 4283 return new AnnotationDescription(className, attribute2Value); 4284 } 4285 //</editor-fold> 4286 4287 /**Create sig files for ct.sym reading the classes description from the directory that contains 4288 * {@code ctDescriptionFile}, using the file as a recipe to create the sigfiles. 4289 */ 4290 @SuppressWarnings("unchecked") 4291 public void createJavadocData(String ctDescriptionFileExtra, String ctDescriptionFile, 4292 String targetDir, int startVersion) throws IOException { 4293 LoadDescriptions data = load(ctDescriptionFileExtra != null ? Paths.get(ctDescriptionFileExtra) 4294 : null, 4295 Paths.get(ctDescriptionFile)); 4296 4297 Path target = Paths.get(targetDir); 4298 4299 for (PlatformInput version : data.versions) { 4300 int versionNumber = Integer.parseInt(version.version, Character.MAX_RADIX); 4301 if (versionNumber < startVersion) { 4302 continue; 4303 } 4304 Path outputFile = target.resolve("element-list-" + versionNumber + ".txt"); 4305 Files.createDirectories(outputFile.getParent()); 4306 try (Writer w = Files.newBufferedWriter(outputFile, StandardCharsets.UTF_8)) { 4307 Set<ModuleDescription> modules = new TreeSet<>((m1, m2) -> m1.name.compareTo(m2.name)); 4308 modules.addAll(data.modules.values()); 4309 for (ModuleDescription module : modules) { 4310 if ("jdk.unsupported".equals(module.name)) { 4311 continue; 4312 } 4313 Optional<ModuleHeaderDescription> header = module.header.stream().filter(h -> h.versions.contains(version.version)).findAny(); 4314 if (header.isEmpty()) { 4315 continue; 4316 } 4317 w.write("module:" + module.name); 4318 w.write("\n"); 4319 for (ExportsDescription export : header.get().exports) { 4320 if (export.isQualified()) { 4321 continue; 4322 } 4323 w.write(export.packageName.replace('/', '.')); 4324 w.write("\n"); 4325 } 4326 } 4327 } 4328 } 4329 } 4330 4331 private static void help() { 4332 System.err.println("Help..."); 4333 } 4334 4335 public static void main(String... args) throws IOException { 4336 if (args.length < 1) { 4337 help(); 4338 return ; 4339 } 4340 4341 switch (args[0]) { 4342 case "build-description": { 4343 if (args.length < 3) { 4344 help(); 4345 return ; 4346 } 4347 4348 Path descDest = Paths.get(args[1]); 4349 List<VersionDescription> versions = new ArrayList<>(); 4350 4351 for (int i = 3; i + 2 < args.length; i += 3) { 4352 versions.add(new VersionDescription(args[i + 1], args[i], args[i + 2])); 4353 } 4354 4355 Files.walkFileTree(descDest, new FileVisitor<Path>() { 4356 @Override 4357 public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { 4358 return FileVisitResult.CONTINUE; 4359 } 4360 @Override 4361 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { 4362 Files.delete(file); 4363 return FileVisitResult.CONTINUE; 4364 } 4365 @Override 4366 public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException { 4367 return FileVisitResult.CONTINUE; 4368 } 4369 @Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { 4370 Files.delete(dir); 4371 return FileVisitResult.CONTINUE; 4372 } 4373 }); 4374 4375 ExcludeIncludeList excludeList = 4376 ExcludeIncludeList.create(args[2]); 4377 4378 new CreateSymbols().createBaseLine(versions, 4379 excludeList, 4380 descDest, 4381 args); 4382 break; 4383 } 4384 case "build-description-incremental-file": { 4385 if (args.length != 6 && args.length != 7) { 4386 help(); 4387 return ; 4388 } 4389 4390 if (args.length == 7) { 4391 if ("--normalize-method-flags".equals(args[6])) { 4392 MethodDescription.METHODS_FLAGS_NORMALIZATION = ~(0x100 | 0x20); 4393 } else { 4394 help(); 4395 return ; 4396 } 4397 } 4398 4399 new CreateSymbols().createIncrementalBaseLineFromDataFile(args[1], args[2], args[3], args[4], "<none>".equals(args[5]) ? null : args[5], args); 4400 break; 4401 } 4402 case "build-description-incremental": { 4403 if (args.length != 3) { 4404 help(); 4405 return ; 4406 } 4407 4408 new CreateSymbols().createIncrementalBaseLine(args[1], args[2], args); 4409 break; 4410 } 4411 case "build-ctsym": { 4412 String ctDescriptionFileExtra; 4413 String ctDescriptionFile; 4414 String ctSymLocation; 4415 String timestampSpec; 4416 String currentVersion; 4417 String systemModules; 4418 4419 if (args.length == 6) { 4420 ctDescriptionFileExtra = null; 4421 ctDescriptionFile = args[1]; 4422 ctSymLocation = args[2]; 4423 timestampSpec = args[3]; 4424 currentVersion = args[4]; 4425 systemModules = args[5]; 4426 } else if (args.length == 7) { 4427 ctDescriptionFileExtra = args[1]; 4428 ctDescriptionFile = args[2]; 4429 ctSymLocation = args[3]; 4430 timestampSpec = args[4]; 4431 currentVersion = args[5]; 4432 systemModules = args[6]; 4433 } else { 4434 help(); 4435 return ; 4436 } 4437 4438 long timestamp = Long.parseLong(timestampSpec); 4439 4440 //SOURCE_DATE_EPOCH is in seconds, convert to milliseconds: 4441 timestamp *= 1000; 4442 4443 new CreateSymbols().createSymbols(ctDescriptionFileExtra, 4444 ctDescriptionFile, 4445 ctSymLocation, 4446 timestamp, 4447 currentVersion, 4448 systemModules); 4449 break; 4450 } 4451 case "build-javadoc-data": { 4452 String ctDescriptionFileExtra; 4453 String ctDescriptionFile; 4454 String targetDir; 4455 int startVersion; 4456 4457 if (args.length == 4) { 4458 ctDescriptionFileExtra = null; 4459 ctDescriptionFile = args[1]; 4460 targetDir = args[2]; 4461 startVersion = Integer.parseInt(args[3]); 4462 } else if (args.length == 5) { 4463 ctDescriptionFileExtra = args[1]; 4464 ctDescriptionFile = args[2]; 4465 targetDir = args[3]; 4466 startVersion = Integer.parseInt(args[4]); 4467 } else { 4468 help(); 4469 return ; 4470 } 4471 4472 if (startVersion < 9) { 4473 System.err.println("The start version must be at least 9!"); 4474 return ; 4475 } 4476 4477 new CreateSymbols().createJavadocData(ctDescriptionFileExtra, 4478 ctDescriptionFile, 4479 targetDir, 4480 startVersion); 4481 break; 4482 } 4483 } 4484 } 4485 4486 }