1 /*
   2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package com.sun.tools.javac.platform;
  26 
  27 import java.io.IOException;
  28 import java.nio.file.DirectoryStream;
  29 import java.nio.file.FileSystem;
  30 import java.nio.file.FileSystems;
  31 import java.nio.file.Files;
  32 import java.nio.file.Path;
  33 import java.nio.file.Paths;
  34 import java.util.ArrayList;
  35 import java.util.Collection;
  36 import java.util.Collections;
  37 import java.util.HashMap;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import java.util.TreeSet;
  42 
  43 import javax.annotation.processing.Processor;
  44 
  45 import com.sun.source.util.Plugin;
  46 import com.sun.tools.javac.jvm.Target;
  47 
  48 /** PlatformProvider for JDK N.
  49  * 
  50  *  <p><b>This is NOT part of any supported API.
  51  *  If you write code that depends on this, you do so at your own risk.
  52  *  This code and its internal interfaces are subject to change or
  53  *  deletion without notice.</b>
  54  */
  55 public class JDKPlatformProvider implements PlatformProvider {
  56 
  57     @Override
  58     public Iterable<String> getSupportedPlatformNames() {
  59         return SUPPORTED_JAVA_PLATFORM_VERSIONS;
  60     }
  61 
  62     @Override
  63     public PlatformDescription getPlatform(String platformName, String options) {
  64         return new PlatformDescriptionImpl(platformName);
  65     }
  66 
  67     private static final String[] symbolFileLocation = { "lib", "ct.sym" };
  68 
  69     private static final Set<String> SUPPORTED_JAVA_PLATFORM_VERSIONS;
  70 
  71     static {
  72         SUPPORTED_JAVA_PLATFORM_VERSIONS = new TreeSet<>();
  73         Path ctSymFile = findCtSym();
  74         if (Files.exists(ctSymFile)) {
  75             try (FileSystem fs = FileSystems.newFileSystem(ctSymFile, null);
  76                  DirectoryStream<Path> dir =
  77                          Files.newDirectoryStream(fs.getRootDirectories().iterator().next())) {
  78                 for (Path section : dir) {
  79                     for (char ver : section.getFileName().toString().toCharArray()) {
  80                         String verString = Character.toString(ver);
  81                         Target t = Target.lookup(verString);
  82 
  83                         if (t != null) {
  84                             SUPPORTED_JAVA_PLATFORM_VERSIONS.add(targetNumericVersion(t));
  85                         }
  86                     }
  87                 }
  88             } catch (IOException ex) {
  89                 //XXX: can handle somehow? Print a warning?
  90             }
  91         }
  92         SUPPORTED_JAVA_PLATFORM_VERSIONS.add(targetNumericVersion(Target.DEFAULT));
  93     }
  94 
  95     private static String targetNumericVersion(Target target) {
  96         return Integer.toString(target.ordinal() - Target.JDK1_1.ordinal() + 1);
  97     }
  98 
  99     static class PlatformDescriptionImpl implements PlatformDescription {
 100 
 101         private final Map<Path, FileSystem> ctSym2FileSystem = new HashMap<>();
 102         private final String version;
 103 
 104         PlatformDescriptionImpl(String version) {
 105             this.version = version;
 106         }
 107 
 108         @Override
 109         public Collection<Path> getPlatformPath() {
 110             if (Target.lookup(version) == Target.DEFAULT) {
 111                 return null;
 112             }
 113 
 114             List<Path> paths = new ArrayList<>();
 115             Path file = findCtSym();
 116             // file == ${jdk.home}/lib/ct.sym
 117             if (Files.exists(file)) {
 118                 FileSystem fs = ctSym2FileSystem.get(file);
 119                 if (fs == null) {
 120                     try {
 121                         ctSym2FileSystem.put(file, fs = FileSystems.newFileSystem(file, null));
 122                     } catch (IOException ex) {
 123                         throw new IllegalStateException(ex);
 124                     }
 125                 }
 126                 Path root = fs.getRootDirectories().iterator().next();
 127                 try (DirectoryStream<Path> dir = Files.newDirectoryStream(root)) {
 128                     for (Path section : dir) {
 129                         if (section.getFileName().toString().contains(version)) {
 130                             paths.add(section);
 131                         }
 132                     }
 133                 } catch (IOException ex) {
 134                     throw new IllegalStateException(ex);
 135                 }
 136             } else {
 137                 throw new IllegalStateException("Cannot find ct.sym!");
 138             }
 139             return paths;
 140         }
 141 
 142         @Override
 143         public String getSourceVersion() {
 144             return version;
 145         }
 146 
 147         @Override
 148         public String getTargetVersion() {
 149             return version;
 150         }
 151 
 152         @Override
 153         public List<PluginInfo<Processor>> getAnnotationProcessors() {
 154             return Collections.emptyList();
 155         }
 156 
 157         @Override
 158         public List<PluginInfo<Plugin>> getPlugins() {
 159             return Collections.emptyList();
 160         }
 161 
 162         @Override
 163         public List<String> getAdditionalOptions() {
 164             return Collections.emptyList();
 165         }
 166 
 167         @Override
 168         public void close() throws IOException {
 169             for (FileSystem fs : ctSym2FileSystem.values()) {
 170                 fs.close();
 171             }
 172             ctSym2FileSystem.clear();
 173         }
 174 
 175     }
 176     
 177     static Path findCtSym() {
 178         String javaHome = System.getProperty("java.home");
 179         Path file = Paths.get(javaHome);
 180         if (file.getFileName().equals(Paths.get("jre")))
 181             file = file.getParent();
 182         // file == ${jdk.home}
 183         for (String name : symbolFileLocation)
 184             file = file.resolve(name);
 185         return file;
 186     }
 187 
 188 }