sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/WordReader.java

@@ -0,0 +1,387 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program 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 for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard;
+
+import java.io.*;
+
+
+/**
+ * An abstract reader of words, with the possibility to include other readers.
+ * Words are separated by spaces or broken off at delimiters. Words containing
+ * spaces or delimiters can be quoted with single or double quotes.
+ * Comments (everything starting with '#' on a single line) are ignored.
+ *
+ * @author Eric Lafortune
+ * @noinspection TailRecursion
+ */
+public abstract class WordReader
+{
+    private static final char COMMENT_CHARACTER = '#';
+
+
+    private File       baseDir;
+    private WordReader includeWordReader;
+    private String     currentLine;
+    private int        currentLineLength;
+    private int        currentIndex;
+    private String     currentWord;
+    private String     currentComments;
+
+
+    /**
+     * Creates a new WordReader with the given base directory.
+     */
+    protected WordReader(File baseDir)
+    {
+        this.baseDir = baseDir;
+    }
+
+
+    /**
+     * Sets the base directory of this reader.
+     */
+    public void setBaseDir(File baseDir)
+    {
+        if (includeWordReader != null)
+        {
+            includeWordReader.setBaseDir(baseDir);
+        }
+        else
+        {
+            this.baseDir = baseDir;
+        }
+    }
+
+
+    /**
+     * Returns the base directory of this reader, if any.
+     */
+    public File getBaseDir()
+    {
+        return includeWordReader != null ?
+            includeWordReader.getBaseDir() :
+            baseDir;
+    }
+
+
+    /**
+     * Specifies to start reading words from the given WordReader. When it is
+     * exhausted, this WordReader will continue to provide its own words.
+     *
+     * @param newIncludeWordReader the WordReader that will start reading words.
+     */
+    public void includeWordReader(WordReader newIncludeWordReader)
+    {
+        if (includeWordReader == null)
+        {
+            includeWordReader = newIncludeWordReader;
+        }
+        else
+        {
+            includeWordReader.includeWordReader(newIncludeWordReader);
+        }
+    }
+
+
+    /**
+     * Reads a word from this WordReader, or from one of its active included
+     * WordReader objects.
+     *
+     * @param isFileName return a complete line (or argument), if the word
+     *                      isn't an option (it doesn't start with '-').
+     * @return the read word.
+     */
+    public String nextWord(boolean isFileName) throws IOException
+    {
+        currentWord = null;
+
+        // See if we have an included reader to produce a word.
+        if (includeWordReader != null)
+        {
+            // Does the included word reader still produce a word?
+            currentWord = includeWordReader.nextWord(isFileName);
+            if (currentWord != null)
+            {
+                // Return it if so.
+                return currentWord;
+            }
+
+            // Otherwise close and ditch the word reader.
+            includeWordReader.close();
+            includeWordReader = null;
+        }
+
+        // Get a word from this reader.
+
+        // Skip any whitespace and comments left on the current line.
+        if (currentLine != null)
+        {
+            // Skip any leading whitespace.
+            while (currentIndex < currentLineLength &&
+                   Character.isWhitespace(currentLine.charAt(currentIndex)))
+            {
+                currentIndex++;
+            }
+
+            // Skip any comments.
+            if (currentIndex < currentLineLength &&
+                isComment(currentLine.charAt(currentIndex)))
+            {
+                currentIndex = currentLineLength;
+            }
+        }
+
+        // Make sure we have a non-blank line.
+        while (currentLine == null || currentIndex == currentLineLength)
+        {
+            currentLine = nextLine();
+            if (currentLine == null)
+            {
+                return null;
+            }
+
+            currentLineLength = currentLine.length();
+
+            // Skip any leading whitespace.
+            currentIndex = 0;
+            while (currentIndex < currentLineLength &&
+                   Character.isWhitespace(currentLine.charAt(currentIndex)))
+            {
+                currentIndex++;
+            }
+
+            // Remember any leading comments.
+            if (currentIndex < currentLineLength &&
+                isComment(currentLine.charAt(currentIndex)))
+            {
+                // Remember the comments.
+                String comment = currentLine.substring(currentIndex + 1);
+                currentComments = currentComments == null ?
+                    comment :
+                    currentComments + '\n' + comment;
+
+                // Skip the comments.
+                currentIndex = currentLineLength;
+            }
+        }
+
+        // Find the word starting at the current index.
+        int startIndex = currentIndex;
+        int endIndex;
+
+        char startChar = currentLine.charAt(startIndex);
+
+        if (isQuote(startChar))
+        {
+            // The next word is starting with a quote character.
+            // Skip the opening quote.
+            startIndex++;
+
+            // The next word is a quoted character string.
+            // Find the closing quote.
+            do
+            {
+                currentIndex++;
+
+                if (currentIndex == currentLineLength)
+                {
+                    currentWord = currentLine.substring(startIndex-1, currentIndex);
+                    throw new IOException("Missing closing quote for "+locationDescription());
+                }
+            }
+            while (currentLine.charAt(currentIndex) != startChar);
+
+            endIndex = currentIndex++;
+        }
+        else if (isFileName &&
+                 !isOption(startChar))
+        {
+            // The next word is a (possibly optional) file name.
+            // Find the end of the line, the first path separator, the first
+            // option, or the first comment.
+            while (currentIndex < currentLineLength)
+            {
+                char currentCharacter = currentLine.charAt(currentIndex);
+                if (isFileDelimiter(currentCharacter) ||
+                    (isOption(currentCharacter) ||
+                     isComment(currentCharacter)) &&
+                    Character.isWhitespace(currentLine.charAt(currentIndex-1))) {
+                    break;
+                }
+
+                currentIndex++;
+            }
+
+            endIndex = currentIndex;
+
+            // Trim any trailing whitespace.
+            while (endIndex > startIndex &&
+                   Character.isWhitespace(currentLine.charAt(endIndex-1)))
+            {
+                endIndex--;
+            }
+        }
+        else if (isDelimiter(startChar))
+        {
+            // The next word is a single delimiting character.
+            endIndex = ++currentIndex;
+        }
+        else
+        {
+            // The next word is a simple character string.
+            // Find the end of the line, the first delimiter, or the first
+            // white space.
+            while (currentIndex < currentLineLength)
+            {
+                char currentCharacter = currentLine.charAt(currentIndex);
+                if (isDelimiter(currentCharacter)            ||
+                    Character.isWhitespace(currentCharacter) ||
+                    isComment(currentCharacter)) {
+                    break;
+                }
+
+                currentIndex++;
+            }
+
+            endIndex = currentIndex;
+        }
+
+        // Remember and return the parsed word.
+        currentWord = currentLine.substring(startIndex, endIndex);
+
+        return currentWord;
+    }
+
+
+    /**
+     * Returns the comments collected before returning the last word.
+     * Starts collecting new comments.
+     *
+     * @return the collected comments, or <code>null</code> if there weren't any.
+     */
+    public String lastComments() throws IOException
+    {
+        if (includeWordReader == null)
+        {
+            String comments = currentComments;
+            currentComments = null;
+            return comments;
+        }
+        else
+        {
+            return includeWordReader.lastComments();
+        }
+    }
+
+
+    /**
+     * Constructs a readable description of the current position in this
+     * WordReader and its included WordReader objects.
+     *
+     * @return the description.
+     */
+    public String locationDescription()
+    {
+        return
+            (includeWordReader == null ?
+                (currentWord == null ?
+                    "end of " :
+                    "'" + currentWord + "' in " ) :
+                (includeWordReader.locationDescription() + ",\n" +
+                 "  included from ")) +
+            lineLocationDescription();
+    }
+
+
+    /**
+     * Reads a line from this WordReader, or from one of its active included
+     * WordReader objects.
+     *
+     * @return the read line.
+     */
+    protected abstract String nextLine() throws IOException;
+
+
+    /**
+     * Returns a readable description of the current WordReader position.
+     *
+     * @return the description.
+     */
+    protected abstract String lineLocationDescription();
+
+
+    /**
+     * Closes the FileWordReader.
+     */
+    public void close() throws IOException
+    {
+        // Close and ditch the included word reader, if any.
+        if (includeWordReader != null)
+        {
+            includeWordReader.close();
+            includeWordReader = null;
+        }
+    }
+
+
+    // Small utility methods.
+
+    private boolean isOption(char character)
+    {
+        return character == '-';
+    }
+
+
+    private boolean isComment(char character)
+    {
+        return character == COMMENT_CHARACTER;
+    }
+
+
+    private boolean isDelimiter(char character)
+    {
+        return character == '@' ||
+               character == '{' ||
+               character == '}' ||
+               character == '(' ||
+               character == ')' ||
+               character == ',' ||
+               character == ';' ||
+               character == File.pathSeparatorChar;
+    }
+
+
+    private boolean isFileDelimiter(char character)
+    {
+        return character == '(' ||
+               character == ')' ||
+               character == ',' ||
+               character == ';' ||
+               character == File.pathSeparatorChar;
+    }
+
+
+    private boolean isQuote(char character)
+    {
+        return character == '\'' ||
+               character == '"';
+    }
+}

data/lib/proguard4.7/src/proguard/ant/ClassPathElement.java

@@ -0,0 +1,191 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program 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 for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.ant;
+
+import org.apache.tools.ant.*;
+import org.apache.tools.ant.types.*;
+import proguard.*;
+import proguard.util.ListUtil;
+
+import java.io.File;
+
+/**
+ * This FileSet represents a class path entry (or a set of class path entries)
+ * in Ant.
+ *
+ * @author Eric Lafortune
+ */
+public class ClassPathElement extends Path
+{
+    private String filter;
+    private String jarFilter;
+    private String warFilter;
+    private String earFilter;
+    private String zipFilter;
+
+
+    /**
+     * @see Path#Path(Project)
+     */
+    public ClassPathElement(Project project)
+    {
+        super(project);
+    }
+
+
+    /**
+     * Adds the contents of this class path element to the given class path.
+     * @param classPath the class path to be extended.
+     * @param output    specifies whether this is an output entry or not.
+     */
+    public void appendClassPathEntriesTo(ClassPath classPath, boolean output)
+    {
+        File     baseDir = getProject().getBaseDir();
+        String[] fileNames;
+
+        if (isReference())
+        {
+            // Get the referenced path or file set.
+            Object referencedObject = getCheckedRef(DataType.class,
+                                                    DataType.class.getName());
+
+            if (referencedObject instanceof Path)
+            {
+                Path path = (Path)referencedObject;
+
+                // Get the names of the files in the referenced path.
+                fileNames = path.list();
+            }
+            else if (referencedObject instanceof AbstractFileSet)
+            {
+                AbstractFileSet fileSet = (AbstractFileSet)referencedObject;
+
+                // Get the names of the existing input files in the referenced file set.
+                DirectoryScanner scanner = fileSet.getDirectoryScanner(getProject());
+                baseDir   = scanner.getBasedir();
+                fileNames = scanner.getIncludedFiles();
+            }
+            else
+            {
+                throw new BuildException("The refid attribute doesn't point to a <path> element or a <fileset> element");
+            }
+        }
+        else
+        {
+            // Get the names of the files in this path.
+            fileNames = list();
+        }
+
+        if (output)
+        {
+            if (fileNames.length != 1)
+            {
+                throw new BuildException("The <outjar> element must specify exactly one file or directory ["+fileNames.length+"]");
+            }
+        }
+        //else
+        //{
+        //    if (fileNames.length < 1)
+        //    {
+        //        throw new BuildException("The <injar> element must specify at least one file or directory");
+        //    }
+        //}
+
+        for (int index = 0; index < fileNames.length; index++)
+        {
+            // Create a new class path entry, with the proper file name and
+            // any filters.
+            String fileName = fileNames[index];
+            File   file     = new File(fileName);
+
+            ClassPathEntry entry =
+                new ClassPathEntry(file.isAbsolute() ? file : new File(baseDir, fileName),
+                                   output);
+            entry.setFilter(ListUtil.commaSeparatedList(filter));
+            entry.setJarFilter(ListUtil.commaSeparatedList(jarFilter));
+            entry.setWarFilter(ListUtil.commaSeparatedList(warFilter));
+            entry.setEarFilter(ListUtil.commaSeparatedList(earFilter));
+            entry.setZipFilter(ListUtil.commaSeparatedList(zipFilter));
+
+            // Add it to the class path.
+            classPath.add(entry);
+        }
+    }
+
+
+    // Ant task attributes.
+
+    /**
+     * @deprecated Use {@link #setLocation(File)} instead.
+     */
+    public void setFile(File file)
+    {
+        setLocation(file);
+    }
+
+
+    /**
+     * @deprecated Use {@link #setLocation(File)} instead.
+     */
+    public void setDir(File file)
+    {
+        setLocation(file);
+    }
+
+
+    /**
+     * @deprecated Use {@link #setLocation(File)} instead.
+     */
+    public void setName(File file)
+    {
+        setLocation(file);
+    }
+
+
+    public void setFilter(String filter)
+    {
+        this.filter = filter;
+    }
+
+
+    public void setJarfilter(String jarFilter)
+    {
+        this.jarFilter = jarFilter;
+    }
+
+
+    public void setWarfilter(String warFilter)
+    {
+        this.warFilter = warFilter;
+    }
+
+
+    public void setEarfilter(String earFilter)
+    {
+        this.earFilter = earFilter;
+    }
+
+
+    public void setZipfilter(String zipFilter)
+    {
+        this.zipFilter = zipFilter;
+    }
+}