src/share/classes/com/sun/tools/javac/processing/JavacProcessingEnvironment.java

*** 293,397 ****
          }
      }
  
      /**
       * Use a service loader appropriate for the platform to provide an
!      * iterator over annotations processors.  If
!      * java.util.ServiceLoader is present use it, otherwise, use
!      * sun.misc.Service, otherwise fail if a loader is needed.
       */
      private class ServiceIterator implements Iterator<Processor> {
!         // The to-be-wrapped iterator.
!         private Iterator<?> iterator;
          private Log log;
!         private Class<?> loaderClass;
!         private boolean jusl;
!         private Object loader;
  
          ServiceIterator(ClassLoader classLoader, Log log) {
-             String loadMethodName;
- 
              this.log = log;
              try {
                  try {
!                     loaderClass = Class.forName("java.util.ServiceLoader");
!                     loadMethodName = "load";
!                     jusl = true;
!                 } catch (ClassNotFoundException cnfe) {
!                     try {
!                         loaderClass = Class.forName("sun.misc.Service");
!                         loadMethodName = "providers";
!                         jusl = false;
!                     } catch (ClassNotFoundException cnfe2) {
                          // Fail softly if a loader is not actually needed.
!                         this.iterator = handleServiceLoaderUnavailability("proc.no.service",
!                                                                           null);
!                         return;
!                     }
                  }
- 
-                 // java.util.ServiceLoader.load or sun.misc.Service.providers
-                 Method loadMethod = loaderClass.getMethod(loadMethodName,
-                                                           Class.class,
-                                                           ClassLoader.class);
- 
-                 Object result = loadMethod.invoke(null,
-                                                   Processor.class,
-                                                   classLoader);
- 
-                 // For java.util.ServiceLoader, we have to call another
-                 // method to get the iterator.
-                 if (jusl) {
-                     loader = result; // Store ServiceLoader to call reload later
-                     Method m = loaderClass.getMethod("iterator");
-                     result = m.invoke(result); // serviceLoader.iterator();
-                 }
- 
-                 // The result should now be an iterator.
-                 this.iterator = (Iterator<?>) result;
              } catch (Throwable t) {
                  log.error("proc.service.problem");
                  throw new Abort(t);
              }
          }
  
          public boolean hasNext() {
              try {
                  return iterator.hasNext();
              } catch (Throwable t) {
-                 if ("ServiceConfigurationError".
-                     equals(t.getClass().getSimpleName())) {
-                     log.error("proc.bad.config.file", t.getLocalizedMessage());
-                 }
                  throw new Abort(t);
              }
          }
  
          public Processor next() {
              try {
!                 return (Processor)(iterator.next());
              } catch (Throwable t) {
-                 if ("ServiceConfigurationError".
-                     equals(t.getClass().getSimpleName())) {
-                     log.error("proc.bad.config.file", t.getLocalizedMessage());
-                 } else {
-                     log.error("proc.processor.constructor.error", t.getLocalizedMessage());
-                 }
                  throw new Abort(t);
              }
          }
  
          public void remove() {
              throw new UnsupportedOperationException();
          }
  
          public void close() {
!             if (jusl) {
                  try {
!                     // Call java.util.ServiceLoader.reload
!                     Method reloadMethod = loaderClass.getMethod("reload");
!                     reloadMethod.invoke(loader);
                  } catch(Exception e) {
                      ; // Ignore problems during a call to reload.
                  }
              }
          }
--- 293,356 ----
          }
      }
  
      /**
       * Use a service loader appropriate for the platform to provide an
!      * iterator over annotations processors; fails if a loader is
!      * needed but unavailable.
       */
      private class ServiceIterator implements Iterator<Processor> {
!         private Iterator<Processor> iterator;
          private Log log;
!         private ServiceLoader<Processor> loader;
  
          ServiceIterator(ClassLoader classLoader, Log log) {
              this.log = log;
              try {
                  try {
!                     loader = ServiceLoader.load(Processor.class, classLoader);
!                     this.iterator = loader.iterator();
!                 } catch (Exception e) {
                      // Fail softly if a loader is not actually needed.
!                     this.iterator = handleServiceLoaderUnavailability("proc.no.service", null);
                  }
              } catch (Throwable t) {
                  log.error("proc.service.problem");
                  throw new Abort(t);
              }
          }
  
          public boolean hasNext() {
              try {
                  return iterator.hasNext();
+             } catch(ServiceConfigurationError sce) {
+                 log.error("proc.bad.config.file", sce.getLocalizedMessage());
+                 throw new Abort(sce);
              } catch (Throwable t) {
                  throw new Abort(t);
              }
          }
  
          public Processor next() {
              try {
!                 return iterator.next();
!             } catch (ServiceConfigurationError sce) {
!                 log.error("proc.bad.config.file", sce.getLocalizedMessage());
!                 throw new Abort(sce);
              } catch (Throwable t) {
                  throw new Abort(t);
              }
          }
  
          public void remove() {
              throw new UnsupportedOperationException();
          }
  
          public void close() {
!             if (loader != null) {
                  try {
!                     loader.reload();
                  } catch(Exception e) {
                      ; // Ignore problems during a call to reload.
                  }
              }
          }