moparisthebest/fernflower
1
0
Fork 0
mirror of https://github.com/moparisthebest/fernflower synced 2024-11-25 18:52:17 -05:00
Code Issues Releases Wiki Activity

Cleanup (formatting; typos)

Browse Source
This commit is contained in:
Roman Shevchenko 2014-10-17 18:19:39 +02:00
parent 9b97ae55f8
commit 2d36ea60eb
2 changed files with 61 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/org/jetbrains/java/decompiler/main/collectors/BytecodeSourceMapper.java
View File

@ -1,83 +1,99 @@
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.java.decompiler.main.collectors; package org.jetbrains.java.decompiler.main.collectors;
import java.util.*;
import java.util.Map.Entry;
import org.jetbrains.java.decompiler.main.DecompilerContext; import org.jetbrains.java.decompiler.main.DecompilerContext;
import org.jetbrains.java.decompiler.main.TextBuffer; import org.jetbrains.java.decompiler.main.TextBuffer;
import java.util.*;
import java.util.Map.Entry;
public class BytecodeSourceMapper { public class BytecodeSourceMapper {
private int offset_total; private int offset_total;
private final HashMap<Integer, Integer> myOriginalLinesMapping = new HashMap<Integer, Integer>();
// class, method, bytecode offset, source line // class, method, bytecode offset, source line
private final HashMap<String, HashMap<String, HashMap<Integer, Integer>>> mapping = new LinkedHashMap<String, HashMap<String, HashMap<Integer, Integer>>>(); // need to preserve order private final Map<String, Map<String, Map<Integer, Integer>>> mapping = new LinkedHashMap<String, Map<String, Map<Integer, Integer>>>();
public void addMapping(String classname, String methodname, int bytecode_offset, int source_line) { // original line to decompiled line
private final Map<Integer, Integer> linesMapping = new LinkedHashMap<Integer, Integer>();
HashMap<String, HashMap<Integer, Integer>> class_mapping = mapping.get(classname); public void addMapping(String className, String methodName, int bytecodeOffset, int sourceLine) {
if(class_mapping == null) { Map<String, Map<Integer, Integer>> class_mapping = mapping.get(className);
mapping.put(classname, class_mapping = new LinkedHashMap<String, HashMap<Integer, Integer>>()); // need to preserve order if (class_mapping == null) {
mapping.put(className, class_mapping = new LinkedHashMap<String, Map<Integer, Integer>>()); // need to preserve order
} }
HashMap<Integer, Integer> method_mapping = class_mapping.get(methodname); Map<Integer, Integer> method_mapping = class_mapping.get(methodName);
if(method_mapping == null) { if (method_mapping == null) {
class_mapping.put(methodname, method_mapping = new HashMap<Integer, Integer>()); class_mapping.put(methodName, method_mapping = new HashMap<Integer, Integer>());
} }
// don't overwrite // don't overwrite
if(!method_mapping.containsKey(bytecode_offset)) { if (!method_mapping.containsKey(bytecodeOffset)) {
method_mapping.put(bytecode_offset, source_line); method_mapping.put(bytecodeOffset, sourceLine);
} }
} }
public void addTracer(String classname, String methodname, BytecodeMappingTracer tracer) { public void addTracer(String className, String methodName, BytecodeMappingTracer tracer) {
for(Entry<Integer, Integer> entry : tracer.getMapping().entrySet()) { for (Entry<Integer, Integer> entry : tracer.getMapping().entrySet()) {
addMapping(classname, methodname, entry.getKey(), entry.getValue()); addMapping(className, methodName, entry.getKey(), entry.getValue());
} }
myOriginalLinesMapping.putAll(tracer.getOriginalLinesMapping()); linesMapping.putAll(tracer.getOriginalLinesMapping());
} }
public void dumpMapping(TextBuffer buffer, boolean offsetsToHex) { public void dumpMapping(TextBuffer buffer, boolean offsetsToHex) {
String lineSeparator = DecompilerContext.getNewLineSeparator(); String lineSeparator = DecompilerContext.getNewLineSeparator();
for(Entry<String, HashMap<String, HashMap<Integer, Integer>>> class_entry : mapping.entrySet()) { for (Entry<String, Map<String, Map<Integer, Integer>>> class_entry : mapping.entrySet()) {
HashMap<String, HashMap<Integer, Integer>> class_mapping = class_entry.getValue(); Map<String, Map<Integer, Integer>> class_mapping = class_entry.getValue();
buffer.append("class " + class_entry.getKey() + "{" + lineSeparator); buffer.append("class '" + class_entry.getKey() + "' {" + lineSeparator);
boolean is_first_method = true; boolean is_first_method = true;
for (Entry<String, Map<Integer, Integer>> method_entry : class_mapping.entrySet()) {
Map<Integer, Integer> method_mapping = method_entry.getValue();
for(Entry<String, HashMap<Integer, Integer>> method_entry : class_mapping.entrySet()) { if (!is_first_method) {
HashMap<Integer, Integer> method_mapping = method_entry.getValue();
if(!is_first_method) {
buffer.appendLineSeparator(); buffer.appendLineSeparator();
} }
buffer.appendIndent(1).append("method " + method_entry.getKey() + "{" + lineSeparator);
buffer.appendIndent(1).append("method '" + method_entry.getKey() + "' {" + lineSeparator);
List<Integer> lstBytecodeOffsets = new ArrayList<Integer>(method_mapping.keySet()); List<Integer> lstBytecodeOffsets = new ArrayList<Integer>(method_mapping.keySet());
Collections.sort(lstBytecodeOffsets); Collections.sort(lstBytecodeOffsets);
for(Integer offset : lstBytecodeOffsets) { for (Integer offset : lstBytecodeOffsets) {
Integer line = method_mapping.get(offset); Integer line = method_mapping.get(offset);
String strOffset = offsetsToHex ? Integer.toHexString(offset): line.toString(); String strOffset = offsetsToHex ? Integer.toHexString(offset) : line.toString();
buffer.appendIndent(2).append(strOffset).appendIndent(2).append((line + offset_total) + lineSeparator); buffer.appendIndent(2).append(strOffset).appendIndent(2).append((line + offset_total) + lineSeparator);
} }
buffer.appendIndent(1).append("}").appendLineSeparator(); buffer.appendIndent(1).append("}").appendLineSeparator();
is_first_method = false; is_first_method = false;
} }
buffer.append("}").appendLineSeparator();
buffer.append("}").appendLineSeparator().appendLineSeparator();
} }
// lines mapping // lines mapping
buffer.append("Lines mapping:").appendLineSeparator(); buffer.append("Lines mapping:").appendLineSeparator();
int[] mapping = getOriginalLinesMapping(); int[] mapping = getOriginalLinesMapping();
for (int i = 0; i < mapping.length; i+=2) { for (int i = 0; i < mapping.length; i += 2) {
buffer.append(mapping[i]).append(" <-> ").append(mapping[i+1]).appendLineSeparator(); buffer.append(mapping[i]).append(" <-> ").append(mapping[i + 1]).appendLineSeparator();
} }
} }
@ -94,15 +110,15 @@ public class BytecodeSourceMapper {
} }
/** /**
* original to our line mapping * Original to decompiled line mapping.
*/ */
public int[] getOriginalLinesMapping() { public int[] getOriginalLinesMapping() {
int[] res = new int[myOriginalLinesMapping.size()*2]; int[] res = new int[linesMapping.size() * 2];
int i = 0; int i = 0;
for (Entry<Integer, Integer> entry : myOriginalLinesMapping.entrySet()) { for (Entry<Integer, Integer> entry : linesMapping.entrySet()) {
res[i] = entry.getKey(); res[i] = entry.getKey();
res[i+1] = entry.getValue() + offset_total + 1; // make it 1 based res[i + 1] = entry.getValue() + offset_total + 1; // make it 1 based
i+=2; i += 2;
} }
return res; return res;
} }

12
testData/results/TestClassSimpleBytecodeMapping.dec
View File

@ -22,15 +22,16 @@ public class TestClassSimpleBytecodeMapping {
} }
} }
class pkg/TestClassSimpleBytecodeMapping$1{ class 'pkg/TestClassSimpleBytecodeMapping$1' {
method run ()V{ method 'run ()V' {
0 7 0 7
3 7 3 7
5 7 5 7
} }
} }
class pkg/TestClassSimpleBytecodeMapping{
method test ()I{ class 'pkg/TestClassSimpleBytecodeMapping' {
method 'test ()I' {
0 4 0 4
3 4 3 4
5 4 5 4
@ -51,10 +52,11 @@ class pkg/TestClassSimpleBytecodeMapping{
2f 15 2f 15
} }
method run (Ljava/lang/Runnable;)V{ method 'run (Ljava/lang/Runnable;)V' {
1 20 1 20
} }
} }
Lines mapping: Lines mapping:
17 <-> 8 17 <-> 8
21 <-> 11 21 <-> 11