/**
   * Returns an empty processor iterator if no processors are on the relevant path, otherwise if
   * processors are present, logs an error. Called when a service loader is unavailable for some
   * reason, either because a service loader class cannot be found or because a security policy
   * prevents class loaders from being created.
   *
   * @param key The resource key to use to log an error message
   * @param e If non-null, pass this exception to Abort
   */
  private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
    JavaFileManager fileManager = context.get(JavaFileManager.class);

    if (fileManager instanceof JavacFileManager) {
      StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
      Iterable<? extends File> workingPath =
          fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
              ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
              : standardFileManager.getLocation(CLASS_PATH);

      if (needClassLoader(options.get(PROCESSOR), workingPath)) handleException(key, e);

    } else {
      handleException(key, e);
    }

    java.util.List<Processor> pl = Collections.emptyList();
    return pl.iterator();
  }
  @Override
  @SuppressWarnings("unchecked")
  protected void setPaths(
      ArrayList bootclasspaths,
      String sourcepathClasspathArg,
      ArrayList sourcepathClasspaths,
      ArrayList classpaths,
      ArrayList extdirsClasspaths,
      ArrayList endorsedDirClasspaths,
      String customEncoding) {

    ArrayList<FileSystem.Classpath> fileSystemClasspaths = new ArrayList<FileSystem.Classpath>();
    EclipseFileManager javaFileManager = null;
    StandardJavaFileManager standardJavaFileManager = null;
    if (this.fileManager instanceof EclipseFileManager) {
      javaFileManager = (EclipseFileManager) this.fileManager;
    }
    if (this.fileManager instanceof StandardJavaFileManager) {
      standardJavaFileManager = (StandardJavaFileManager) this.fileManager;
    }

    if (javaFileManager != null) {
      if ((javaFileManager.flags & EclipseFileManager.HAS_ENDORSED_DIRS) == 0
          && (javaFileManager.flags & EclipseFileManager.HAS_BOOTCLASSPATH) != 0) {
        fileSystemClasspaths.addAll(this.handleEndorseddirs(null));
      }
    }
    Iterable<? extends File> location = null;
    if (standardJavaFileManager != null) {
      location = standardJavaFileManager.getLocation(StandardLocation.PLATFORM_CLASS_PATH);
    }
    if (location != null) {
      for (File file : location) {
        Classpath classpath = FileSystem.getClasspath(file.getAbsolutePath(), null, null);
        if (classpath != null) {
          fileSystemClasspaths.add(classpath);
        }
      }
    }
    if (javaFileManager != null) {
      if ((javaFileManager.flags & EclipseFileManager.HAS_EXT_DIRS) == 0
          && (javaFileManager.flags & EclipseFileManager.HAS_BOOTCLASSPATH) != 0) {
        fileSystemClasspaths.addAll(this.handleExtdirs(null));
      }
    }
    if (standardJavaFileManager != null) {
      location = standardJavaFileManager.getLocation(StandardLocation.SOURCE_PATH);
    } else {
      location = null;
    }
    if (location != null) {
      for (File file : location) {
        Classpath classpath = FileSystem.getClasspath(file.getAbsolutePath(), null, null);
        if (classpath != null) {
          fileSystemClasspaths.add(classpath);
        }
      }
    }
    if (standardJavaFileManager != null) {
      location = standardJavaFileManager.getLocation(StandardLocation.CLASS_PATH);
    } else {
      location = null;
    }
    if (location != null) {
      for (File file : location) {
        Classpath classpath = FileSystem.getClasspath(file.getAbsolutePath(), null, null);
        if (classpath != null) {
          fileSystemClasspaths.add(classpath);
        }
      }
    }
    if (this.checkedClasspaths == null) {
      fileSystemClasspaths.addAll(this.handleBootclasspath(null, null));
      fileSystemClasspaths.addAll(this.handleClasspath(null, null));
    }
    fileSystemClasspaths = FileSystem.ClasspathNormalizer.normalize(fileSystemClasspaths);
    final int size = fileSystemClasspaths.size();
    if (size != 0) {
      this.checkedClasspaths = new FileSystem.Classpath[size];
      int i = 0;
      for (FileSystem.Classpath classpath : fileSystemClasspaths) {
        this.checkedClasspaths[i++] = classpath;
      }
    }
  }
Exemple #3
0
 public Iterable<? extends File> getLocation(Location location) {
   return standardJavaFileManager.getLocation(location);
 }
Exemple #4
0
  void createSymbols() throws IOException {
    Set<String> legacy = getLegacyPackages();
    Set<String> legacyProprietary = getLegacyPackages();
    Set<String> documented = new HashSet<String>();
    Set<PackageSymbol> packages =
        ((JavacProcessingEnvironment) processingEnv).getSpecifiedPackages();
    String jarName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Jar");
    if (jarName == null)
      throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Jar=LOCATION_OF_JAR");
    String destName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Dest");
    if (destName == null)
      throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Dest=LOCATION_OF_JAR");

    for (PackageSymbol psym : packages) {
      String name = psym.getQualifiedName().toString();
      legacyProprietary.remove(name);
      documented.add(name);
    }

    JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
    Location jarLocation = StandardLocation.locationFor(jarName);
    File jarFile = new File(jarName);
    fm.setLocation(jarLocation, List.of(jarFile));
    fm.setLocation(StandardLocation.CLASS_PATH, List.<File>nil());
    fm.setLocation(StandardLocation.SOURCE_PATH, List.<File>nil());
    {
      ArrayList<File> bootClassPath = new ArrayList<File>();
      bootClassPath.add(jarFile);
      for (File path : fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) {
        if (!new File(path.getName()).equals(new File("rt.jar"))) bootClassPath.add(path);
      }
      System.err.println("Using boot class path = " + bootClassPath);
      fm.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
    }
    // System.out.println(fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH));
    File destDir = new File(destName);
    if (!destDir.exists())
      if (!destDir.mkdirs()) throw new RuntimeException("Could not create " + destDir);
    fm.setLocation(StandardLocation.CLASS_OUTPUT, List.of(destDir));
    Set<String> hiddenPackages = new HashSet<String>();
    Set<String> crisp = new HashSet<String>();
    List<String> options = List.of("-XDdev");
    // options = options.prepend("-doe");
    // options = options.prepend("-verbose");
    JavacTaskImpl task = (JavacTaskImpl) tool.getTask(null, fm, null, options, null, null);
    com.sun.tools.javac.main.JavaCompiler compiler =
        com.sun.tools.javac.main.JavaCompiler.instance(task.getContext());
    ClassReader reader = ClassReader.instance(task.getContext());
    ClassWriter writer = ClassWriter.instance(task.getContext());
    Symtab syms = Symtab.instance(task.getContext());
    Attribute.Compound proprietary =
        new Attribute.Compound(
            syms.proprietaryType, List.<Pair<Symbol.MethodSymbol, Attribute>>nil());

    Type.moreInfo = true;
    Pool pool = new Pool();
    for (JavaFileObject file : fm.list(jarLocation, "", EnumSet.of(CLASS), true)) {
      String className = fm.inferBinaryName(jarLocation, file);
      int index = className.lastIndexOf('.');
      String pckName = index == -1 ? "" : className.substring(0, index);
      boolean addLegacyAnnotation = false;
      if (documented.contains(pckName)) {
        if (!legacy.contains(pckName)) crisp.add(pckName);
        // System.out.println("Documented: " + className);
      } else if (legacyProprietary.contains(pckName)) {
        addLegacyAnnotation = true;
        // System.out.println("Legacy proprietary: " + className);
      } else {
        // System.out.println("Hidden " + className);
        hiddenPackages.add(pckName);
        continue;
      }
      TypeSymbol sym = (TypeSymbol) compiler.resolveIdent(className);
      if (sym.kind != Kinds.TYP) {
        if (className.indexOf('$') < 0) {
          System.err.println("Ignoring (other) " + className + " : " + sym);
          System.err.println("   " + sym.getClass().getSimpleName() + " " + sym.type);
        }
        continue;
      }
      sym.complete();
      if (sym.getEnclosingElement().getKind() != ElementKind.PACKAGE) {
        System.err.println("Ignoring (bad) " + sym.getQualifiedName());
        continue;
      }
      ClassSymbol cs = (ClassSymbol) sym;
      if (addLegacyAnnotation) {
        cs.attributes_field =
            (cs.attributes_field == null)
                ? List.of(proprietary)
                : cs.attributes_field.prepend(proprietary);
      }
      writeClass(pool, cs, writer);
    }

    if (false) {
      for (String pckName : crisp) System.out.println("Crisp: " + pckName);
      for (String pckName : hiddenPackages) System.out.println("Hidden: " + pckName);
      for (String pckName : legacyProprietary) System.out.println("Legacy proprietary: " + pckName);
      for (String pckName : documented) System.out.println("Documented: " + pckName);
    }
  }
 @Override
 public Iterable<? extends File> getLocation(Location location) {
   return myStandardFileManager.getLocation(location);
 }