| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.netbeans.modules.jackpot30.cmdline.lib; |
| |
| import com.sun.source.util.JavacTask; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.lang.reflect.InvocationTargetException; |
| import java.net.MalformedURLException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.regex.Pattern; |
| import javax.tools.ForwardingJavaFileManager; |
| import javax.tools.JavaCompiler; |
| import javax.tools.JavaCompiler.CompilationTask; |
| import javax.tools.JavaFileManager; |
| import javax.tools.JavaFileManager.Location; |
| import javax.tools.ToolProvider; |
| import org.netbeans.api.annotations.common.NonNull; |
| import org.netbeans.api.java.classpath.ClassPath; |
| import org.netbeans.modules.java.hints.providers.spi.HintDescription; |
| import org.netbeans.spi.java.classpath.PathResourceImplementation; |
| import org.netbeans.spi.java.classpath.support.ClassPathSupport; |
| import org.openide.filesystems.FileObject; |
| import org.openide.filesystems.FileUtil; |
| import org.openide.filesystems.URLMapper; |
| import org.openide.util.BaseUtilities; |
| |
| /** |
| * |
| * @author lahvac |
| */ |
| public class Utils { |
| |
| public static Map<String, String> computeId2DisplayName(Iterable<? extends HintDescription> descs) { |
| final Map<String, String> id2DisplayName = new HashMap<>(); |
| |
| for (HintDescription hd : descs) { |
| if (hd.getMetadata() != null) { |
| id2DisplayName.put(hd.getMetadata().id, hd.getMetadata().displayName); |
| } |
| } |
| |
| return id2DisplayName; |
| } |
| |
| public static String categoryName(String id, Map<String, String> id2DisplayName) { |
| if (id != null && id.startsWith("text/x-java:")) { |
| id = id.substring("text/x-java:".length()); |
| } |
| |
| String idDisplayName = id2DisplayName.get(id); |
| |
| if (idDisplayName == null) { |
| idDisplayName = "unknown"; |
| } |
| |
| for (Entry<String, String> remap : toIdRemap.entrySet()) { |
| idDisplayName = idDisplayName.replace(remap.getKey(), remap.getValue()); |
| } |
| |
| idDisplayName = idDisplayName.replaceAll("[^A-Za-z0-9]", "_").replaceAll("_+", "_"); |
| |
| idDisplayName = "[" + idDisplayName + "] "; |
| |
| return idDisplayName; |
| } |
| |
| private static final Map<String, String> toIdRemap = new HashMap<String, String>() {{ |
| put("==", "equals"); |
| put("!=", "not_equals"); |
| }}; |
| |
| //copied from BootClassPathUtil: |
| public static ClassPath createDefaultBootClassPath() { |
| String cp = System.getProperty("sun.boot.class.path"); |
| if (cp != null) { |
| List<URL> urls = new ArrayList<>(); |
| String[] paths = cp.split(Pattern.quote(System.getProperty("path.separator"))); |
| for (String path : paths) { |
| File f = new File(path); |
| |
| if (!f.canRead()) |
| continue; |
| |
| FileObject fo = FileUtil.toFileObject(f); |
| if (FileUtil.isArchiveFile(fo)) { |
| fo = FileUtil.getArchiveRoot(fo); |
| } |
| if (fo != null) { |
| urls.add(fo.toURL()); |
| } |
| } |
| return ClassPathSupport.createClassPath((URL[])urls.toArray(new URL[0])); |
| } else { |
| try { |
| Class.forName("org.netbeans.ProxyURLStreamHandlerFactory").getMethod("register") |
| .invoke(null); |
| } catch (ClassNotFoundException | NoSuchMethodException | |
| SecurityException | IllegalAccessException | |
| IllegalArgumentException | InvocationTargetException ex) { |
| throw new IllegalStateException(ex); |
| } |
| final List<PathResourceImplementation> modules = new ArrayList<>(); |
| final File installDir = new File(System.getProperty("java.home")); |
| final URI imageURI = getImageURI(installDir); |
| try { |
| final FileObject jrtRoot = URLMapper.findFileObject(imageURI.toURL()); |
| final FileObject root = getModulesRoot(jrtRoot); |
| for (FileObject module : root.getChildren()) { |
| modules.add(ClassPathSupport.createResource(module.toURL())); |
| } |
| } catch (MalformedURLException e) { |
| throw new IllegalStateException(e); |
| } |
| if (modules.isEmpty()) { |
| throw new IllegalStateException("No modules!"); |
| } |
| return ClassPathSupport.createClassPath(modules); |
| } |
| } |
| |
| private static final String PROTOCOL = "nbjrt"; //NOI18N |
| |
| private static URI getImageURI(@NonNull final File jdkHome) { |
| try { |
| return new URI(String.format( |
| "%s:%s!/%s", //NOI18N |
| PROTOCOL, |
| BaseUtilities.toURI(jdkHome).toString(), |
| "")); |
| } catch (URISyntaxException e) { |
| throw new IllegalStateException(); |
| } |
| } |
| |
| @NonNull |
| private static FileObject getModulesRoot(@NonNull final FileObject jrtRoot) { |
| final FileObject modules = jrtRoot.getFileObject("modules"); //NOI18N |
| //jimage v1 - modules are located in the root |
| //jimage v2 - modules are located in "modules" folder |
| return modules == null ? |
| jrtRoot : |
| modules; |
| } |
| |
| public static void addExports() { |
| class CurrentClassLoaderFM extends ForwardingJavaFileManager<JavaFileManager> { |
| public CurrentClassLoaderFM(JavaFileManager delegate) { |
| super(delegate); |
| } |
| @Override |
| public ClassLoader getClassLoader(Location location) { |
| return Utils.class.getClassLoader(); |
| } |
| } |
| JavaCompiler compilerTool = ToolProvider.getSystemJavaCompiler(); |
| try (CurrentClassLoaderFM fm = new CurrentClassLoaderFM(compilerTool.getStandardFileManager(d -> {}, null, null))) { |
| PrintWriter nullWriter = new PrintWriter(new StringWriter()); |
| //using JavacTask.analyze instead of CompilationTask.call to avoid closing the current ClassLoader: |
| ((JavacTask) compilerTool.getTask(nullWriter, fm, d -> {}, Arrays.asList("-proc:none", "-XDaccessInternalAPI"), Arrays.asList("java.lang.Object"), null)).analyze(); |
| } catch (IOException ex) { |
| //ignore... |
| ex.printStackTrace(); |
| } |
| } |
| } |