mirror of
https://git.huckle.dev/Huckles-Minecraft-Archive/jpexs-decompiler.git
synced 2026-05-25 12:36:29 +00:00
327 lines
9.2 KiB
Java
327 lines
9.2 KiB
Java
/*
|
|
* Copyright (C) 2010-2015 JPEXS, All rights reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 3.0 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library.
|
|
*/
|
|
package com.jpexs.decompiler.graph;
|
|
|
|
import com.jpexs.decompiler.flash.BaseLocalData;
|
|
import java.io.Serializable;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
*
|
|
* @author JPEXS
|
|
*/
|
|
public class GraphPart implements Serializable {
|
|
|
|
public static final int TYPE_NONE = 0;
|
|
public static final int TYPE_LOOP_HEADER = 1;
|
|
public static final int TYPE_PRELOOP = 3;
|
|
public static final int TYPE_REENTRY = 2;
|
|
|
|
public boolean traversed = false;
|
|
public int DFSP_pos = 0;
|
|
public GraphPart iloop_header;
|
|
public int type = TYPE_NONE;
|
|
public boolean irreducible = false;
|
|
|
|
public int start = 0;
|
|
|
|
public int end = 0;
|
|
|
|
public int instanceCount = 0;
|
|
|
|
public List<GraphPart> nextParts = new ArrayList<>();
|
|
|
|
public int posX = -1;
|
|
|
|
public int posY = -1;
|
|
|
|
public GraphPath path = new GraphPath();
|
|
|
|
public List<GraphPart> refs = new ArrayList<>();
|
|
|
|
public boolean ignored = false;
|
|
|
|
public List<Object> forContinues = new ArrayList<>();
|
|
|
|
public int level;
|
|
|
|
public int discoveredTime;
|
|
|
|
public int finishedTime;
|
|
|
|
public int order;
|
|
|
|
public List<GraphPart> throwParts = new ArrayList<>();
|
|
|
|
public enum StopPartType {
|
|
|
|
NONE, AND_OR, COMMONPART
|
|
}
|
|
|
|
//public StopPartType stopPartType = StopPartType.NONE;
|
|
//public TranslateStack andOrStack; // Stores stack when AND_OR stopPart has been reached
|
|
/*public class CommonPartStack { // Stores stack when COMMONPART stopPart has been reached
|
|
|
|
boolean isTrueStack;
|
|
|
|
TranslateStack trueStack;
|
|
|
|
TranslateStack falseStack;
|
|
}/
|
|
|
|
//public ArrayList<CommonPartStack> commonPartStacks;
|
|
|
|
/* public void setAndOrStack(TranslateStack stack) {
|
|
andOrStack = stack;
|
|
}
|
|
|
|
public void setCommonPartStack(TranslateStack stack) {
|
|
CommonPartStack currentStack = commonPartStacks.get(commonPartStacks.size() - 1);
|
|
if (currentStack.isTrueStack) {
|
|
currentStack.trueStack = stack;
|
|
} else {
|
|
currentStack.falseStack = stack;
|
|
}
|
|
}*/
|
|
public int setTime(int time, List<GraphPart> ordered, List<GraphPart> visited) {
|
|
if (visited.contains(this)) {
|
|
return time;
|
|
}
|
|
discoveredTime = time;
|
|
visited.add(this);
|
|
for (GraphPart next : nextParts) {
|
|
if (!visited.contains(next)) {
|
|
time = next.setTime(time + 1, ordered, visited);
|
|
}
|
|
}
|
|
time++;
|
|
finishedTime = time;
|
|
order = ordered.size();
|
|
ordered.add(this);
|
|
return time;
|
|
}
|
|
|
|
private boolean leadsTo(BaseLocalData localData, Graph gr, GraphSource code, GraphPart part, List<GraphPart> visited, List<Loop> loops) throws InterruptedException {
|
|
if (Thread.currentThread().isInterrupted()) {
|
|
throw new InterruptedException();
|
|
}
|
|
|
|
GraphPart tpart = gr.checkPart(null, localData, this, null);
|
|
if (tpart == null) {
|
|
return false;
|
|
}
|
|
if (tpart != this) {
|
|
return tpart.leadsTo(localData, gr, code, part, visited, loops);
|
|
}
|
|
Loop currentLoop = null;
|
|
for (Loop l : loops) {
|
|
/*if(l.phase==0){
|
|
if(l.loopContinue==this){
|
|
l.leadsToMark = 1;
|
|
next = l.loopBreak;
|
|
currentLoop = l;
|
|
continue;
|
|
}
|
|
}*/
|
|
if (l.phase == 1) {
|
|
if (l.loopContinue == this) {
|
|
return false;
|
|
}
|
|
if (l.loopPreContinue == this) {
|
|
return false;
|
|
}
|
|
if (l.loopBreak == this) {
|
|
//return false; //?
|
|
}
|
|
}
|
|
}
|
|
if (visited.contains(this)) {
|
|
return false;
|
|
}
|
|
/*if (loops.contains(this)) {
|
|
return false;
|
|
}*/
|
|
visited.add(this);
|
|
if (end < code.size() && code.get(end).isBranch() && (code.get(end).ignoredLoops())) {
|
|
return false;
|
|
}
|
|
for (GraphPart p : nextParts) {
|
|
if (p == part) {
|
|
return true;
|
|
} else {
|
|
if (p.leadsTo(localData, gr, code, part, visited, loops)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
for (GraphPart p : throwParts) {
|
|
if (p == part) {
|
|
return true;
|
|
} else {
|
|
if (p.leadsTo(localData, gr, code, part, visited, loops)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean leadsTo(BaseLocalData localData, Graph gr, GraphSource code, GraphPart part, List<Loop> loops) throws InterruptedException {
|
|
for (Loop l : loops) {
|
|
l.leadsToMark = 0;
|
|
}
|
|
return leadsTo(localData, gr, code, part, new ArrayList<>(), loops);
|
|
}
|
|
|
|
public GraphPart(int start, int end) {
|
|
this.start = start;
|
|
this.end = end;
|
|
}
|
|
|
|
private GraphPart getNextPartPath(GraphPart original, GraphPath path, List<GraphPart> visited) {
|
|
if (visited.contains(this) && (this == original)) {
|
|
return null;
|
|
}
|
|
if (visited.contains(this) && (this != original)) {
|
|
return null;
|
|
}
|
|
visited.add(this);
|
|
for (GraphPart p : nextParts) {
|
|
if (p == original) {
|
|
continue;
|
|
}
|
|
if (p.path.equals(path)) {
|
|
return p;
|
|
} else if (p.path.length() >= path.length()) {
|
|
GraphPart gp = p.getNextPartPath(original, path, visited);
|
|
if (gp != null) {
|
|
return gp;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public GraphPart getNextPartPath(List<GraphPart> ignored) {
|
|
List<GraphPart> visited = new ArrayList<>();
|
|
visited.addAll(ignored);
|
|
if (visited.contains(this)) {
|
|
visited.remove(this);
|
|
}
|
|
return getNextPartPath(this, path, visited);
|
|
}
|
|
|
|
public GraphPart getNextSuperPartPath(List<GraphPart> ignored) {
|
|
List<GraphPart> visited = new ArrayList<>();
|
|
visited.addAll(ignored);
|
|
return getNextSuperPartPath(this, path, visited);
|
|
}
|
|
|
|
private GraphPart getNextSuperPartPath(GraphPart original, GraphPath path, List<GraphPart> visited) {
|
|
if (visited.contains(this)) {
|
|
return null;
|
|
}
|
|
visited.add(this);
|
|
for (GraphPart p : nextParts) {
|
|
if (p == original) {
|
|
continue;
|
|
}
|
|
if (p.path.length() < path.length()) {
|
|
return p;
|
|
} else {
|
|
GraphPart gp = p.getNextSuperPartPath(original, path, visited);
|
|
if (gp != null) {
|
|
return gp;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
if (end < start) {
|
|
return "<-> " + (start + 1) + "-" + (end + 1);
|
|
}
|
|
return "" + (start + 1) + "-" + (end + 1) + (instanceCount > 1 ? "(" + instanceCount + " links)" : "");// + " p" + path;
|
|
}
|
|
|
|
public boolean containsIP(int ip) {
|
|
return (ip >= start) && (ip <= end);
|
|
}
|
|
|
|
private boolean containsPart(GraphPart part, GraphPart what, List<GraphPart> used) {
|
|
if (used.contains(part)) {
|
|
return false;
|
|
}
|
|
used.add(part);
|
|
for (GraphPart subpart : part.nextParts) {
|
|
if (subpart == what) {
|
|
return true;
|
|
}
|
|
if (containsPart(subpart, what, used)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int getHeight() {
|
|
return end - start + 1;
|
|
}
|
|
|
|
public int getPosAt(int offset) {
|
|
return start + offset;
|
|
}
|
|
|
|
public boolean containsPart(GraphPart what) {
|
|
return containsPart(this, what, new ArrayList<>());
|
|
}
|
|
|
|
public List<GraphPart> getSubParts() {
|
|
List<GraphPart> ret = new ArrayList<>();
|
|
ret.add(this);
|
|
return ret;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int hash = 3;
|
|
hash = 83 * hash + this.start;
|
|
return hash;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (obj == null) {
|
|
return false;
|
|
}
|
|
if (!(obj instanceof GraphPart)) {
|
|
return false;
|
|
}
|
|
final GraphPart other = (GraphPart) obj;
|
|
if (this.start != other.start) {
|
|
return false;
|
|
}
|
|
if (this.end != other.end) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|