sometsome 3.10.46 → 3.10.50.33

data/lib/proguard4.7/src/proguard/preverify/SubroutineInliner.java

@@ -1,73 +0,0 @@
-/*
- * 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.preverify;
-
-import proguard.Configuration;
-import proguard.classfile.*;
-import proguard.classfile.attribute.visitor.AllAttributeVisitor;
-import proguard.classfile.visitor.*;
-
-/**
- * This class can inline subroutines in methods. This is generally useful (i.e.
- * required) for preverifying code.
- *
- * @author Eric Lafortune
- */
-public class SubroutineInliner
-{
-    private final Configuration configuration;
-
-
-    /**
-     * Creates a new SubroutineInliner.
-     */
-    public SubroutineInliner(Configuration configuration)
-    {
-        this.configuration = configuration;
-    }
-
-
-    /**
-     * Performs subroutine inlining of the given program class pool.
-     */
-    public void execute(ClassPool programClassPool)
-    {
-        // Clean up any old visitor info.
-        programClassPool.classesAccept(new ClassCleaner());
-
-        // Inline all subroutines.
-        ClassVisitor inliner =
-            new AllMethodVisitor(
-            new AllAttributeVisitor(
-            new CodeSubroutineInliner()));
-
-        // In Java Standard Edition, only class files from Java 6 or higher
-        // should be preverified.
-        if (!configuration.microEdition)
-        {
-            inliner =
-                new ClassVersionFilter(ClassConstants.INTERNAL_CLASS_VERSION_1_6,
-                                       inliner);
-        }
-
-        programClassPool.classesAccept(inliner);
-    }
-}

data/lib/proguard4.7/src/proguard/retrace/MANIFEST.MF

@@ -1,3 +0,0 @@
-Manifest-Version: 1.0
-Main-Class: proguard.retrace.ReTrace
-Class-Path: proguard.jar

data/lib/proguard4.7/src/proguard/retrace/ReTrace.java

@@ -1,749 +0,0 @@
-/*
- * 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.retrace;
-
-import proguard.classfile.util.ClassUtil;
-import proguard.obfuscate.*;
-
-import java.io.*;
-import java.util.*;
-import java.util.regex.*;
-
-
-/**
- * Tool for de-obfuscating stack traces of applications that were obfuscated
- * with ProGuard.
- *
- * @author Eric Lafortune
- */
-public class ReTrace
-implements   MappingProcessor
-{
-    private static final String REGEX_OPTION   = "-regex";
-    private static final String VERBOSE_OPTION = "-verbose";
-
-
-    public static final String STACK_TRACE_EXPRESSION = "(?:\\s*%c:.*)|(?:\\s*at\\s+%c.%m\\s*\\(.*?(?::%l)?\\)\\s*)";
-
-    private static final String REGEX_CLASS       = "\\b(?:[A-Za-z0-9_$]+\\.)*[A-Za-z0-9_$]+\\b";
-    private static final String REGEX_CLASS_SLASH = "\\b(?:[A-Za-z0-9_$]+/)*[A-Za-z0-9_$]+\\b";
-    private static final String REGEX_LINE_NUMBER = "\\b[0-9]+\\b";
-    private static final String REGEX_TYPE        = REGEX_CLASS + "(?:\\[\\])*";
-    private static final String REGEX_MEMBER      = "<?\\b[A-Za-z0-9_$]+\\b>?";
-    private static final String REGEX_ARGUMENTS   = "(?:" + REGEX_TYPE + "(?:\\s*,\\s*" + REGEX_TYPE + ")*)?";
-
-    // The class settings.
-    private final String  regularExpression;
-    private final boolean verbose;
-    private final File    mappingFile;
-    private final File    stackTraceFile;
-
-    private Map classMap       = new HashMap();
-    private Map classFieldMap  = new HashMap();
-    private Map classMethodMap = new HashMap();
-
-
-    /**
-     * Creates a new ReTrace object to process stack traces on the standard
-     * input, based on the given mapping file name.
-     * @param regularExpression the regular expression for parsing the lines in
-     *                          the stack trace.
-     * @param verbose           specifies whether the de-obfuscated stack trace
-     *                          should be verbose.
-     * @param mappingFile       the mapping file that was written out by
-     *                          ProGuard.
-     */
-    public ReTrace(String  regularExpression,
-                   boolean verbose,
-                   File    mappingFile)
-    {
-        this(regularExpression, verbose, mappingFile, null);
-    }
-
-
-    /**
-     * Creates a new ReTrace object to process a stack trace from the given file,
-     * based on the given mapping file name.
-     * @param regularExpression the regular expression for parsing the lines in
-     *                          the stack trace.
-     * @param verbose           specifies whether the de-obfuscated stack trace
-     *                          should be verbose.
-     * @param mappingFile       the mapping file that was written out by
-     *                          ProGuard.
-     * @param stackTraceFile    the optional name of the file that contains the
-     *                          stack trace.
-     */
-    public ReTrace(String  regularExpression,
-                   boolean verbose,
-                   File    mappingFile,
-                   File    stackTraceFile)
-    {
-        this.regularExpression = regularExpression;
-        this.verbose           = verbose;
-        this.mappingFile       = mappingFile;
-        this.stackTraceFile    = stackTraceFile;
-    }
-
-
-    /**
-     * Performs the subsequent ReTrace operations.
-     */
-    public void execute() throws IOException
-    {
-        // Read the mapping file.
-        MappingReader mappingReader = new MappingReader(mappingFile);
-        mappingReader.pump(this);
-
-
-        StringBuffer expressionBuffer    = new StringBuffer(regularExpression.length() + 32);
-        char[]       expressionTypes     = new char[32];
-        int          expressionTypeCount = 0;
-        int index = 0;
-        while (true)
-        {
-            int nextIndex = regularExpression.indexOf('%', index);
-            if (nextIndex < 0                             ||
-                nextIndex == regularExpression.length()-1 ||
-                expressionTypeCount == expressionTypes.length)
-            {
-                break;
-            }
-
-            expressionBuffer.append(regularExpression.substring(index, nextIndex));
-            expressionBuffer.append('(');
-
-            char expressionType = regularExpression.charAt(nextIndex + 1);
-            switch(expressionType)
-            {
-                case 'c':
-                    expressionBuffer.append(REGEX_CLASS);
-                    break;
-
-                case 'C':
-                    expressionBuffer.append(REGEX_CLASS_SLASH);
-                    break;
-
-                case 'l':
-                    expressionBuffer.append(REGEX_LINE_NUMBER);
-                    break;
-
-                case 't':
-                    expressionBuffer.append(REGEX_TYPE);
-                    break;
-
-                case 'f':
-                    expressionBuffer.append(REGEX_MEMBER);
-                    break;
-
-                case 'm':
-                    expressionBuffer.append(REGEX_MEMBER);
-                    break;
-
-                case 'a':
-                    expressionBuffer.append(REGEX_ARGUMENTS);
-                    break;
-            }
-
-            expressionBuffer.append(')');
-
-            expressionTypes[expressionTypeCount++] = expressionType;
-
-            index = nextIndex + 2;
-        }
-
-        expressionBuffer.append(regularExpression.substring(index));
-
-        Pattern pattern = Pattern.compile(expressionBuffer.toString());
-
-        // Read the stack trace file.
-        LineNumberReader reader =
-            new LineNumberReader(stackTraceFile == null ?
-                (Reader)new InputStreamReader(System.in) :
-                (Reader)new BufferedReader(new FileReader(stackTraceFile)));
-
-
-        try
-        {
-            StringBuffer outLine = new StringBuffer(256);
-            List         extraOutLines  = new ArrayList();
-
-            String className = null;
-
-            // Read the line in the stack trace.
-            while (true)
-            {
-                String line = reader.readLine();
-                if (line == null)
-                {
-                    break;
-                }
-
-                Matcher matcher = pattern.matcher(line);
-
-                if (matcher.matches())
-                {
-                    int    lineNumber = 0;
-                    String type       = null;
-                    String arguments  = null;
-
-                    // Figure out a class name, line number, type, and
-                    // arguments beforehand.
-                    for (int expressionTypeIndex = 0; expressionTypeIndex < expressionTypeCount; expressionTypeIndex++)
-                    {
-                        int startIndex = matcher.start(expressionTypeIndex + 1);
-                        if (startIndex >= 0)
-                        {
-                            String match = matcher.group(expressionTypeIndex + 1);
-
-                            char expressionType = expressionTypes[expressionTypeIndex];
-                            switch (expressionType)
-                            {
-                                case 'c':
-                                    className = originalClassName(match);
-                                    break;
-
-                                case 'C':
-                                    className = originalClassName(ClassUtil.externalClassName(match));
-                                    break;
-
-                                case 'l':
-                                    lineNumber = Integer.parseInt(match);
-                                    break;
-
-                                case 't':
-                                    type = originalType(match);
-                                    break;
-
-                                case 'a':
-                                    arguments = originalArguments(match);
-                                    break;
-                            }
-                        }
-                    }
-
-                    // Actually construct the output line.
-                    int lineIndex = 0;
-
-                    outLine.setLength(0);
-                    extraOutLines.clear();
-
-                    for (int expressionTypeIndex = 0; expressionTypeIndex < expressionTypeCount; expressionTypeIndex++)
-                    {
-                        int startIndex = matcher.start(expressionTypeIndex + 1);
-                        if (startIndex >= 0)
-                        {
-                            int    endIndex = matcher.end(expressionTypeIndex + 1);
-                            String match    = matcher.group(expressionTypeIndex + 1);
-
-                            // Copy a literal piece of input line.
-                            outLine.append(line.substring(lineIndex, startIndex));
-
-                            char expressionType = expressionTypes[expressionTypeIndex];
-                            switch (expressionType)
-                            {
-                                case 'c':
-                                    className = originalClassName(match);
-                                    outLine.append(className);
-                                    break;
-
-                                case 'C':
-                                    className = originalClassName(ClassUtil.externalClassName(match));
-                                    outLine.append(ClassUtil.internalClassName(className));
-                                    break;
-
-                                case 'l':
-                                    lineNumber = Integer.parseInt(match);
-                                    outLine.append(match);
-                                    break;
-
-                                case 't':
-                                    type = originalType(match);
-                                    outLine.append(type);
-                                    break;
-
-                                case 'f':
-                                    originalFieldName(className,
-                                                      match,
-                                                      type,
-                                                      outLine,
-                                                      extraOutLines);
-                                    break;
-
-                                case 'm':
-                                    originalMethodName(className,
-                                                       match,
-                                                       lineNumber,
-                                                       type,
-                                                       arguments,
-                                                       outLine,
-                                                       extraOutLines);
-                                    break;
-
-                                case 'a':
-                                    arguments = originalArguments(match);
-                                    outLine.append(arguments);
-                                    break;
-                            }
-
-                            // Skip the original element whose processed version
-                            // has just been appended.
-                            lineIndex = endIndex;
-                        }
-                    }
-
-                    // Copy the last literal piece of input line.
-                    outLine.append(line.substring(lineIndex));
-
-                    // Print out the main line.
-                    System.out.println(outLine);
-
-                    // Print out any additional lines.
-                    for (int extraLineIndex = 0; extraLineIndex < extraOutLines.size(); extraLineIndex++)
-                    {
-                        System.out.println(extraOutLines.get(extraLineIndex));
-                    }
-                }
-                else
-                {
-                    // Print out the original line.
-                    System.out.println(line);
-                }
-            }
-        }
-        catch (IOException ex)
-        {
-            throw new IOException("Can't read stack trace (" + ex.getMessage() + ")");
-        }
-        finally
-        {
-            if (stackTraceFile != null)
-            {
-                try
-                {
-                    reader.close();
-                }
-                catch (IOException ex)
-                {
-                    // This shouldn't happen.
-                }
-            }
-        }
-    }
-
-
-    /**
-     * Finds the original field name(s), appending the first one to the out
-     * line, and any additional alternatives to the extra lines.
-     */
-    private void originalFieldName(String       className,
-                                   String       obfuscatedFieldName,
-                                   String       type,
-                                   StringBuffer outLine,
-                                   List         extraOutLines)
-    {
-        int extraIndent = -1;
-
-        // Class name -> obfuscated field names.
-        Map fieldMap = (Map)classFieldMap.get(className);
-        if (fieldMap != null)
-        {
-            // Obfuscated field names -> fields.
-            Set fieldSet = (Set)fieldMap.get(obfuscatedFieldName);
-            if (fieldSet != null)
-            {
-                // Find all matching fields.
-                Iterator fieldInfoIterator = fieldSet.iterator();
-                while (fieldInfoIterator.hasNext())
-                {
-                    FieldInfo fieldInfo = (FieldInfo)fieldInfoIterator.next();
-                    if (fieldInfo.matches(type))
-                    {
-                        // Is this the first matching field?
-                        if (extraIndent < 0)
-                        {
-                            extraIndent = outLine.length();
-
-                            // Append the first original name.
-                            if (verbose)
-                            {
-                                outLine.append(fieldInfo.type).append(' ');
-                            }
-                            outLine.append(fieldInfo.originalName);
-                        }
-                        else
-                        {
-                            // Create an additional line with the proper
-                            // indentation.
-                            StringBuffer extraBuffer = new StringBuffer();
-                            for (int counter = 0; counter < extraIndent; counter++)
-                            {
-                                extraBuffer.append(' ');
-                            }
-
-                            // Append the alternative name.
-                            if (verbose)
-                            {
-                                extraBuffer.append(fieldInfo.type).append(' ');
-                            }
-                            extraBuffer.append(fieldInfo.originalName);
-
-                            // Store the additional line.
-                            extraOutLines.add(extraBuffer);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Just append the obfuscated name if we haven't found any matching
-        // fields.
-        if (extraIndent < 0)
-        {
-            outLine.append(obfuscatedFieldName);
-        }
-    }
-
-
-    /**
-     * Finds the original method name(s), appending the first one to the out
-     * line, and any additional alternatives to the extra lines.
-     */
-    private void originalMethodName(String       className,
-                                    String       obfuscatedMethodName,
-                                    int          lineNumber,
-                                    String       type,
-                                    String       arguments,
-                                    StringBuffer outLine,
-                                    List         extraOutLines)
-    {
-        int extraIndent = -1;
-
-        // Class name -> obfuscated method names.
-        Map methodMap = (Map)classMethodMap.get(className);
-        if (methodMap != null)
-        {
-            // Obfuscated method names -> methods.
-            Set methodSet = (Set)methodMap.get(obfuscatedMethodName);
-            if (methodSet != null)
-            {
-                // Find all matching methods.
-                Iterator methodInfoIterator = methodSet.iterator();
-                while (methodInfoIterator.hasNext())
-                {
-                    MethodInfo methodInfo = (MethodInfo)methodInfoIterator.next();
-                    if (methodInfo.matches(lineNumber, type, arguments))
-                    {
-                        // Is this the first matching method?
-                        if (extraIndent < 0)
-                        {
-                            extraIndent = outLine.length();
-
-                            // Append the first original name.
-                            if (verbose)
-                            {
-                                outLine.append(methodInfo.type).append(' ');
-                            }
-                            outLine.append(methodInfo.originalName);
-                            if (verbose)
-                            {
-                                outLine.append('(').append(methodInfo.arguments).append(')');
-                            }
-                        }
-                        else
-                        {
-                            // Create an additional line with the proper
-                            // indentation.
-                            StringBuffer extraBuffer = new StringBuffer();
-                            for (int counter = 0; counter < extraIndent; counter++)
-                            {
-                                extraBuffer.append(' ');
-                            }
-
-                            // Append the alternative name.
-                            if (verbose)
-                            {
-                                extraBuffer.append(methodInfo.type).append(' ');
-                            }
-                            extraBuffer.append(methodInfo.originalName);
-                            if (verbose)
-                            {
-                                extraBuffer.append('(').append(methodInfo.arguments).append(')');
-                            }
-
-                            // Store the additional line.
-                            extraOutLines.add(extraBuffer);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Just append the obfuscated name if we haven't found any matching
-        // methods.
-        if (extraIndent < 0)
-        {
-            outLine.append(obfuscatedMethodName);
-        }
-    }
-
-
-    /**
-     * Returns the original argument types.
-     */
-    private String originalArguments(String obfuscatedArguments)
-    {
-        StringBuffer originalArguments = new StringBuffer();
-
-        int startIndex = 0;
-        while (true)
-        {
-            int endIndex = obfuscatedArguments.indexOf(',', startIndex);
-            if (endIndex < 0)
-            {
-                break;
-            }
-
-            originalArguments.append(originalType(obfuscatedArguments.substring(startIndex, endIndex).trim())).append(',');
-
-            startIndex = endIndex + 1;
-        }
-
-        originalArguments.append(originalType(obfuscatedArguments.substring(startIndex).trim()));
-
-        return originalArguments.toString();
-    }
-
-
-    /**
-     * Returns the original type.
-     */
-    private String originalType(String obfuscatedType)
-    {
-        int index = obfuscatedType.indexOf('[');
-
-        return index >= 0 ?
-            originalClassName(obfuscatedType.substring(0, index)) + obfuscatedType.substring(index) :
-            originalClassName(obfuscatedType);
-    }
-
-
-    /**
-     * Returns the original class name.
-     */
-    private String originalClassName(String obfuscatedClassName)
-    {
-        String originalClassName = (String)classMap.get(obfuscatedClassName);
-
-        return originalClassName != null ?
-            originalClassName :
-            obfuscatedClassName;
-    }
-
-
-    // Implementations for MappingProcessor.
-
-    public boolean processClassMapping(String className, String newClassName)
-    {
-        // Obfuscated class name -> original class name.
-        classMap.put(newClassName, className);
-
-        return true;
-    }
-
-
-    public void processFieldMapping(String className, String fieldType, String fieldName, String newFieldName)
-    {
-        // Original class name -> obfuscated field names.
-        Map fieldMap = (Map)classFieldMap.get(className);
-        if (fieldMap == null)
-        {
-            fieldMap = new HashMap();
-            classFieldMap.put(className, fieldMap);
-        }
-
-        // Obfuscated field name -> fields.
-        Set fieldSet = (Set)fieldMap.get(newFieldName);
-        if (fieldSet == null)
-        {
-            fieldSet = new LinkedHashSet();
-            fieldMap.put(newFieldName, fieldSet);
-        }
-
-        // Add the field information.
-        fieldSet.add(new FieldInfo(fieldType,
-                                   fieldName));
-    }
-
-
-    public void processMethodMapping(String className, int firstLineNumber, int lastLineNumber, String methodReturnType, String methodName, String methodArguments, String newMethodName)
-    {
-        // Original class name -> obfuscated method names.
-        Map methodMap = (Map)classMethodMap.get(className);
-        if (methodMap == null)
-        {
-            methodMap = new HashMap();
-            classMethodMap.put(className, methodMap);
-        }
-
-        // Obfuscated method name -> methods.
-        Set methodSet = (Set)methodMap.get(newMethodName);
-        if (methodSet == null)
-        {
-            methodSet = new LinkedHashSet();
-            methodMap.put(newMethodName, methodSet);
-        }
-
-        // Add the method information.
-        methodSet.add(new MethodInfo(firstLineNumber,
-                                     lastLineNumber,
-                                     methodReturnType,
-                                     methodArguments,
-                                     methodName));
-    }
-
-
-    /**
-     * A field record.
-     */
-    private static class FieldInfo
-    {
-        private String type;
-        private String originalName;
-
-
-        private FieldInfo(String type, String originalName)
-        {
-            this.type         = type;
-            this.originalName = originalName;
-        }
-
-
-        private boolean matches(String type)
-        {
-            return
-                type == null || type.equals(this.type);
-        }
-    }
-
-
-    /**
-     * A method record.
-     */
-    private static class MethodInfo
-    {
-        private int    firstLineNumber;
-        private int    lastLineNumber;
-        private String type;
-        private String arguments;
-        private String originalName;
-
-
-        private MethodInfo(int firstLineNumber, int lastLineNumber, String type, String arguments, String originalName)
-        {
-            this.firstLineNumber = firstLineNumber;
-            this.lastLineNumber  = lastLineNumber;
-            this.type            = type;
-            this.arguments       = arguments;
-            this.originalName    = originalName;
-        }
-
-
-        private boolean matches(int lineNumber, String type, String arguments)
-        {
-            return
-                (lineNumber == 0    || (firstLineNumber <= lineNumber && lineNumber <= lastLineNumber) || lastLineNumber == 0) &&
-                (type       == null || type.equals(this.type))                                                                 &&
-                (arguments  == null || arguments.equals(this.arguments));
-        }
-    }
-
-
-    /**
-     * The main program for ReTrace.
-     */
-    public static void main(String[] args)
-    {
-        if (args.length < 1)
-        {
-            System.err.println("Usage: java proguard.ReTrace [-verbose] <mapping_file> [<stacktrace_file>]");
-            System.exit(-1);
-        }
-
-        String  regularExpresssion = STACK_TRACE_EXPRESSION;
-        boolean verbose            = false;
-
-        int argumentIndex = 0;
-        while (argumentIndex < args.length)
-        {
-            String arg = args[argumentIndex];
-            if (arg.equals(REGEX_OPTION))
-            {
-                regularExpresssion = args[++argumentIndex];
-            }
-            else if (arg.equals(VERBOSE_OPTION))
-            {
-                verbose = true;
-            }
-            else
-            {
-                break;
-            }
-
-            argumentIndex++;
-        }
-
-        if (argumentIndex >= args.length)
-        {
-            System.err.println("Usage: java proguard.ReTrace [-regex <regex>] [-verbose] <mapping_file> [<stacktrace_file>]");
-            System.exit(-1);
-        }
-
-        File mappingFile    = new File(args[argumentIndex++]);
-        File stackTraceFile = argumentIndex < args.length ?
-            new File(args[argumentIndex]) :
-            null;
-
-        ReTrace reTrace = new ReTrace(regularExpresssion, verbose, mappingFile, stackTraceFile);
-
-        try
-        {
-            // Execute ReTrace with its given settings.
-            reTrace.execute();
-        }
-        catch (IOException ex)
-        {
-            if (verbose)
-            {
-                // Print a verbose stack trace.
-                ex.printStackTrace();
-            }
-            else
-            {
-                // Print just the stack trace message.
-                System.err.println("Error: "+ex.getMessage());
-            }
-
-            System.exit(1);
-        }
-
-        System.exit(0);
-    }
-}