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

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

@ -1,62 +1,76 @@
/*
* 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;
import java.util.*;
import java.util.Map.Entry;
import org.jetbrains.java.decompiler.main.DecompilerContext;
import org.jetbrains.java.decompiler.main.TextBuffer;
import java.util.*;
import java.util.Map.Entry;
public class BytecodeSourceMapper {
private int offset_total;
private final HashMap<Integer, Integer> myOriginalLinesMapping = new HashMap<Integer, Integer>();
// 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) {
Map<String, Map<Integer, Integer>> class_mapping = mapping.get(className);
if (class_mapping == null) {
mapping.put(classname, class_mapping = new LinkedHashMap<String, HashMap<Integer, Integer>>()); // need to preserve order
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) {
class_mapping.put(methodname, method_mapping = new HashMap<Integer, Integer>());
class_mapping.put(methodName, method_mapping = new HashMap<Integer, Integer>());
}
// don't overwrite
if(!method_mapping.containsKey(bytecode_offset)) {
method_mapping.put(bytecode_offset, source_line);
if (!method_mapping.containsKey(bytecodeOffset)) {
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()) {
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) {
String lineSeparator = DecompilerContext.getNewLineSeparator();
for(Entry<String, HashMap<String, HashMap<Integer, Integer>>> class_entry : mapping.entrySet()) {
HashMap<String, HashMap<Integer, Integer>> class_mapping = class_entry.getValue();
buffer.append("class " + class_entry.getKey() + "{" + lineSeparator);
for (Entry<String, Map<String, Map<Integer, Integer>>> class_entry : mapping.entrySet()) {
Map<String, Map<Integer, Integer>> class_mapping = class_entry.getValue();
buffer.append("class '" + class_entry.getKey() + "' {" + lineSeparator);
boolean is_first_method = true;
for(Entry<String, HashMap<Integer, Integer>> method_entry : class_mapping.entrySet()) {
HashMap<Integer, Integer> method_mapping = method_entry.getValue();
for (Entry<String, Map<Integer, Integer>> method_entry : class_mapping.entrySet()) {
Map<Integer, Integer> method_mapping = method_entry.getValue();
if (!is_first_method) {
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());
Collections.sort(lstBytecodeOffsets);
@ -68,9 +82,11 @@ public class BytecodeSourceMapper {
buffer.appendIndent(2).append(strOffset).appendIndent(2).append((line + offset_total) + lineSeparator);
}
buffer.appendIndent(1).append("}").appendLineSeparator();
is_first_method = false;
}
buffer.append("}").appendLineSeparator();
buffer.append("}").appendLineSeparator().appendLineSeparator();
}
// lines mapping
@ -94,12 +110,12 @@ public class BytecodeSourceMapper {
}
/**
* original to our line mapping
* Original to decompiled line mapping.
*/
public int[] getOriginalLinesMapping() {
int[] res = new int[myOriginalLinesMapping.size()*2];
int[] res = new int[linesMapping.size() * 2];
int i = 0;
for (Entry<Integer, Integer> entry : myOriginalLinesMapping.entrySet()) {
for (Entry<Integer, Integer> entry : linesMapping.entrySet()) {
res[i] = entry.getKey();
res[i + 1] = entry.getValue() + offset_total + 1; // make it 1 based
i += 2;

12
testData/results/TestClassSimpleBytecodeMapping.dec
View File

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