/* * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ /*****************************************************************************//*                    Copyright (c) IBM Corporation 1998                     *//*                                                                           *//* (C) Copyright IBM Corp. 1998                                              *//*                                                                           *//*****************************************************************************/ package sun.rmi.rmic; import java.io.File;import java.io.IOException;import java.io.OutputStream;import java.util.Collection;import java.util.Enumeration;import java.util.Iterator;import java.util.LinkedHashSet;import java.util.StringTokenizer;import java.util.Vector;import java.util.jar.JarFile;import java.util.jar.Manifest;import java.util.jar.Attributes;import sun.tools.java.ClassPath; /** * BatchEnvironment for rmic extends javac's version in four ways: * 1. It overrides errorString() to handle looking for rmic-specific * error messages in rmic's resource bundle * 2. It provides a mechanism for recording intermediate generated * files so that they can be deleted later. * 3. It holds a reference to the Main instance so that generators * can refer to it. * 4. It provides access to the ClassPath passed to the constructor. * * WARNING: The contents of this source file are not part of any * supported API.  Code that depends on them does so at its own risk: * they are subject to change or removal without notice. */ public class BatchEnvironment extends sun.tools.javac.BatchEnvironment {     /** instance of Main which created this environment */    private Main main;     /**     * Create a ClassPath object for rmic from a class path string.     */    public static ClassPath createClassPath(String classPathString) {        ClassPath[] paths = classPaths(null, classPathString, null, null);        return paths[1];    }     /**     * Create a ClassPath object for rmic from the relevant command line     * options for class path, boot class path, and extension directories.     */    public static ClassPath createClassPath(String classPathString,                                            String sysClassPathString,                                            String extDirsString)    {        /**         * Previously, this method delegated to the         * sun.tools.javac.BatchEnvironment.classPaths method in order         * to supply default values for paths not specified on the         * command line, expand extensions directories into specific         * JAR files, and construct the ClassPath object-- but as part         * of the fix for 6473331, which adds support for Class-Path         * manifest entries in JAR files, those steps are now handled         * here directly, with the help of a Path utility class copied         * from the new javac implementation (see below).         */        Path path = new Path();         if (sysClassPathString == null) {            sysClassPathString = System.getProperty("sun.boot.class.path");        }        if (sysClassPathString != null) {            path.addFiles(sysClassPathString);        }         /*         * Class-Path manifest entries are supported for JAR files         * everywhere except in the boot class path.         */        path.expandJarClassPaths(true);         if (extDirsString == null) {            extDirsString = System.getProperty("java.ext.dirs");        }        if (extDirsString != null) {            path.addDirectories(extDirsString);        }         /*         * In the application class path, an empty element means         * the current working directory.         */        path.emptyPathDefault(".");         if (classPathString == null) {            // The env.class.path property is the user's CLASSPATH            // environment variable, and it set by the wrapper (ie,            // javac.exe).            classPathString = System.getProperty("env.class.path");            if (classPathString == null) {                classPathString = ".";            }        }        path.addFiles(classPathString);         return new ClassPath(path.toArray(new String[path.size()]));    }     /**     * Create a BatchEnvironment for rmic with the given class path,     * stream for messages and Main.     */    public BatchEnvironment(OutputStream out, ClassPath path, Main main) {        super(out, new ClassPath(""), path);                                // use empty "sourcePath" (see 4666958)        this.main = main;    }     /**     * Get the instance of Main which created this environment.     */    public Main getMain() {        return main;    }     /**     * Get the ClassPath.     */    public ClassPath getClassPath() {        return binaryPath;    }     /** list of generated source files created in this environment */    private Vector generatedFiles = new Vector();     /**     * Remember a generated source file generated so that it     * can be removed later, if appropriate.     */    public void addGeneratedFile(File file) {        generatedFiles.addElement(file);    }     /**     * Delete all the generated source files made during the execution     * of this environment (those that have been registered with the     * "addGeneratedFile" method).     */    public void deleteGeneratedFiles() {        synchronized(generatedFiles) {            Enumeration enumeration = generatedFiles.elements();            while (enumeration.hasMoreElements()) {                File file = (File) enumeration.nextElement();                file.delete();            }            generatedFiles.removeAllElements();        }    }     /**     * Release resources, if any.     */    public void shutdown() {        main = null;        generatedFiles = null;        super.shutdown();    }     /**     * Return the formatted, localized string for a named error message     * and supplied arguments.  For rmic error messages, with names that     * being with "rmic.", look up the error message in rmic's resource     * bundle; otherwise, defer to java's superclass method.     */    public String errorString(String err,                              Object arg0, Object arg1, Object arg2)    {        if (err.startsWith("rmic.") || err.startsWith("warn.rmic.")) {            String result =  Main.getText(err,                                          (arg0 != null ? arg0.toString() : null),                                          (arg1 != null ? arg1.toString() : null),                                          (arg2 != null ? arg2.toString() : null));             if (err.startsWith("warn.")) {                result = "warning: " + result;            }            return result;        } else {            return super.errorString(err, arg0, arg1, arg2);        }    }    public void reset() {    }     /**     * Utility for building paths of directories and JAR files.  This     * class was copied from com.sun.tools.javac.util.Paths as part of     * the fix for 6473331, which adds support for Class-Path manifest     * entries in JAR files.  Diagnostic code is simply commented out     * because rmic silently ignored these conditions historically.     */    private static class Path extends LinkedHashSet<String> {        private static final long serialVersionUID = 0;        private static final boolean warn = false;         private static class PathIterator implements Collection<String> {            private int pos = 0;            private final String path;            private final String emptyPathDefault;             public PathIterator(String path, String emptyPathDefault) {                this.path = path;                this.emptyPathDefault = emptyPathDefault;            }            public PathIterator(String path) { this(path, null); }            public Iterator<String> iterator() {                return new Iterator<String>() {                    public boolean hasNext() {                        return pos <= path.length();                    }                    public String next() {                        int beg = pos;                        int end = path.indexOf(File.pathSeparator, beg);                        if (end == -1)                            end = path.length();                        pos = end + 1;                         if (beg == end && emptyPathDefault != null)                            return emptyPathDefault;                        else                            return path.substring(beg, end);                    }                    public void remove() {                        throw new UnsupportedOperationException();                    }                };            }             // required for Collection.            public int size() {                throw new UnsupportedOperationException();            }            public boolean isEmpty() {                throw new UnsupportedOperationException();            }            public boolean contains(Object o) {                throw new UnsupportedOperationException();            }            public Object[] toArray() {                throw new UnsupportedOperationException();            }            public <T> T[] toArray(T[] a) {                throw new UnsupportedOperationException();            }            public boolean add(String o) {                throw new UnsupportedOperationException();            }            public boolean remove(Object o) {                throw new UnsupportedOperationException();            }            public boolean containsAll(Collection<?> c) {                throw new UnsupportedOperationException();            }            public boolean addAll(Collection<? extends String> c) {                throw new UnsupportedOperationException();            }            public boolean removeAll(Collection<?> c) {                throw new UnsupportedOperationException();            }            public boolean retainAll(Collection<?> c) {                throw new UnsupportedOperationException();            }            public void clear() {                throw new UnsupportedOperationException();            }            public boolean equals(Object o) {                throw new UnsupportedOperationException();            }            public int hashCode() {                throw new UnsupportedOperationException();            }        }         /** Is this the name of a zip file? */        private static boolean isZip(String name) {            return new File(name).isFile();        }         private boolean expandJarClassPaths = false;         public Path expandJarClassPaths(boolean x) {            expandJarClassPaths = x;            return this;        }         /** What to use when path element is the empty string */        private String emptyPathDefault = null;         public Path emptyPathDefault(String x) {            emptyPathDefault = x;            return this;        }         public Path() { super(); }         public Path addDirectories(String dirs, boolean warn) {            if (dirs != null)                for (String dir : new PathIterator(dirs))                    addDirectory(dir, warn);            return this;        }         public Path addDirectories(String dirs) {            return addDirectories(dirs, warn);        }         private void addDirectory(String dir, boolean warn) {            if (! new File(dir).isDirectory()) {//              if (warn)//                  log.warning(Position.NOPOS,//                              "dir.path.element.not.found", dir);                return;            }             for (String direntry : new File(dir).list()) {                String canonicalized = direntry.toLowerCase();                if (canonicalized.endsWith(".jar") ||                    canonicalized.endsWith(".zip"))                    addFile(dir + File.separator + direntry, warn);            }        }         public Path addFiles(String files, boolean warn) {            if (files != null)                for (String file : new PathIterator(files, emptyPathDefault))                    addFile(file, warn);            return this;        }         public Path addFiles(String files) {            return addFiles(files, warn);        }         private void addFile(String file, boolean warn) {            if (contains(file)) {                /* Discard duplicates and avoid infinite recursion */                return;            }             File ele = new File(file);            if (! ele.exists()) {                /* No such file or directory exist */                if (warn)//                      log.warning(Position.NOPOS,//                          "path.element.not.found", file);                    return;            }             if (ele.isFile()) {                /* File is an ordinay file  */                String arcname = file.toLowerCase();                if (! (arcname.endsWith(".zip") ||                       arcname.endsWith(".jar"))) {                    /* File name don't have right extension *///                      if (warn)//                          log.warning(Position.NOPOS,//                              "invalid.archive.file", file);                    return;                }            }             /* Now what we have left is either a directory or a file name               confirming to archive naming convention */             super.add(file);            if (expandJarClassPaths && isZip(file))                addJarClassPath(file, warn);        }         // Adds referenced classpath elements from a jar's Class-Path        // Manifest entry.  In some future release, we may want to        // update this code to recognize URLs rather than simple        // filenames, but if we do, we should redo all path-related code.        private void addJarClassPath(String jarFileName, boolean warn) {            try {                String jarParent = new File(jarFileName).getParent();                JarFile jar = new JarFile(jarFileName);                 try {                    Manifest man = jar.getManifest();                    if (man == null) return;                     Attributes attr = man.getMainAttributes();                    if (attr == null) return;                     String path = attr.getValue(Attributes.Name.CLASS_PATH);                    if (path == null) return;                     for (StringTokenizer st = new StringTokenizer(path);                        st.hasMoreTokens();) {                        String elt = st.nextToken();                        if (jarParent != null)                            elt = new File(jarParent, elt).getCanonicalPath();                        addFile(elt, warn);                    }                } finally {                    jar.close();                }            } catch (IOException e) {//              log.error(Position.NOPOS,//                        "error.reading.file", jarFileName,//                        e.getLocalizedMessage());            }        }    }}