| /* |
| * 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.obfuscate; |
| |
| import java.io.*; |
| |
| |
| /** |
| * This class can parse mapping files and invoke a processor for each of the |
| * mapping entries. |
| * |
| * @author Eric Lafortune |
| */ |
| public class MappingReader |
| { |
| private final File mappingFile; |
| |
| |
| public MappingReader(File mappingFile) |
| { |
| this.mappingFile = mappingFile; |
| } |
| |
| |
| /** |
| * Reads the mapping file, presenting all of the encountered mapping entries |
| * to the given processor. |
| */ |
| public void pump(MappingProcessor mappingProcessor) throws IOException |
| { |
| LineNumberReader reader = new LineNumberReader( |
| new BufferedReader( |
| new FileReader(mappingFile))); |
| try |
| { |
| String className = null; |
| |
| // Read the subsequent class mappings and class member mappings. |
| while (true) |
| { |
| String line = reader.readLine(); |
| |
| if (line == null) |
| { |
| break; |
| } |
| |
| line = line.trim(); |
| |
| // The distinction between a class mapping and a class |
| // member mapping is the initial whitespace. |
| if (line.endsWith(":")) |
| { |
| // Process the class mapping and remember the class's |
| // old name. |
| className = processClassMapping(line, mappingProcessor); |
| } |
| else if (className != null) |
| { |
| // Process the class member mapping, in the context of the |
| // current old class name. |
| processClassMemberMapping(className, line, mappingProcessor); |
| } |
| } |
| } |
| catch (IOException ex) |
| { |
| throw new IOException("Can't process mapping file (" + ex.getMessage() + ")"); |
| } |
| finally |
| { |
| try |
| { |
| reader.close(); |
| } |
| catch (IOException ex) |
| { |
| // This shouldn't happen. |
| } |
| } |
| } |
| |
| |
| /** |
| * Parses the given line with a class mapping and processes the |
| * results with the given mapping processor. Returns the old class name, |
| * or null if any subsequent class member lines can be ignored. |
| */ |
| private String processClassMapping(String line, |
| MappingProcessor mappingProcessor) |
| { |
| // See if we can parse "___ -> ___:", containing the original |
| // class name and the new class name. |
| |
| int arrowIndex = line.indexOf("->"); |
| if (arrowIndex < 0) |
| { |
| return null; |
| } |
| |
| int colonIndex = line.indexOf(':', arrowIndex + 2); |
| if (colonIndex < 0) |
| { |
| return null; |
| } |
| |
| // Extract the elements. |
| String className = line.substring(0, arrowIndex).trim(); |
| String newClassName = line.substring(arrowIndex + 2, colonIndex).trim(); |
| |
| // Process this class name mapping. |
| boolean interested = mappingProcessor.processClassMapping(className, newClassName); |
| |
| return interested ? className : null; |
| } |
| |
| |
| /** |
| * Parses the given line with a class member mapping and processes the |
| * results with the given mapping processor. |
| */ |
| private void processClassMemberMapping(String className, |
| String line, |
| MappingProcessor mappingProcessor) |
| { |
| // See if we can parse "___:___:___ ___(___) -> ___", |
| // containing the optional line numbers, the return type, the original |
| // field/method name, optional arguments, and the new field/method name. |
| |
| int colonIndex1 = line.indexOf(':'); |
| int colonIndex2 = colonIndex1 < 0 ? -1 : line.indexOf(':', colonIndex1 + 1); |
| int spaceIndex = line.indexOf(' ', colonIndex2 + 2); |
| int argumentIndex1 = line.indexOf('(', spaceIndex + 1); |
| int argumentIndex2 = argumentIndex1 < 0 ? -1 : line.indexOf(')', argumentIndex1 + 1); |
| int arrowIndex = line.indexOf("->", Math.max(spaceIndex, argumentIndex2) + 1); |
| |
| if (spaceIndex < 0 || |
| arrowIndex < 0) |
| { |
| return; |
| } |
| |
| // Extract the elements. |
| String type = line.substring(colonIndex2 + 1, spaceIndex).trim(); |
| String name = line.substring(spaceIndex + 1, argumentIndex1 >= 0 ? argumentIndex1 : arrowIndex).trim(); |
| String newName = line.substring(arrowIndex + 2).trim(); |
| |
| // Process this class member mapping. |
| if (type.length() > 0 && |
| name.length() > 0 && |
| newName.length() > 0) |
| { |
| // Is it a field or a method? |
| if (argumentIndex2 < 0) |
| { |
| mappingProcessor.processFieldMapping(className, type, name, newName); |
| } |
| else |
| { |
| int firstLineNumber = 0; |
| int lastLineNumber = 0; |
| |
| if (colonIndex2 > 0) |
| { |
| firstLineNumber = Integer.parseInt(line.substring(0, colonIndex1).trim()); |
| lastLineNumber = Integer.parseInt(line.substring(colonIndex1 + 1, colonIndex2).trim()); |
| } |
| |
| String arguments = line.substring(argumentIndex1 + 1, argumentIndex2).trim(); |
| |
| mappingProcessor.processMethodMapping(className, |
| firstLineNumber, |
| lastLineNumber, |
| type, |
| name, |
| arguments, |
| newName); |
| } |
| } |
| } |
| } |