ra/fernflower
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

java-decompiler: post-import cleanup (dead code dropped)

Browse Source
This commit is contained in:
Roman Shevchenko
2014-08-29 16:05:51 +04:00
parent 84ea54eb1e
commit 63b8d35d08
160 changed files with 4 additions and 4887 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/org/jetbrains/java/decompiler/util/ListStack.java
View File

@@ -77,14 +77,6 @@ public class ListStack<T> extends ArrayList<T> {
return pointer;
}
public T get(int index) {
return super.get(index);
}
public T set(int index, T element) {
return super.set(index, element);
}
public T getByOffset(int offset) {
return this.get(pointer + offset);
}

251
src/org/jetbrains/java/decompiler/util/SFormsFastMap.java
View File

@@ -1,251 +0,0 @@
/*
* 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.util;
import org.jetbrains.java.decompiler.modules.decompiler.exps.VarExprent;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
public class SFormsFastMap<E> {
private int size;
private List<E[]> lstElements = new ArrayList<E[]>(3);
{
lstElements.add((E[])new Object[5]);
lstElements.add((E[])new Object[5]);
lstElements.add((E[])new Object[5]);
}
public SFormsFastMap() {
}
public SFormsFastMap(SFormsFastMap<E> map) {
for (int i = 2; i >= 0; i--) {
E[] arr = map.lstElements.get(i);
E[] arrnew = (E[])new Object[arr.length];
System.arraycopy(arr, 0, arrnew, 0, arr.length);
lstElements.set(i, arrnew);
for (E element : arrnew) {
if (element != null) {
size++;
}
}
}
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void put(int key, E value) {
putInternal(key, value, false);
}
public void remove(int key) {
putInternal(key, null, true);
}
public void removeAllFields() {
E[] arr = lstElements.get(2);
for (int i = arr.length - 1; i >= 0; i--) {
E val = arr[i];
if (val != null) {
arr[i] = null;
size--;
}
}
}
public void putInternal(final int key, final E value, boolean remove) {
int index = 0;
int ikey = key;
if (ikey < 0) {
index = 2;
ikey = -ikey;
}
else if (ikey >= VarExprent.STACK_BASE) {
index = 1;
ikey -= VarExprent.STACK_BASE;
}
E[] arr = lstElements.get(index);
if (ikey >= arr.length) {
if (remove) {
return;
}
else {
arr = ensureCapacity(arr, ikey + 1, false);
lstElements.set(index, arr);
}
}
E oldval = arr[ikey];
arr[ikey] = value;
if (oldval == null && value != null) {
size++;
}
else if (oldval != null && value == null) {
size--;
}
}
public boolean containsKey(int key) {
return get(key) != null;
}
public E get(int key) {
int index = 0;
if (key < 0) {
index = 2;
key = -key;
}
else if (key >= VarExprent.STACK_BASE) {
index = 1;
key -= VarExprent.STACK_BASE;
}
E[] arr = lstElements.get(index);
if (key < arr.length) {
return arr[key];
}
return null;
}
public void union(SFormsFastMap<E> map, IElementsUnion<E> union) {
for (int i = 2; i >= 0; i--) {
E[] lstOwn = lstElements.get(i);
E[] lstExtern = map.lstElements.get(i);
int externsize = lstExtern.length;
if (lstOwn.length < externsize) {
lstOwn = ensureCapacity(lstOwn, externsize, true);
lstElements.set(i, lstOwn);
}
int ownsize = lstOwn.length;
int minsize = ownsize > externsize ? externsize : ownsize;
for (int j = minsize - 1; j >= 0; j--) {
E second = lstExtern[j];
if (second != null) {
E first = lstOwn[j];
if (first == null) {
lstOwn[j] = union.copy(second);
size++;
}
else {
union.union(first, second);
}
}
}
// ITimer timer = TimerFactory.newTimer();
// timer.start();
//
// if(externsize > minsize) {
// for(int j=minsize;j<externsize;j++) {
// E second = lstExtern.get(j);
// if(second != null) {
// lstOwn.add(union.copy(second));
// size++;
// } else {
// lstOwn.add(null);
// }
// }
// }
//
// timer.stop();
// Timer.addTime("sformunion", timer.getDuration());
}
}
public List<Entry<Integer, E>> entryList() {
List<Entry<Integer, E>> list = new ArrayList<Entry<Integer, E>>();
for (int i = 2; i >= 0; i--) {
int ikey = 0;
for (final E ent : lstElements.get(i)) {
if (ent != null) {
final int key = i == 0 ? ikey : (i == 1 ? ikey + VarExprent.STACK_BASE : -ikey);
list.add(new Entry<Integer, E>() {
private Integer var = key;
private E val = ent;
public Integer getKey() {
return var;
}
public E getValue() {
return val;
}
public E setValue(E newvalue) {
return null;
}
});
}
ikey++;
}
}
return list;
}
private E[] ensureCapacity(E[] arr, int size, boolean exact) {
int minsize = size;
if (!exact) {
minsize = 2 * arr.length / 3 + 1;
if (size > minsize) {
minsize = size;
}
}
E[] arrnew = (E[])new Object[minsize];
System.arraycopy(arr, 0, arrnew, 0, arr.length);
return arrnew;
}
public interface IElementsUnion<E> {
E union(E first, E second);
E copy(E element);
}
}

290
src/org/jetbrains/java/decompiler/util/SFormsFastMapOld.java
View File

@@ -1,290 +0,0 @@
/*
* 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.util;
import org.jetbrains.java.decompiler.modules.decompiler.exps.VarExprent;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
public class SFormsFastMapOld<E> {
private List<ArrayList<Entry<Integer, E>>> lstElements = new ArrayList<ArrayList<Entry<Integer, E>>>(3);
{
lstElements.add(new ArrayList<Entry<Integer, E>>());
lstElements.add(new ArrayList<Entry<Integer, E>>());
lstElements.add(new ArrayList<Entry<Integer, E>>());
}
public SFormsFastMapOld() {
}
public SFormsFastMapOld(SFormsFastMapOld<E> map) {
for (int i = 2; i >= 0; i--) {
lstElements.set(i, new ArrayList<Entry<Integer, E>>(map.lstElements.get(i)));
}
}
public int size() {
int size = 0;
for (int i = 2; i >= 0; i--) {
size += lstElements.get(i).size();
}
return size;
}
public boolean isEmpty() {
for (int i = 2; i >= 0; i--) {
if (!lstElements.get(i).isEmpty()) {
return false;
}
}
return true;
}
public void put(int key, E value) {
putInternal(key, value, false);
}
public void remove(int key) {
putInternal(key, null, true);
}
public void removeAllFields() {
lstElements.get(2).clear();
}
public void putInternal(final int key, final E value, boolean remove) {
int index = 0;
int ikey = key;
if (ikey < 0) {
index = 2;
ikey = -ikey;
}
else if (ikey >= VarExprent.STACK_BASE) {
index = 1;
ikey -= VarExprent.STACK_BASE;
}
ArrayList<Entry<Integer, E>> lst = lstElements.get(index);
if (ikey >= lst.size()) {
if (remove) {
return;
}
else {
ensureCapacity(lst, ikey + 1, false);
}
}
lst.set(ikey, value == null ? null : new Entry<Integer, E>() {
private Integer var = key;
private E val = value;
public Integer getKey() {
return var;
}
public E getValue() {
return val;
}
public E setValue(E newvalue) {
val = newvalue;
return null;
}
});
}
public boolean containsKey(int key) {
return get(key) != null;
}
public E get(int key) {
int index = 0;
if (key < 0) {
index = 2;
key = -key;
}
else if (key >= VarExprent.STACK_BASE) {
index = 1;
key -= VarExprent.STACK_BASE;
}
ArrayList<Entry<Integer, E>> lst = lstElements.get(index);
Entry<Integer, E> ent;
if (key < lst.size() && (ent = lst.get(key)) != null) {
return ent.getValue();
}
return null;
}
public void union(SFormsFastMapOld<E> map, IElementsUnion<E> union) {
for (int i = 2; i >= 0; i--) {
ArrayList<Entry<Integer, E>> lstOwn = lstElements.get(i);
ArrayList<Entry<Integer, E>> lstExtern = map.lstElements.get(i);
int ownsize = lstOwn.size();
int externsize = lstExtern.size();
int minsize = ownsize > externsize ? externsize : ownsize;
for (int j = minsize - 1; j >= 0; j--) {
Entry<Integer, E> second = lstExtern.get(j);
if (second != null) {
Entry<Integer, E> first = lstOwn.get(j);
if (first == null) {
putInternal(second.getKey(), union.copy(second.getValue()), false);
}
else {
first.setValue(union.union(first.getValue(), second.getValue()));
}
}
}
if (externsize > minsize) {
// ensureCapacity(lstOwn, externsize, true);
// lstOwn.addAll(lstExtern.subList(minsize, externsize));
for (int j = minsize; j < externsize; j++) {
Entry<Integer, E> second = lstExtern.get(j);
// if(first != null) {
// first.setValue(union.copy(first.getValue()));
// }
if (second != null) {
putInternal(second.getKey(), union.copy(second.getValue()), false);
}
// lstOwn.add(lstExtern.get(j));
}
}
}
}
public List<Entry<Integer, E>> entryList() {
List<Entry<Integer, E>> list = new ArrayList<Entry<Integer, E>>();
for (int i = 2; i >= 0; i--) {
for (Entry<Integer, E> ent : lstElements.get(i)) {
if (ent != null) {
list.add(ent);
}
}
}
return list;
}
// public SFormsFastMapIterator iterator() {
// return new SFormsFastMapIterator();
// }
private void ensureCapacity(ArrayList<Entry<Integer, E>> lst, int size, boolean exact) {
if (!exact) {
int minsize = 2 * lst.size() / 3 + 1;
if (minsize > size) {
size = minsize;
}
}
lst.ensureCapacity(size);
for (int i = size - lst.size(); i > 0; i--) {
lst.add(null);
}
}
public interface IElementsUnion<E> {
E union(E first, E second);
E copy(E element);
}
// public class SFormsFastMapIterator implements Iterator<Entry<Integer, E>> {
//
// private int[] pointer = new int[]{0, -1};
// private int[] next_pointer = null;
//
// private int[] getNextIndex(int list, int index) {
//
// while(list < 3) {
// ArrayList<E> lst = lstElements.get(list);
//
// while(++index < lst.size()) {
// E element = lst.get(index);
// if(element != null) {
// return new int[] {list, index};
// }
// }
//
// index = -1;
// list++;
// }
//
// return null;
// }
//
// public boolean hasNext() {
// next_pointer = getNextIndex(pointer[0], pointer[1]);
// return (next_pointer != null);
// }
//
// public Entry<Integer, E> next() {
// if(next_pointer != null) {
// pointer = next_pointer;
// } else {
// int[] nextpointer = getNextIndex(pointer[0], pointer[1]);
// if(nextpointer != null) {
// pointer = nextpointer;
// } else {
// return null;
// }
// }
//
// next_pointer = null;
//
// return new Entry<Integer, E>() {
// public Integer getKey() {
// return null;
// }
//
// public E getValue() {
// return null;
// }
//
// public E setValue(E value) {
// throw new RuntimeException("not implemented!");
// }
// };
// //lstElements.get(pointer[0]).get(pointer[1]);
// }
//
// public void remove() {
// throw new RuntimeException("not implemented!");
// }
//
// }
}