1 /*

     2  * Copyright (c) 2006, 2015, 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 java.io.BufferedReader;

    29 import java.io.ByteArrayInputStream;

    30 import java.io.ByteArrayOutputStream;

    31 import java.io.File;

    32 import java.io.IOException;

    33 import java.io.InputStream;

    34 import java.io.OutputStream;

    35 import java.io.Writer;

    36 import java.nio.file.DirectoryStream;

    37 import java.nio.file.Files;

    38 import java.nio.file.FileVisitResult;

    39 import java.nio.file.FileVisitor;

    40 import java.nio.file.Path;

    41 import java.nio.file.Paths;

    42 import java.nio.file.attribute.BasicFileAttributes;

    43 import java.util.stream.Stream;

    44 import java.util.ArrayList;

    45 import java.util.Arrays;

    46 import java.util.Collection;

    47 import java.util.Collections;

    48 import java.util.HashMap;

    49 import java.util.HashSet;

    50 import java.util.Iterator;

    51 import java.util.LinkedHashMap;

    52 import java.util.List;

    53 import java.util.Map;

    54 import java.util.Map.Entry;

    55 import java.util.Objects;

    56 import java.util.Set;

    57 import java.util.function.Function;

    58 import java.util.function.Predicate;

    59 import java.util.regex.Matcher;

    60 import java.util.regex.Pattern;

    61 import java.util.stream.Collectors;

    62 

    63 import com.sun.tools.classfile.AccessFlags;

    64 import com.sun.tools.classfile.Annotation;

    65 import com.sun.tools.classfile.Annotation.Annotation_element_value;

    66 import com.sun.tools.classfile.Annotation.Array_element_value;

    67 import com.sun.tools.classfile.Annotation.Class_element_value;

    68 import com.sun.tools.classfile.Annotation.Enum_element_value;

    69 import com.sun.tools.classfile.Annotation.Primitive_element_value;

    70 import com.sun.tools.classfile.Annotation.element_value;

    71 import com.sun.tools.classfile.Annotation.element_value_pair;

    72 import com.sun.tools.classfile.AnnotationDefault_attribute;

    73 import com.sun.tools.classfile.Attribute;

    74 import com.sun.tools.classfile.Attributes;

    75 import com.sun.tools.classfile.ClassFile;

    76 import com.sun.tools.classfile.ClassWriter;

    77 import com.sun.tools.classfile.ConstantPool;

    78 import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;

    79 import com.sun.tools.classfile.ConstantPool.CONSTANT_Double_info;

    80 import com.sun.tools.classfile.ConstantPool.CONSTANT_Float_info;

    81 import com.sun.tools.classfile.ConstantPool.CONSTANT_Integer_info;

    82 import com.sun.tools.classfile.ConstantPool.CONSTANT_Long_info;

    83 import com.sun.tools.classfile.ConstantPool.CONSTANT_String_info;

    84 import com.sun.tools.classfile.ConstantPool.CONSTANT_Utf8_info;

    85 import com.sun.tools.classfile.ConstantPool.CPInfo;

    86 import com.sun.tools.classfile.ConstantPool.InvalidIndex;

    87 import com.sun.tools.classfile.ConstantPoolException;

    88 import com.sun.tools.classfile.ConstantValue_attribute;

    89 import com.sun.tools.classfile.Deprecated_attribute;

    90 import com.sun.tools.classfile.Descriptor;

    91 import com.sun.tools.classfile.Exceptions_attribute;

    92 import com.sun.tools.classfile.Field;

    93 import com.sun.tools.classfile.InnerClasses_attribute;

    94 import com.sun.tools.classfile.InnerClasses_attribute.Info;

    95 import com.sun.tools.classfile.Method;

    96 import com.sun.tools.classfile.RuntimeAnnotations_attribute;

    97 import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;

    98 import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;

    99 import com.sun.tools.classfile.RuntimeParameterAnnotations_attribute;

   100 import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;

   101 import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;

   102 import com.sun.tools.classfile.Signature_attribute;

   103 import com.sun.tools.javac.jvm.Target;

   104 import com.sun.tools.javac.util.Assert;

   105 import com.sun.tools.javac.util.Pair;

   106 

   107 /**

   108  * A tool for processing the .sym.txt files. It allows to:

   109  *  * convert the .sym.txt into class/sig files for ct.sym

   110  *  * in cooperation with the adjacent history Probe, construct .sym.txt files for previous platforms

   111  *

   112  * To convert the .sym.txt files to class/sig files from ct.sym, run:

   113  *     java build.tool.symbolgenerator.CreateSymbols build-ctsym [JOINED_VERSIONS|SEPARATE] <platform-description-file> <target-directory>

   114  *

   115  * The <platform-description-file> is a file of this format:

   116  *     generate platforms <platform-ids-to-generate separate with ':'>

   117  *     platform version <platform-id1> files <.sym.txt files containing history data for given platform, separate with ':'>

   118  *     platform version <platform-id2> base <base-platform-id> files <.sym.txt files containing history data for given platform, separate with ':'>

   119  *

   120  * The content of platform "<base-platform-id>" is also automatically added to the content of

   121  * platform "<platform-id2>", unless explicitly excluded in "<platform-id2>"'s .sym.txt files.

   122  *

   123  * To create the .sym.txt files, first run the history Probe for all the previous platforms:

   124  *     <jdk-N>/bin/java build.tools.symbolgenerator.Probe <classes-for-N>

   125  *

   126  * Where <classes-for-N> is a name of a file into which the classes from the bootclasspath of <jdk-N>

   127  * will be written.

   128  *

   129  * Then create the <platform-description-file> file and the .sym.txt files like this:

   130  *     java build.tools.symbolgenerator.CreateSymbols build-description <target-directory> <path-to-a-JDK-root> <include-list-file>

   131  *                                                    <platform-id1> <target-file-for-platform1> "<none>"

   132  *                                                    <platform-id2> <target-file-for-platform2> <diff-against-platform2>

   133  *                                                    <platform-id3> <target-file-for-platform3> <diff-against-platform3>

   134  *                                                    ...

   135  *

   136  * The <include-list-file> is a file that specifies classes that should be included/excluded.

   137  * Lines that start with '+' represent class or package that should be included, '-' class or package

   138  * that should be excluded. '/' should be used as package name delimiter, packages should end with '/'.

   139  * Several include list files may be specified, separated by File.pathSeparator.

   140  *

   141  * When <diff-against-platformN> is specified, the .sym.txt files for platform N will only contain

   142  * differences between platform N and the specified platform. The first platform (denoted F further)

   143  * that is specified should use literal value "<none>", to have all the APIs of the platform written to

   144  * the .sym.txt files. If there is an existing platform with full .sym.txt files in the repository,

   145  * that platform should be used as the first platform to avoid unnecessary changes to the .sym.txt

   146  * files. The <diff-against-platformN> for platform N should be determined as follows: if N < F, then

   147  * <diff-against-platformN> should be N + 1. If F < N, then <diff-against-platformN> should be N - 1.

   148  * If N is a custom/specialized sub-version of another platform N', then <diff-against-platformN> should be N'.

   149  *

   150  * To generate the .sym.txt files for OpenJDK 7 and 8:

   151  *     <jdk-7>/bin/java build.tools.symbolgenerator.Probe OpenJDK7.classes

   152  *     <jdk-8>/bin/java build.tools.symbolgenerator.Probe OpenJDK8.classes

   153  *     java build.tools.symbolgenerator.CreateSymbols build-description langtools/make/data/symbols $TOPDIR langtools/make/data/symbols/include.list

   154  *                                                    8 OpenJDK8.classes '<none>'

   155  *                                                    7 OpenJDK7.classes 8

   156  *

   157  * Note: the versions are expected to be a single character.

   158  */

   159 public class CreateSymbols {

   160 

   161     //<editor-fold defaultstate="collapsed" desc="ct.sym construction">

   162     /**Create sig files for ct.sym reading the classes description from the directory that contains

   163      * {@code ctDescriptionFile}, using the file as a recipe to create the sigfiles.

   164      */

   165     @SuppressWarnings("unchecked")

   166     public void createSymbols(String ctDescriptionFile, String ctSymLocation, CtSymKind ctSymKind) throws IOException {

   167         ClassList classes = load(Paths.get(ctDescriptionFile));

   168 

   169         splitHeaders(classes);

   170 

   171         for (ClassDescription classDescription : classes) {

   172             for (ClassHeaderDescription header : classDescription.header) {

   173                 switch (ctSymKind) {

   174                     case JOINED_VERSIONS:

   175                         Set<String> jointVersions = new HashSet<>();

   176                         jointVersions.add(header.versions);

   177                         limitJointVersion(jointVersions, classDescription.fields);

   178                         limitJointVersion(jointVersions, classDescription.methods);

   179                         writeClassesForVersions(ctSymLocation, classDescription, header, jointVersions);

   180                         break;

   181                     case SEPARATE:

   182                         Set<String> versions = new HashSet<>();

   183                         for (char v : header.versions.toCharArray()) {

   184                             versions.add("" + v);

   185                         }

   186                         writeClassesForVersions(ctSymLocation, classDescription, header, versions);

   187                         break;

   188                 }

   189             }

   190         }

   191     }

   192 

   193     public static String EXTENSION = ".sig";

   194 

   195     ClassList load(Path ctDescription) throws IOException {

   196         List<PlatformInput> platforms = new ArrayList<>();

   197         Set<String> generatePlatforms = null;

   198 

   199         try (LineBasedReader reader = new LineBasedReader(ctDescription)) {

   200             while (reader.hasNext()) {

   201                 switch (reader.lineKey) {

   202                     case "generate":

   203                         String[] platformsAttr = reader.attributes.get("platforms").split(":");

   204                         generatePlatforms = new HashSet<>(Arrays.asList(platformsAttr));

   205                         reader.moveNext();

   206                         break;

   207                     case "platform":

   208                         platforms.add(PlatformInput.load(reader));

   209                         reader.moveNext();

   210                         break;

   211                     default:

   212                         throw new IllegalStateException("Unknown key: " + reader.lineKey);

   213                 }

   214             }

   215         }

   216 

   217         Map<String, ClassDescription> classes = new LinkedHashMap<>();

   218 

   219         for (PlatformInput platform: platforms) {

   220             for (ClassDescription cd : classes.values()) {

   221                 addNewVersion(cd.header, platform.basePlatform, platform.version);

   222                 addNewVersion(cd.fields, platform.basePlatform, platform.version);

   223                 addNewVersion(cd.methods, platform.basePlatform, platform.version);

   224             }

   225             for (String input : platform.files) {

   226                 Path inputFile = ctDescription.getParent().resolve(input);

   227                 try (LineBasedReader reader = new LineBasedReader(inputFile)) {

   228                     while (reader.hasNext()) {

   229                         String nameAttr = reader.attributes.get("name");

   230                         ClassDescription cd =

   231                                 classes.computeIfAbsent(nameAttr, n -> new ClassDescription());

   232                         if ("-class".equals(reader.lineKey)) {

   233                             removeVersion(cd.header, h -> true, platform.version);

   234                             reader.moveNext();

   235                             continue;

   236                         }

   237                         cd.read(reader, platform.basePlatform, platform.version);

   238                     }

   239                 }

   240             }

   241         }

   242 

   243         ClassList result = new ClassList();

   244 

   245         for (ClassDescription desc : classes.values()) {

   246             for (Iterator<ClassHeaderDescription> chdIt = desc.header.iterator(); chdIt.hasNext();) {

   247                 ClassHeaderDescription chd = chdIt.next();

   248 

   249                 chd.versions = reduce(chd.versions, generatePlatforms);

   250                 if (chd.versions.isEmpty())

   251                     chdIt.remove();

   252             }

   253 

   254             if (desc.header.isEmpty()) {

   255                 continue;

   256             }

   257 

   258             for (Iterator<MethodDescription> methodIt = desc.methods.iterator(); methodIt.hasNext();) {

   259                 MethodDescription method = methodIt.next();

   260 

   261                 method.versions = reduce(method.versions, generatePlatforms);

   262                 if (method.versions.isEmpty())

   263                     methodIt.remove();

   264             }

   265 

   266             for (Iterator<FieldDescription> fieldIt = desc.fields.iterator(); fieldIt.hasNext();) {

   267                 FieldDescription field = fieldIt.next();

   268 

   269                 field.versions = reduce(field.versions, generatePlatforms);

   270                 if (field.versions.isEmpty())

   271                     fieldIt.remove();

   272             }

   273 

   274             result.add(desc);

   275         }

   276 

   277         return result;

   278     }

   279 

   280     static final class LineBasedReader implements AutoCloseable {

   281         private final BufferedReader input;

   282         public String lineKey;

   283         public Map<String, String> attributes = new HashMap<>();

   284 

   285         public LineBasedReader(Path input) throws IOException {

   286             this.input = Files.newBufferedReader(input);

   287             moveNext();

   288         }

   289 

   290         public void moveNext() throws IOException {

   291             String line = input.readLine();

   292 

   293             if (line == null) {

   294                 lineKey = null;

   295                 return ;

   296             }

   297 

   298             if (line.trim().isEmpty() || line.startsWith("#")) {

   299                 moveNext();

   300                 return ;

   301             }

   302 

   303             String[] parts = line.split(" ");

   304 

   305             lineKey = parts[0];

   306             attributes.clear();

   307 

   308             for (int i = 1; i < parts.length; i += 2) {

   309                 attributes.put(parts[i], unquote(parts[i + 1]));

   310             }

   311         }

   312 

   313         public boolean hasNext() {

   314             return lineKey != null;

   315         }

   316 

   317         @Override

   318         public void close() throws IOException {

   319             input.close();

   320         }

   321     }

   322 

   323     private static String reduce(String original, String other) {

   324         Set<String> otherSet = new HashSet<>();

   325 

   326         for (char v : other.toCharArray()) {

   327             otherSet.add("" + v);

   328         }

   329 

   330         return reduce(original, otherSet);

   331     }

   332 

   333     private static String reduce(String original, Set<String> generate) {

   334         StringBuilder sb = new StringBuilder();

   335 

   336         for (char v : original.toCharArray()) {

   337             if (generate.contains("" + v)) {

   338                 sb.append(v);

   339             }

   340         }

   341         return sb.toString();

   342     }

   343 

   344     private static class PlatformInput {

   345         public final String version;

   346         public final String basePlatform;

   347         public final List<String> files;

   348         public PlatformInput(String version, String basePlatform, List<String> files) {

   349             this.version = version;

   350             this.basePlatform = basePlatform;

   351             this.files = files;

   352         }

   353 

   354         public static PlatformInput load(LineBasedReader in) throws IOException {

   355             return new PlatformInput(in.attributes.get("version"),

   356                                      in.attributes.get("base"),

   357                                      Arrays.asList(in.attributes.get("files").split(":")));

   358         }

   359     }

   360 

   361     static void addNewVersion(Collection<? extends FeatureDescription> features,

   362                        String baselineVersion,

   363                        String version) {

   364         features.stream()

   365                 .filter(f -> f.versions.contains(baselineVersion))

   366                 .forEach(f -> f.versions += version);

   367     }

   368 

   369     static <T extends FeatureDescription> void removeVersion(Collection<T> features,

   370                                                              Predicate<T> shouldRemove,

   371                                                              String version) {

   372         for (T existing : features) {

   373             if (shouldRemove.test(existing) && existing.versions.endsWith(version)) {

   374                 existing.versions = existing.versions.replace(version, "");

   375                 return;

   376             }

   377         }

   378     }

   379 

   380     /**Changes to class header of an outer class (like adding a new type parameter) may affect

   381      * its innerclasses. So if the outer class's header is different for versions A and B, need to

   382      * split its innerclasses headers to also be different for versions A and B.

   383      */

   384     static void splitHeaders(ClassList classes) {

   385         Set<String> ctVersions = new HashSet<>();

   386 

   387         for (ClassDescription cd : classes) {

   388             for (ClassHeaderDescription header : cd.header) {

   389                 for (char c : header.versions.toCharArray()) {

   390                     ctVersions.add("" + c);

   391                 }

   392             }

   393         }

   394 

   395         classes.sort();

   396 

   397         for (ClassDescription cd : classes) {

   398             Map<String, String> outerSignatures2Version = new HashMap<>();

   399 

   400             for (String version : ctVersions) { //XXX

   401                 ClassDescription outer = cd;

   402                 String outerSignatures = "";

   403 

   404                 while ((outer = classes.enclosingClass(outer)) != null) {

   405                     for (ClassHeaderDescription outerHeader : outer.header) {

   406                         if (outerHeader.versions.contains(version)) {

   407                             outerSignatures += outerHeader.signature;

   408                         }

   409                     }

   410                 }

   411 

   412                 outerSignatures2Version.compute(outerSignatures,

   413                                                  (key, value) -> value != null ? value + version : version);

   414             }

   415 

   416             List<ClassHeaderDescription> newHeaders = new ArrayList<>();

   417 

   418             HEADER_LOOP: for (ClassHeaderDescription header : cd.header) {

   419                 for (String versions : outerSignatures2Version.values()) {

   420                     if (containsAll(versions, header.versions)) {

   421                         newHeaders.add(header);

   422                         continue HEADER_LOOP;

   423                     }

   424                     if (disjoint(versions, header.versions)) {

   425                         continue;

   426                     }

   427                     ClassHeaderDescription newHeader = new ClassHeaderDescription();

   428                     newHeader.classAnnotations = header.classAnnotations;

   429                     newHeader.deprecated = header.deprecated;

   430                     newHeader.extendsAttr = header.extendsAttr;

   431                     newHeader.flags = header.flags;

   432                     newHeader.implementsAttr = header.implementsAttr;

   433                     newHeader.innerClasses = header.innerClasses;

   434                     newHeader.runtimeAnnotations = header.runtimeAnnotations;

   435                     newHeader.signature = header.signature;

   436                     newHeader.versions = reduce(versions, header.versions);

   437 

   438                     newHeaders.add(newHeader);

   439                 }

   440             }

   441 

   442             cd.header = newHeaders;

   443         }

   444     }

   445 

   446     void limitJointVersion(Set<String> jointVersions, List<? extends FeatureDescription> features) {

   447         for (FeatureDescription feature : features) {

   448             for (String version : jointVersions) {

   449                 if (!containsAll(feature.versions, version) &&

   450                     !disjoint(feature.versions, version)) {

   451                     StringBuilder featurePart = new StringBuilder();

   452                     StringBuilder otherPart = new StringBuilder();

   453                     for (char v : version.toCharArray()) {

   454                         if (feature.versions.indexOf(v) != (-1)) {

   455                             featurePart.append(v);

   456                         } else {

   457                             otherPart.append(v);

   458                         }

   459                     }

   460                     jointVersions.remove(version);

   461                     if (featurePart.length() == 0 || otherPart.length() == 0) {

   462                         throw new AssertionError();

   463                     }

   464                     jointVersions.add(featurePart.toString());

   465                     jointVersions.add(otherPart.toString());

   466                     break;

   467                 }

   468             }

   469         }

   470     }

   471 

   472     private static boolean containsAll(String versions, String subVersions) {

   473         for (char c : subVersions.toCharArray()) {

   474             if (versions.indexOf(c) == (-1))

   475                 return false;

   476         }

   477         return true;

   478     }

   479 

   480     private static boolean disjoint(String version1, String version2) {

   481         for (char c : version2.toCharArray()) {

   482             if (version1.indexOf(c) != (-1))

   483                 return false;

   484         }

   485         return true;

   486     }

   487 

   488     void writeClassesForVersions(String ctSymLocation,

   489                                  ClassDescription classDescription,

   490                                  ClassHeaderDescription header,

   491                                  Iterable<String> versions) throws IOException {

   492         for (String ver : versions) {

   493             writeClass(ctSymLocation, classDescription, header, ver);

   494         }

   495     }

   496 

   497     public enum CtSymKind {

   498         JOINED_VERSIONS,

   499         SEPARATE;

   500     }

   501 

   502     //<editor-fold defaultstate="collapsed" desc="Class Writing">

   503     void writeClass(String ctSymLocation,

   504                     ClassDescription classDescription,

   505                     ClassHeaderDescription header,

   506                     String version) throws IOException {

   507         List<CPInfo> constantPool = new ArrayList<>();

   508         constantPool.add(null);

   509         List<Method> methods = new ArrayList<>();

   510         for (MethodDescription methDesc : classDescription.methods) {

   511             if (disjoint(methDesc.versions, version))

   512                 continue;

   513             Descriptor descriptor = new Descriptor(addString(constantPool, methDesc.descriptor));

   514             //TODO: LinkedHashMap to avoid param annotations vs. Signature problem in javac's ClassReader:

   515             Map<String, Attribute> attributesMap = new LinkedHashMap<>();

   516             addAttributes(methDesc, constantPool, attributesMap);

   517             Attributes attributes = new Attributes(attributesMap);

   518             AccessFlags flags = new AccessFlags(methDesc.flags);

   519             int nameString = addString(constantPool, methDesc.name);

   520             methods.add(new Method(flags, nameString, descriptor, attributes));

   521         }

   522         List<Field> fields = new ArrayList<>();

   523         for (FieldDescription fieldDesc : classDescription.fields) {

   524             if (disjoint(fieldDesc.versions, version))

   525                 continue;

   526             Descriptor descriptor = new Descriptor(addString(constantPool, fieldDesc.descriptor));

   527             Map<String, Attribute> attributesMap = new HashMap<>();

   528             addAttributes(fieldDesc, constantPool, attributesMap);

   529             Attributes attributes = new Attributes(attributesMap);

   530             AccessFlags flags = new AccessFlags(fieldDesc.flags);

   531             int nameString = addString(constantPool, fieldDesc.name);

   532             fields.add(new Field(flags, nameString, descriptor, attributes));

   533         }

   534         int currentClass = addClass(constantPool, classDescription.name);

   535         int superclass = header.extendsAttr != null ? addClass(constantPool, header.extendsAttr) : 0;

   536         int[] interfaces = new int[header.implementsAttr.size()];

   537         int i = 0;

   538         for (String intf : header.implementsAttr) {

   539             interfaces[i++] = addClass(constantPool, intf);

   540         }

   541         AccessFlags flags = new AccessFlags(header.flags);

   542         Map<String, Attribute> attributesMap = new HashMap<>();

   543         addAttributes(header, constantPool, attributesMap);

   544         Attributes attributes = new Attributes(attributesMap);

   545         ConstantPool cp = new ConstantPool(constantPool.toArray(new CPInfo[constantPool.size()]));

   546         ClassFile classFile = new ClassFile(0xCAFEBABE,

   547                 Target.DEFAULT.minorVersion,

   548                 Target.DEFAULT.majorVersion,

   549                 cp,

   550                 flags,

   551                 currentClass,

   552                 superclass,

   553                 interfaces,

   554                 fields.toArray(new Field[0]),

   555                 methods.toArray(new Method[0]),

   556                 attributes);

   557 

   558         Path outputClassFile = Paths.get(ctSymLocation, version, classDescription.name + EXTENSION);

   559 

   560         Files.createDirectories(outputClassFile.getParent());

   561 

   562         try (OutputStream out = Files.newOutputStream(outputClassFile)) {

   563             ClassWriter w = new ClassWriter();

   564 

   565             w.write(classFile, out);

   566         }

   567     }

   568 

   569     private void addAttributes(ClassHeaderDescription header, List<CPInfo> constantPool, Map<String, Attribute> attributes) {

   570         addGenericAttributes(header, constantPool, attributes);

   571         if (header.innerClasses != null && !header.innerClasses.isEmpty()) {

   572             Info[] innerClasses = new Info[header.innerClasses.size()];

   573             int i = 0;

   574             for (InnerClassInfo info : header.innerClasses) {

   575                 innerClasses[i++] =

   576                         new Info(info.innerClass == null ? 0 : addClass(constantPool, info.innerClass),

   577                                  info.outerClass == null ? 0 : addClass(constantPool, info.outerClass),

   578                                  info.innerClassName == null ? 0 : addString(constantPool, info.innerClassName),

   579                                  new AccessFlags(info.innerClassFlags));

   580             }

   581             int attributeString = addString(constantPool, Attribute.InnerClasses);

   582             attributes.put(Attribute.InnerClasses,

   583                            new InnerClasses_attribute(attributeString, innerClasses));

   584         }

   585     }

   586 

   587     private void addAttributes(MethodDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) {

   588         addGenericAttributes(desc, constantPool, attributes);

   589         if (desc.thrownTypes != null && !desc.thrownTypes.isEmpty()) {

   590             int[] exceptions = new int[desc.thrownTypes.size()];

   591             int i = 0;

   592             for (String exc : desc.thrownTypes) {

   593                 exceptions[i++] = addClass(constantPool, exc);

   594             }

   595             int attributeString = addString(constantPool, Attribute.Exceptions);

   596             attributes.put(Attribute.Exceptions,

   597                            new Exceptions_attribute(attributeString, exceptions));

   598         }

   599         if (desc.annotationDefaultValue != null) {

   600             int attributeString = addString(constantPool, Attribute.AnnotationDefault);

   601             element_value attributeValue = createAttributeValue(constantPool,

   602                                                                 desc.annotationDefaultValue);

   603             attributes.put(Attribute.AnnotationDefault,

   604                            new AnnotationDefault_attribute(attributeString, attributeValue));

   605         }

   606         if (desc.classParameterAnnotations != null && !desc.classParameterAnnotations.isEmpty()) {

   607             int attributeString =

   608                     addString(constantPool, Attribute.RuntimeInvisibleParameterAnnotations);

   609             Annotation[][] annotations =

   610                     createParameterAnnotations(constantPool, desc.classParameterAnnotations);

   611             attributes.put(Attribute.RuntimeInvisibleParameterAnnotations,

   612                            new RuntimeInvisibleParameterAnnotations_attribute(attributeString,

   613                                    annotations));

   614         }

   615         if (desc.runtimeParameterAnnotations != null && !desc.runtimeParameterAnnotations.isEmpty()) {

   616             int attributeString =

   617                     addString(constantPool, Attribute.RuntimeVisibleParameterAnnotations);

   618             Annotation[][] annotations =

   619                     createParameterAnnotations(constantPool, desc.runtimeParameterAnnotations);

   620             attributes.put(Attribute.RuntimeVisibleParameterAnnotations,

   621                            new RuntimeVisibleParameterAnnotations_attribute(attributeString,

   622                                    annotations));

   623         }

   624     }

   625 

   626     private void addAttributes(FieldDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) {

   627         addGenericAttributes(desc, constantPool, attributes);

   628         if (desc.constantValue != null) {

   629             Pair<Integer, Character> constantPoolEntry =

   630                     addConstant(constantPool, desc.constantValue, false);

   631             Assert.checkNonNull(constantPoolEntry);

   632             int constantValueString = addString(constantPool, Attribute.ConstantValue);

   633             attributes.put(Attribute.ConstantValue,

   634                            new ConstantValue_attribute(constantValueString, constantPoolEntry.fst));

   635         }

   636     }

   637 

   638     private void addGenericAttributes(FeatureDescription desc, List<CPInfo> constantPool, Map<String, Attribute> attributes) {

   639         if (desc.deprecated) {

   640             int attributeString = addString(constantPool, Attribute.Deprecated);

   641             attributes.put(Attribute.Deprecated,

   642                            new Deprecated_attribute(attributeString));

   643         }

   644         if (desc.signature != null) {

   645             int attributeString = addString(constantPool, Attribute.Signature);

   646             int signatureString = addString(constantPool, desc.signature);

   647             attributes.put(Attribute.Signature,

   648                            new Signature_attribute(attributeString, signatureString));

   649         }

   650         if (desc.classAnnotations != null && !desc.classAnnotations.isEmpty()) {

   651             int attributeString = addString(constantPool, Attribute.RuntimeInvisibleAnnotations);

   652             Annotation[] annotations = createAnnotations(constantPool, desc.classAnnotations);

   653             attributes.put(Attribute.RuntimeInvisibleAnnotations,

   654                            new RuntimeInvisibleAnnotations_attribute(attributeString, annotations));

   655         }

   656         if (desc.runtimeAnnotations != null && !desc.runtimeAnnotations.isEmpty()) {

   657             int attributeString = addString(constantPool, Attribute.RuntimeVisibleAnnotations);

   658             Annotation[] annotations = createAnnotations(constantPool, desc.runtimeAnnotations);

   659             attributes.put(Attribute.RuntimeVisibleAnnotations,

   660                            new RuntimeVisibleAnnotations_attribute(attributeString, annotations));

   661         }

   662     }

   663 

   664     private Annotation[] createAnnotations(List<CPInfo> constantPool, List<AnnotationDescription> desc) {

   665         Annotation[] result = new Annotation[desc.size()];

   666         int i = 0;

   667 

   668         for (AnnotationDescription ad : desc) {

   669             result[i++] = createAnnotation(constantPool, ad);

   670         }

   671 

   672         return result;

   673     }

   674 

   675     private Annotation[][] createParameterAnnotations(List<CPInfo> constantPool, List<List<AnnotationDescription>> desc) {

   676         Annotation[][] result = new Annotation[desc.size()][];

   677         int i = 0;

   678 

   679         for (List<AnnotationDescription> paramAnnos : desc) {

   680             result[i++] = createAnnotations(constantPool, paramAnnos);

   681         }

   682 

   683         return result;

   684     }

   685 

   686     private Annotation createAnnotation(List<CPInfo> constantPool, AnnotationDescription desc) {

   687         return new Annotation(null,

   688                               addString(constantPool, desc.annotationType),

   689                               createElementPairs(constantPool, desc.values));

   690     }

   691 

   692     private element_value_pair[] createElementPairs(List<CPInfo> constantPool, Map<String, Object> annotationAttributes) {

   693         element_value_pair[] pairs = new element_value_pair[annotationAttributes.size()];

   694         int i = 0;

   695 

   696         for (Entry<String, Object> e : annotationAttributes.entrySet()) {

   697             int elementNameString = addString(constantPool, e.getKey());

   698             element_value value = createAttributeValue(constantPool, e.getValue());

   699             pairs[i++] = new element_value_pair(elementNameString, value);

   700         }

   701 

   702         return pairs;

   703     }

   704 

   705     private element_value createAttributeValue(List<CPInfo> constantPool, Object value) {

   706         Pair<Integer, Character> constantPoolEntry = addConstant(constantPool, value, true);

   707         if (constantPoolEntry != null) {

   708             return new Primitive_element_value(constantPoolEntry.fst, constantPoolEntry.snd);

   709         } else if (value instanceof EnumConstant) {

   710             EnumConstant ec = (EnumConstant) value;

   711             return new Enum_element_value(addString(constantPool, ec.type),

   712                                           addString(constantPool, ec.constant),

   713                                           'e');

   714         } else if (value instanceof ClassConstant) {

   715             ClassConstant cc = (ClassConstant) value;

   716             return new Class_element_value(addString(constantPool, cc.type), 'c');

   717         } else if (value instanceof AnnotationDescription) {

   718             Annotation annotation = createAnnotation(constantPool, ((AnnotationDescription) value));

   719             return new Annotation_element_value(annotation, '@');

   720         } else if (value instanceof Collection) {

   721             @SuppressWarnings("unchecked")

   722                     Collection<Object> array = (Collection<Object>) value;

   723             element_value[] values = new element_value[array.size()];

   724             int i = 0;

   725 

   726             for (Object elem : array) {

   727                 values[i++] = createAttributeValue(constantPool, elem);

   728             }

   729 

   730             return new Array_element_value(values, '[');

   731         }

   732         throw new IllegalStateException(value.getClass().getName());

   733     }

   734 

   735     private static Pair<Integer, Character> addConstant(List<CPInfo> constantPool, Object value, boolean annotation) {

   736         if (value instanceof Boolean) {

   737             return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info(((Boolean) value) ? 1 : 0)), 'Z');

   738         } else if (value instanceof Byte) {

   739             return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((byte) value)), 'B');

   740         } else if (value instanceof Character) {

   741             return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((char) value)), 'C');

   742         } else if (value instanceof Short) {

   743             return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((short) value)), 'S');

   744         } else if (value instanceof Integer) {

   745             return Pair.of(addToCP(constantPool, new CONSTANT_Integer_info((int) value)), 'I');

   746         } else if (value instanceof Long) {

   747             return Pair.of(addToCP(constantPool, new CONSTANT_Long_info((long) value)), 'J');

   748         } else if (value instanceof Float) {

   749             return Pair.of(addToCP(constantPool, new CONSTANT_Float_info((float) value)), 'F');

   750         } else if (value instanceof Double) {

   751             return Pair.of(addToCP(constantPool, new CONSTANT_Double_info((double) value)), 'D');

   752         } else if (value instanceof String) {

   753             int stringIndex = addString(constantPool, (String) value);

   754             if (annotation) {

   755                 return Pair.of(stringIndex, 's');

   756             } else {

   757                 return Pair.of(addToCP(constantPool, new CONSTANT_String_info(null, stringIndex)), 's');

   758             }

   759         }

   760 

   761         return null;

   762     }

   763 

   764     private static int addString(List<CPInfo> constantPool, String string) {

   765         Assert.checkNonNull(string);

   766 

   767         int i = 0;

   768         for (CPInfo info : constantPool) {

   769             if (info instanceof CONSTANT_Utf8_info) {

   770                 if (((CONSTANT_Utf8_info) info).value.equals(string)) {

   771                     return i;

   772                 }

   773             }

   774             i++;

   775         }

   776 

   777         return addToCP(constantPool, new CONSTANT_Utf8_info(string));

   778     }

   779 

   780     private static int addToCP(List<CPInfo> constantPool, CPInfo entry) {

   781         int result = constantPool.size();

   782 

   783         constantPool.add(entry);

   784 

   785         if (entry.size() > 1) {

   786             constantPool.add(null);

   787         }

   788 

   789         return result;

   790     }

   791 

   792     private static int addClass(List<CPInfo> constantPool, String className) {

   793         int classNameIndex = addString(constantPool, className);

   794 

   795         int i = 0;

   796         for (CPInfo info : constantPool) {

   797             if (info instanceof CONSTANT_Class_info) {

   798                 if (((CONSTANT_Class_info) info).name_index == classNameIndex) {

   799                     return i;

   800                 }

   801             }

   802             i++;

   803         }

   804 

   805         return addToCP(constantPool, new CONSTANT_Class_info(null, classNameIndex));

   806     }

   807     //</editor-fold>

   808     //</editor-fold>

   809 

   810     //<editor-fold defaultstate="collapsed" desc="Create Symbol Description">

   811     public void createBaseLine(List<VersionDescription> versions, ExcludeIncludeList excludesIncludes, Path descDest, Path jdkRoot) throws IOException {

   812         ClassList classes = new ClassList();

   813 

   814         for (VersionDescription desc : versions) {

   815             ClassList currentVersionClasses = new ClassList();

   816             try (BufferedReader descIn = Files.newBufferedReader(Paths.get(desc.classes))) {

   817                 String classFileData;

   818 

   819                 while ((classFileData = descIn.readLine()) != null) {

   820                     ByteArrayOutputStream data = new ByteArrayOutputStream();

   821                     for (int i = 0; i < classFileData.length(); i += 2) {

   822                         data.write(Integer.parseInt(classFileData.substring(i, i + 2), 16));

   823                     }

   824                     try (InputStream in = new ByteArrayInputStream(data.toByteArray())) {

   825                         inspectClassFile(in, currentVersionClasses, excludesIncludes, desc.version);

   826                     } catch (IOException | ConstantPoolException ex) {

   827                         throw new IllegalStateException(ex);

   828                     }

   829                 }

   830             }

   831 

   832             Set<String> includedClasses = new HashSet<>();

   833             boolean modified;

   834 

   835             do {

   836                 modified = false;

   837 

   838                 for (ClassDescription clazz : currentVersionClasses) {

   839                     ClassHeaderDescription header = clazz.header.get(0);

   840 

   841                     if (includeEffectiveAccess(currentVersionClasses, clazz)) {

   842                         modified |= include(includedClasses, currentVersionClasses, clazz.name);

   843                     }

   844 

   845                     if (includedClasses.contains(clazz.name)) {

   846                         modified |= include(includedClasses, currentVersionClasses, header.extendsAttr);

   847                         for (String i : header.implementsAttr) {

   848                             modified |= include(includedClasses, currentVersionClasses, i);

   849                         }

   850 

   851                         modified |= includeOutputType(Collections.singleton(header),

   852                                                       h -> "",

   853                                                       includedClasses,

   854                                                       currentVersionClasses);

   855                         modified |= includeOutputType(clazz.fields,

   856                                                       f -> f.descriptor,

   857                                                       includedClasses,

   858                                                       currentVersionClasses);

   859                         modified |= includeOutputType(clazz.methods,

   860                                                       m -> m.descriptor,

   861                                                       includedClasses,

   862                                                       currentVersionClasses);

   863                     }

   864                 }

   865             } while (modified);

   866 

   867             for (ClassDescription clazz : currentVersionClasses) {

   868                 if (!includedClasses.contains(clazz.name)) {

   869                     continue;

   870                 }

   871 

   872                 ClassHeaderDescription header = clazz.header.get(0);

   873 

   874                 if (header.innerClasses != null) {

   875                     Iterator<InnerClassInfo> innerClassIt = header.innerClasses.iterator();

   876 

   877                     while(innerClassIt.hasNext()) {

   878                         InnerClassInfo ici = innerClassIt.next();

   879                         if (!includedClasses.contains(ici.innerClass))

   880                             innerClassIt.remove();

   881                     }

   882                 }

   883 

   884                 ClassDescription existing = classes.find(clazz.name, true);

   885 

   886                 if (existing != null) {

   887                     addClassHeader(existing, header, desc.version);

   888                     for (MethodDescription currentMethod : clazz.methods) {

   889                         addMethod(existing, currentMethod, desc.version);

   890                     }

   891                     for (FieldDescription currentField : clazz.fields) {

   892                         addField(existing, currentField, desc.version);

   893                     }

   894                 } else {

   895                     classes.add(clazz);

   896                 }

   897             }

   898         }

   899 

   900         classes.sort();

   901 

   902         Map<String, String> package2Modules = buildPackage2Modules(jdkRoot);

   903         Map<String, List<ClassDescription>> module2Classes = new HashMap<>();

   904 

   905         for (ClassDescription clazz : classes) {

   906             String pack;

   907             int lastSlash = clazz.name.lastIndexOf('/');

   908             if (lastSlash != (-1)) {

   909                 pack = clazz.name.substring(0, lastSlash).replace('/', '.');

   910             } else {

   911                 pack = "";

   912             }

   913             String module = package2Modules.get(pack);

   914 

   915             if (module == null) {

   916                 module = "java.base";

   917 

   918                 OUTER: while (!pack.isEmpty()) {

   919                     for (Entry<String, String> p2M : package2Modules.entrySet()) {

   920                         if (p2M.getKey().startsWith(pack)) {

   921                             module = p2M.getValue();

   922                             break OUTER;

   923                         }

   924                     }

   925                     int dot = pack.lastIndexOf('.');

   926                     if (dot == (-1))

   927                         break;

   928                     pack = pack.substring(0, dot);

   929                 }

   930             }

   931             module2Classes.computeIfAbsent(module, m -> new ArrayList<>())

   932                     .add(clazz);

   933         }

   934 

   935         Path symbolsFile = descDest.resolve("symbols");

   936 

   937         Files.createDirectories(symbolsFile.getParent());

   938 

   939         try (Writer symbolsOut = Files.newBufferedWriter(symbolsFile)) {

   940             Map<VersionDescription, List<Path>> outputFiles = new LinkedHashMap<>();

   941 

   942             for (Entry<String, List<ClassDescription>> e : module2Classes.entrySet()) {

   943                 for (VersionDescription desc : versions) {

   944                     Path f = descDest.resolve(e.getKey() + "-" + desc.version + ".sym.txt");

   945                     try (Writer out = Files.newBufferedWriter(f)) {

   946                         for (ClassDescription clazz : e.getValue()) {

   947                             clazz.write(out, desc.primaryBaseline, desc.version);

   948                         }

   949                     }

   950                     outputFiles.computeIfAbsent(desc, d -> new ArrayList<>())

   951                                .add(f);

   952                 }

   953             }

   954             symbolsOut.append("generate platforms ")

   955                       .append(versions.stream()

   956                                       .map(v -> v.version)

   957                                       .collect(Collectors.joining(":")))

   958                       .append("\n");

   959             for (Entry<VersionDescription, List<Path>> versionFileEntry : outputFiles.entrySet()) {

   960                 symbolsOut.append("platform version ")

   961                           .append(versionFileEntry.getKey().version);

   962                 if (versionFileEntry.getKey().primaryBaseline != null) {

   963                     symbolsOut.append(" base ")

   964                               .append(versionFileEntry.getKey().primaryBaseline);

   965                 }

   966                 symbolsOut.append(" files ")

   967                           .append(versionFileEntry.getValue()

   968                                                   .stream()

   969                                                   .map(p -> p.getFileName().toString())

   970                                                   .sorted()

   971                                                   .collect(Collectors.joining(":")))

   972                           .append("\n");

   973             }

   974         }

   975     }

   976 

   977     //<editor-fold defaultstate="collapsed" desc="Class Reading">

   978     //non-final for tests:

   979     public static String PROFILE_ANNOTATION = "Ljdk/Profile+Annotation;";

   980     public static boolean ALLOW_NON_EXISTING_CLASSES = false;

   981 

   982     private void inspectClassFile(InputStream in, ClassList classes, ExcludeIncludeList excludesIncludes, String version) throws IOException, ConstantPoolException {

   983         ClassFile cf = ClassFile.read(in);

   984 

   985         if (!excludesIncludes.accepts(cf.getName())) {

   986             return ;

   987         }

   988 

   989         ClassHeaderDescription headerDesc = new ClassHeaderDescription();

   990 

   991         headerDesc.flags = cf.access_flags.flags;

   992 

   993         if (cf.super_class != 0) {

   994             headerDesc.extendsAttr = cf.getSuperclassName();

   995         }

   996         List<String> interfaces = new ArrayList<>();

   997         for (int i = 0; i < cf.interfaces.length; i++) {

   998             interfaces.add(cf.getInterfaceName(i));

   999         }

  1000         headerDesc.implementsAttr = interfaces;

  1001         for (Attribute attr : cf.attributes) {

  1002             if (!readAttribute(cf, headerDesc, attr))

  1003                 return ;

  1004         }

  1005 

  1006         ClassDescription clazzDesc = null;

  1007 

  1008         for (ClassDescription cd : classes) {

  1009             if (cd.name.equals(cf.getName())) {

  1010                 clazzDesc = cd;

  1011                 break;

  1012             }

  1013         }

  1014 

  1015         if (clazzDesc == null) {

  1016             clazzDesc = new ClassDescription();

  1017             clazzDesc.name = cf.getName();

  1018             classes.add(clazzDesc);

  1019         }

  1020 

  1021         addClassHeader(clazzDesc, headerDesc, version);

  1022 

  1023         for (Method m : cf.methods) {

  1024             if (!include(m.access_flags.flags))

  1025                 continue;

  1026             MethodDescription methDesc = new MethodDescription();

  1027             methDesc.flags = m.access_flags.flags;

  1028             methDesc.name = m.getName(cf.constant_pool);

  1029             methDesc.descriptor = m.descriptor.getValue(cf.constant_pool);

  1030             for (Attribute attr : m.attributes) {

  1031                 readAttribute(cf, methDesc, attr);

  1032             }

  1033             addMethod(clazzDesc, methDesc, version);

  1034         }

  1035         for (Field f : cf.fields) {

  1036             if (!include(f.access_flags.flags))

  1037                 continue;

  1038             FieldDescription fieldDesc = new FieldDescription();

  1039             fieldDesc.flags = f.access_flags.flags;

  1040             fieldDesc.name = f.getName(cf.constant_pool);

  1041             fieldDesc.descriptor = f.descriptor.getValue(cf.constant_pool);

  1042             for (Attribute attr : f.attributes) {

  1043                 readAttribute(cf, fieldDesc, attr);

  1044             }

  1045             addField(clazzDesc, fieldDesc, version);

  1046         }

  1047     }

  1048 

  1049     private boolean include(int accessFlags) {

  1050         return (accessFlags & (AccessFlags.ACC_PUBLIC | AccessFlags.ACC_PROTECTED)) != 0;

  1051     }

  1052 

  1053     private void addClassHeader(ClassDescription clazzDesc, ClassHeaderDescription headerDesc, String version) {

  1054         //normalize:

  1055         boolean existed = false;

  1056         for (ClassHeaderDescription existing : clazzDesc.header) {

  1057             if (existing.equals(headerDesc)) {

  1058                 headerDesc = existing;

  1059                 existed = true;

  1060             } else {

  1061                 //check if the only difference between the 7 and 8 version is the Profile annotation

  1062                 //if so, copy it to the pre-8 version, so save space

  1063                 List<AnnotationDescription> annots = headerDesc.classAnnotations;

  1064 

  1065                 if (annots != null) {

  1066                     for (AnnotationDescription ad : annots) {

  1067                         if (PROFILE_ANNOTATION.equals(ad.annotationType)) {

  1068                             annots.remove(ad);

  1069                             if (existing.equals(headerDesc)) {

  1070                                 headerDesc = existing;

  1071                                 annots = headerDesc.classAnnotations;

  1072                                 if (annots == null) {

  1073                                     headerDesc.classAnnotations = annots = new ArrayList<>();

  1074                                 }

  1075                                 annots.add(ad);

  1076                                 existed = true;

  1077                             } else {

  1078                                 annots.add(ad);

  1079                             }

  1080                             break;

  1081                         }

  1082                     }

  1083                 }

  1084             }

  1085         }

  1086 

  1087         headerDesc.versions += version;

  1088 

  1089         if (!existed) {

  1090             clazzDesc.header.add(headerDesc);

  1091         }

  1092     }

  1093 

  1094     private void addMethod(ClassDescription clazzDesc, MethodDescription methDesc, String version) {

  1095         //normalize:

  1096         boolean methodExisted = false;

  1097         for (MethodDescription existing : clazzDesc.methods) {

  1098             if (existing.equals(methDesc)) {

  1099                 methodExisted = true;

  1100                 methDesc = existing;

  1101                 break;

  1102             }

  1103         }

  1104         methDesc.versions += version;

  1105         if (!methodExisted) {

  1106             clazzDesc.methods.add(methDesc);

  1107         }

  1108     }

  1109 

  1110     private void addField(ClassDescription clazzDesc, FieldDescription fieldDesc, String version) {

  1111         boolean fieldExisted = false;

  1112         for (FieldDescription existing : clazzDesc.fields) {

  1113             if (existing.equals(fieldDesc)) {

  1114                 fieldExisted = true;

  1115                 fieldDesc = existing;

  1116                 break;

  1117             }

  1118         }

  1119         fieldDesc.versions += version;

  1120         if (!fieldExisted) {

  1121             clazzDesc.fields.add(fieldDesc);

  1122         }

  1123     }

  1124 

  1125     private boolean readAttribute(ClassFile cf, FeatureDescription feature, Attribute attr) throws ConstantPoolException {

  1126         String attrName = attr.getName(cf.constant_pool);

  1127         switch (attrName) {

  1128             case Attribute.AnnotationDefault:

  1129                 assert feature instanceof MethodDescription;

  1130                 element_value defaultValue = ((AnnotationDefault_attribute) attr).default_value;

  1131                 ((MethodDescription) feature).annotationDefaultValue =

  1132                         convertElementValue(cf.constant_pool, defaultValue);

  1133                 break;

  1134             case "Deprecated":

  1135                 feature.deprecated = true;

  1136                 break;