From 7b2a1fbd1aa078ed341957c4941759a02c92da94 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jindra=20Pet=F8=EDk?= Date: Sat, 16 Feb 2013 12:06:02 +0100 Subject: [PATCH] AS2: Decompiling via graph - good against obfuscators --- trunk/src/com/jpexs/asdec/SWFInputStream.java | 50 +- .../jpexs/asdec/abc/avm2/graph/AVM2Graph.java | 10 +- .../com/jpexs/asdec/abc/gui/GraphFrame.java | 7 +- trunk/src/com/jpexs/asdec/action/Action.java | 481 ++++------- .../com/jpexs/asdec/action/ActionGraph.java | 758 ++++++++++++++++++ .../com/jpexs/asdec/action/IgnoredPair.java | 16 + .../action/flashlite/ActionFSCommand2.java | 2 +- .../action/flashlite/ActionStrictMode.java | 2 +- .../jpexs/asdec/action/gui/ActionPanel.java | 15 +- .../jpexs/asdec/action/parser/ASMParser.java | 3 + .../jpexs/asdec/action/special/ActionNop.java | 4 +- .../jpexs/asdec/action/swf3/ActionGetURL.java | 2 +- .../asdec/action/swf3/ActionGoToLabel.java | 2 +- .../asdec/action/swf3/ActionGotoFrame.java | 2 +- .../asdec/action/swf3/ActionNextFrame.java | 2 +- .../jpexs/asdec/action/swf3/ActionPlay.java | 2 +- .../asdec/action/swf3/ActionPrevFrame.java | 2 +- .../asdec/action/swf3/ActionSetTarget.java | 2 +- .../jpexs/asdec/action/swf3/ActionStop.java | 2 +- .../asdec/action/swf3/ActionStopSounds.java | 2 +- .../action/swf3/ActionToggleQuality.java | 2 +- .../asdec/action/swf3/ActionWaitForFrame.java | 2 +- .../jpexs/asdec/action/swf4/ActionAdd.java | 2 +- .../jpexs/asdec/action/swf4/ActionAnd.java | 2 +- .../asdec/action/swf4/ActionAsciiToChar.java | 2 +- .../jpexs/asdec/action/swf4/ActionCall.java | 2 +- .../asdec/action/swf4/ActionCharToAscii.java | 2 +- .../asdec/action/swf4/ActionCloneSprite.java | 2 +- .../jpexs/asdec/action/swf4/ActionDivide.java | 2 +- .../asdec/action/swf4/ActionEndDrag.java | 2 +- .../jpexs/asdec/action/swf4/ActionEquals.java | 2 +- .../asdec/action/swf4/ActionGetProperty.java | 2 +- .../asdec/action/swf4/ActionGetTime.java | 2 +- .../asdec/action/swf4/ActionGetURL2.java | 2 +- .../asdec/action/swf4/ActionGetVariable.java | 2 +- .../asdec/action/swf4/ActionGotoFrame2.java | 2 +- .../jpexs/asdec/action/swf4/ActionLess.java | 2 +- .../action/swf4/ActionMBAsciiToChar.java | 2 +- .../action/swf4/ActionMBCharToAscii.java | 2 +- .../action/swf4/ActionMBStringExtract.java | 2 +- .../action/swf4/ActionMBStringLength.java | 4 +- .../asdec/action/swf4/ActionMultiply.java | 2 +- .../jpexs/asdec/action/swf4/ActionNot.java | 2 +- .../com/jpexs/asdec/action/swf4/ActionOr.java | 2 +- .../jpexs/asdec/action/swf4/ActionPop.java | 11 +- .../jpexs/asdec/action/swf4/ActionPush.java | 18 +- .../asdec/action/swf4/ActionRandomNumber.java | 2 +- .../asdec/action/swf4/ActionRemoveSprite.java | 2 +- .../asdec/action/swf4/ActionSetProperty.java | 2 +- .../asdec/action/swf4/ActionSetTarget2.java | 2 +- .../asdec/action/swf4/ActionSetVariable.java | 2 +- .../asdec/action/swf4/ActionStartDrag.java | 2 +- .../asdec/action/swf4/ActionStringAdd.java | 2 +- .../asdec/action/swf4/ActionStringEquals.java | 2 +- .../action/swf4/ActionStringExtract.java | 2 +- .../asdec/action/swf4/ActionStringLength.java | 2 +- .../asdec/action/swf4/ActionStringLess.java | 2 +- .../asdec/action/swf4/ActionSubtract.java | 2 +- .../asdec/action/swf4/ActionToInteger.java | 2 +- .../jpexs/asdec/action/swf4/ActionTrace.java | 2 +- .../action/swf4/ActionWaitForFrame2.java | 2 +- .../asdec/action/swf4/RegisterNumber.java | 2 +- .../jpexs/asdec/action/swf5/ActionAdd2.java | 2 +- .../jpexs/asdec/action/swf5/ActionBitAnd.java | 2 +- .../asdec/action/swf5/ActionBitLShift.java | 2 +- .../jpexs/asdec/action/swf5/ActionBitOr.java | 2 +- .../asdec/action/swf5/ActionBitRShift.java | 2 +- .../asdec/action/swf5/ActionBitURShift.java | 2 +- .../jpexs/asdec/action/swf5/ActionBitXor.java | 2 +- .../asdec/action/swf5/ActionCallFunction.java | 2 +- .../asdec/action/swf5/ActionCallMethod.java | 2 +- .../asdec/action/swf5/ActionConstantPool.java | 4 +- .../asdec/action/swf5/ActionDecrement.java | 2 +- .../action/swf5/ActionDefineFunction.java | 13 +- .../asdec/action/swf5/ActionDefineLocal.java | 2 +- .../asdec/action/swf5/ActionDefineLocal2.java | 2 +- .../jpexs/asdec/action/swf5/ActionDelete.java | 5 +- .../asdec/action/swf5/ActionDelete2.java | 5 +- .../asdec/action/swf5/ActionEnumerate.java | 2 +- .../asdec/action/swf5/ActionEquals2.java | 2 +- .../asdec/action/swf5/ActionGetMember.java | 2 +- .../asdec/action/swf5/ActionIncrement.java | 2 +- .../asdec/action/swf5/ActionInitArray.java | 2 +- .../asdec/action/swf5/ActionInitObject.java | 2 +- .../jpexs/asdec/action/swf5/ActionLess2.java | 2 +- .../jpexs/asdec/action/swf5/ActionModulo.java | 2 +- .../asdec/action/swf5/ActionNewMethod.java | 2 +- .../asdec/action/swf5/ActionNewObject.java | 2 +- .../action/swf5/ActionPushDuplicate.java | 4 +- .../jpexs/asdec/action/swf5/ActionReturn.java | 2 +- .../asdec/action/swf5/ActionSetMember.java | 2 +- .../asdec/action/swf5/ActionStackSwap.java | 2 +- .../action/swf5/ActionStoreRegister.java | 2 +- .../asdec/action/swf5/ActionTargetPath.java | 2 +- .../asdec/action/swf5/ActionToNumber.java | 2 +- .../asdec/action/swf5/ActionToString.java | 2 +- .../jpexs/asdec/action/swf5/ActionTypeOf.java | 2 +- .../asdec/action/swf6/ActionEnumerate2.java | 2 +- .../asdec/action/swf6/ActionGreater.java | 2 +- .../asdec/action/swf6/ActionInstanceOf.java | 2 +- .../asdec/action/swf6/ActionStrictEquals.java | 2 +- .../action/swf6/ActionStringGreater.java | 2 +- .../jpexs/asdec/action/swf7/ActionCastOp.java | 2 +- .../action/swf7/ActionDefineFunction2.java | 53 +- .../asdec/action/swf7/ActionExtends.java | 2 +- .../asdec/action/swf7/ActionImplementsOp.java | 2 +- .../jpexs/asdec/action/swf7/ActionThrow.java | 2 +- .../action/treemodel/AsciiToCharTreeItem.java | 10 + .../treemodel/CallFunctionTreeItem.java | 12 +- .../action/treemodel/CallMethodTreeItem.java | 13 +- .../asdec/action/treemodel/CallTreeItem.java | 8 + .../action/treemodel/CastOpTreeItem.java | 9 + .../action/treemodel/CharToAsciiTreeItem.java | 8 + .../action/treemodel/CloneSpriteTreeItem.java | 10 + .../asdec/action/treemodel/ConstantPool.java | 2 +- .../action/treemodel/DecrementTreeItem.java | 8 +- .../action/treemodel/DefineLocalTreeItem.java | 9 + .../action/treemodel/DeleteTreeItem.java | 9 + .../action/treemodel/DirectValueTreeItem.java | 24 +- .../asdec/action/treemodel/EachTreeItem.java | 9 + .../action/treemodel/EnumerateTreeItem.java | 8 + .../action/treemodel/ExtendsTreeItem.java | 9 + .../action/treemodel/FSCommand2TreeItem.java | 13 +- .../action/treemodel/FunctionTreeItem.java | 24 +- .../action/treemodel/GetMemberTreeItem.java | 21 +- .../action/treemodel/GetPropertyTreeItem.java | 8 + .../action/treemodel/GetURL2TreeItem.java | 9 + .../action/treemodel/GetVariableTreeItem.java | 8 + .../action/treemodel/GotoFrame2TreeItem.java | 8 + .../treemodel/ImplementsOpTreeItem.java | 12 +- .../action/treemodel/IncrementTreeItem.java | 8 + .../action/treemodel/InitArrayTreeItem.java | 13 +- .../action/treemodel/InitObjectTreeItem.java | 14 +- .../treemodel/MBAsciiToCharTreeItem.java | 8 + .../treemodel/MBCharToAsciiTreeItem.java | 8 + .../treemodel/MBStringExtractTreeItem.java | 10 + .../MBStringLengthTreeItem.java | 10 +- .../action/treemodel/NewMethodTreeItem.java | 13 +- .../action/treemodel/NewObjectTreeItem.java | 12 +- .../treemodel/RandomNumberTreeItem.java | 8 + .../treemodel/RemoveSpriteTreeItem.java | 8 + .../action/treemodel/ReturnTreeItem.java | 8 + .../action/treemodel/SetMemberTreeItem.java | 10 + .../action/treemodel/SetPropertyTreeItem.java | 9 + .../action/treemodel/SetTarget2TreeItem.java | 8 + .../action/treemodel/SetVariableTreeItem.java | 9 + .../action/treemodel/StartDragTreeItem.java | 13 + .../treemodel/StoreRegisterTreeItem.java | 10 +- .../treemodel/StringExtractTreeItem.java | 10 + .../action/treemodel/TargetPathTreeItem.java | 8 + .../asdec/action/treemodel/ThrowTreeItem.java | 8 + .../action/treemodel/ToIntegerTreeItem.java | 8 + .../action/treemodel/ToNumberTreeItem.java | 8 + .../action/treemodel/ToStringTreeItem.java | 8 + .../asdec/action/treemodel/TraceTreeItem.java | 8 + .../asdec/action/treemodel/TreeItem.java | 15 + .../action/treemodel/TypeOfTreeItem.java | 8 + .../treemodel/WaitForFrame2TreeItem.java | 8 + .../action/treemodel/clauses/ForTreeItem.java | 6 + .../treemodel/clauses/SwitchTreeItem.java | 12 +- .../treemodel/clauses/WhileTreeItem.java | 6 + .../operations/BinaryOpTreeItem.java | 10 + .../treemodel/operations/EqTreeItem.java | 7 +- .../treemodel/operations/GeTreeItem.java | 7 +- .../treemodel/operations/GtTreeItem.java | 7 +- .../treemodel/operations/LeTreeItem.java | 7 +- .../treemodel/operations/LogicalOp.java | 11 + .../treemodel/operations/LtTreeItem.java | 7 +- .../treemodel/operations/NeqTreeItem.java | 7 +- .../treemodel/operations/NotTreeItem.java | 7 +- .../operations/StrictEqTreeItem.java | 7 +- .../operations/StrictNeqTreeItem.java | 7 +- .../treemodel/operations/UnaryOpTreeItem.java | 9 + trunk/src/com/jpexs/asdec/graph/Graph.java | 78 +- .../src/com/jpexs/asdec/graph/GraphPart.java | 37 + .../com/jpexs/asdec/graph/GraphPartMulti.java | 23 + 176 files changed, 1903 insertions(+), 510 deletions(-) create mode 100644 trunk/src/com/jpexs/asdec/action/ActionGraph.java create mode 100644 trunk/src/com/jpexs/asdec/action/IgnoredPair.java rename trunk/src/com/jpexs/asdec/action/treemodel/{operations => }/MBStringLengthTreeItem.java (77%) create mode 100644 trunk/src/com/jpexs/asdec/action/treemodel/operations/LogicalOp.java diff --git a/trunk/src/com/jpexs/asdec/SWFInputStream.java b/trunk/src/com/jpexs/asdec/SWFInputStream.java index 0923d08a3..ac4a47e56 100644 --- a/trunk/src/com/jpexs/asdec/SWFInputStream.java +++ b/trunk/src/com/jpexs/asdec/SWFInputStream.java @@ -18,6 +18,9 @@ package com.jpexs.asdec; import com.jpexs.asdec.abc.avm2.instructions.other.NopIns; import com.jpexs.asdec.action.Action; +import com.jpexs.asdec.action.IgnoredPair; +import com.jpexs.asdec.action.parser.ASMParser; +import com.jpexs.asdec.action.parser.ParseException; import com.jpexs.asdec.action.special.ActionNop; import com.jpexs.asdec.action.swf3.*; import com.jpexs.asdec.action.swf4.*; @@ -37,6 +40,7 @@ import com.jpexs.asdec.types.shaperecords.SHAPERECORD; import com.jpexs.asdec.types.shaperecords.StraightEdgeRecord; import com.jpexs.asdec.types.shaperecords.StyleChangeRecord; import java.io.BufferedInputStream; +import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; @@ -45,6 +49,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Stack; +import java.util.logging.Level; import java.util.logging.Logger; /** @@ -496,15 +501,27 @@ public class SWFInputStream extends InputStream { } last = a; } + try { + String s = Highlighting.stripHilights(Action.actionsToString(ret, null, version)); + ret = ASMParser.parse(new ByteArrayInputStream(s.getBytes()), SWF.DEFAULT_VERSION); + } catch (ParseException ex) { + Logger.getLogger(SWFInputStream.class.getName()).log(Level.SEVERE, "parsing error", ex); + } return ret; } private void readActionListAtPos(Stack stack, ConstantPool cpool, SWFInputStream sis, ReReadableInputStream rri, int ip, List ret) throws IOException { + boolean debugMode = false; + boolean displayCompiletime=false; rri.setPos(ip); Action a; List output = new ArrayList(); long filePos = rri.getPos(); while ((a = sis.readAction()) != null) { + if (debugMode) { + System.out.println("ip: " + ip + " action: " + a + " stack:" + Highlighting.stripHilights(stack.toString())); + } + if (a instanceof ActionPush) { if (cpool != null) { ((ActionPush) a).constantPool = cpool.constants; @@ -542,14 +559,43 @@ public class SWFInputStream extends InputStream { aif = (ActionIf) a; TreeItem top = stack.pop(); if (top.isCompileTime()) { + if (debugMode) { + System.out.print("is compiletime -> "); + } if (top.toBoolean()) { newip = rri.getPos() + aif.offset; rri.setPos(newip); a = new ActionJump(aif.offset); + if (debugMode) { + System.out.println("jump"); + } } else { + if (debugMode) { + System.out.println("ignore"); + } a = new ActionNop(); } - beforeInsert = new ActionPop(); + if(displayCompiletime){ + beforeInsert = new ActionPop(); + } + else{ + List needed=top.getNeededActions(); + for(IgnoredPair ig:needed){ + if(ig.action instanceof ActionPush){ + if(!((ActionPush)ig.action).ignoredParts.contains(ig.pos)){ + ((ActionPush)ig.action).ignoredParts.add(ig.pos); + + if(((ActionPush)ig.action).ignoredParts.size()==((ActionPush)ig.action).values.size()) + { + ig.action.ignored=true; + } + } + }else{ + ig.action.ignored=true; + } + } + } + } else { goaif = true; } @@ -557,7 +603,7 @@ public class SWFInputStream extends InputStream { newip = rri.getPos() + ((ActionJump) a).offset; rri.setPos(newip); } else { - a.translate(stack, cpool, output, new HashMap()); + a.translate(stack, output, new HashMap()); } for (int i = 0; i < actionLen; i++) { ensureCapacity(ret, ip + i); diff --git a/trunk/src/com/jpexs/asdec/abc/avm2/graph/AVM2Graph.java b/trunk/src/com/jpexs/asdec/abc/avm2/graph/AVM2Graph.java index 9d21407df..4026c87fa 100644 --- a/trunk/src/com/jpexs/asdec/abc/avm2/graph/AVM2Graph.java +++ b/trunk/src/com/jpexs/asdec/abc/avm2/graph/AVM2Graph.java @@ -486,8 +486,12 @@ public class AVM2Graph extends Graph{ } } boolean loop = false; + boolean reversed=false; if ((!part.nextParts.isEmpty()) && part.nextParts.get(0).leadsTo(part, loopContinues)) { loop = true; + }else if ((part.nextParts.size()>1) && part.nextParts.get(1).leadsTo(part, loopContinues)) { + loop = true; + reversed=true; } if (((part.nextParts.size() == 2) || ((part.nextParts.size() == 1) && loop)) && (!isSwitch)) { @@ -508,7 +512,7 @@ public class AVM2Graph extends Graph{ } if (part.nextParts.size() > 1) { - currentLoop.loopBreak = part.nextParts.get(1); + currentLoop.loopBreak = part.nextParts.get(reversed?0:1); } int breakIp = -1; @@ -537,7 +541,7 @@ public class AVM2Graph extends Graph{ GraphPart finalPart = null; boolean isFor = false; try { - loopBody = printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level + 1, part, part.nextParts.get(0), stopPart, loops, localRegs, body, ignoredSwitches); + loopBody = printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level + 1, part, part.nextParts.get(reversed?1:0), stopPart, loops, localRegs, body, ignoredSwitches); } catch (ForException fex) { loopBody = fex.output; finalCommands = fex.finalOutput; @@ -646,7 +650,7 @@ public class AVM2Graph extends Graph{ } if (loop && (part.nextParts.size() > 1)) { loops.remove(currentLoop); //remove loop so no break shows up - ret.addAll(printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level, part, part.nextParts.get(1), stopPart, loops, localRegs, body, ignoredSwitches)); + ret.addAll(printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level, part, part.nextParts.get(reversed?0:1), stopPart, loops, localRegs, body, ignoredSwitches)); } if (next != null) { diff --git a/trunk/src/com/jpexs/asdec/abc/gui/GraphFrame.java b/trunk/src/com/jpexs/asdec/abc/gui/GraphFrame.java index c36fa6b83..5169e91e8 100644 --- a/trunk/src/com/jpexs/asdec/abc/gui/GraphFrame.java +++ b/trunk/src/com/jpexs/asdec/abc/gui/GraphFrame.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.abc.gui; import com.jpexs.asdec.abc.avm2.graph.AVM2Graph; +import com.jpexs.asdec.graph.Graph; import com.jpexs.asdec.graph.GraphPart; import com.jpexs.asdec.gui.View; import java.awt.*; @@ -41,9 +42,9 @@ public class GraphFrame extends JFrame { private static final int SPACE_HORIZONTAL = 10; private static final int BLOCK_WIDTH = 200; private static final int BLOCK_HEIGHT = 20; - private AVM2Graph graph; + private Graph graph; - public GraphPanel(AVM2Graph graph) { + public GraphPanel(Graph graph) { this.graph = graph; setPreferredSize(new Dimension((BLOCK_WIDTH + SPACE_HORIZONTAL) * getPartWidth(graph.heads.get(0), new HashSet()), (BLOCK_HEIGHT + SPACE_VERTICAL) * getPartHeight(graph.heads.get(0), new ArrayList()))); } @@ -121,7 +122,7 @@ public class GraphFrame extends JFrame { } } - public GraphFrame(AVM2Graph graph, String name) { + public GraphFrame(Graph graph, String name) { setSize(500, 500); Container cnt = getContentPane(); cnt.setLayout(new BorderLayout()); diff --git a/trunk/src/com/jpexs/asdec/action/Action.java b/trunk/src/com/jpexs/asdec/action/Action.java index a5384feb7..86028e779 100644 --- a/trunk/src/com/jpexs/asdec/action/Action.java +++ b/trunk/src/com/jpexs/asdec/action/Action.java @@ -48,6 +48,7 @@ import java.util.logging.Logger; public class Action { public Action beforeInsert; + public boolean ignored=false; /** * Action type identifier */ @@ -124,7 +125,7 @@ public class Action { List ret = new ArrayList(); return ret; } - + /** * Gets all ActionIf or ActionJump actions from subactions * @@ -363,17 +364,25 @@ public class Action { } offset = 0; - for (Action a : list) { + for (Action a : list) { offset = a.getAddress(); if (importantOffsets.contains(offset)) { ret += "loc" + Helper.formatAddress(offset) + ":"; } - if(a.beforeInsert!=null){ - ret+=a.beforeInsert.getASMSource(importantOffsets, constantPool, version) + "\r\n"; - } - if(!(a instanceof ActionNop)){ - ret += Highlighting.hilighOffset("", offset) + a.getASMSource(importantOffsets, constantPool, version) + "\r\n"; - } + + if(a.ignored){ + int len=a.getBytes(version).length; + for(int i=0;i stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { } /** @@ -579,8 +588,10 @@ public class Action { */ public static String actionsToSource(List actions, int version) { try { + //List tree = actionsToTree(new HashMap(), actions, version); List tree = actionsToTree(new HashMap(), actions, version); + return treeToString(tree); } catch (Exception ex) { Logger.getLogger(Action.class.getName()).log(Level.SEVERE, null, ex); @@ -597,14 +608,9 @@ public class Action { * @return List of treeItems */ public static List actionsToTree(HashMap regNames, List actions, int version) { - Stack stack = new Stack(); - return actionsToTree(regNames, new ArrayList(), new ArrayList(), getActionsAllIfsOrJumps(actions), stack, new ConstantPool(), actions, 0, actions.size() - 1, version); - } - - private static Stack actionsToStackTree(HashMap regNames, List jumpsOrIfs, List actions, ConstantPool constants, int start, int end, int version) { - Stack ret = new Stack(); - actionsToTree(regNames, new ArrayList(), new ArrayList(), jumpsOrIfs, ret, constants, actions, start, end, version); - return ret; + //Stack stack = new Stack(); + return ActionGraph.translateViaGraph(regNames, actions, version); + //return actionsToTree(regNames, stack, actions, 0, actions.size() - 1, version); } private static class Loop { @@ -629,8 +635,10 @@ public class Action { logger.fine(s); } - private static List actionsToTree(HashMap registerNames, List unknownJumps, List loopList, List jumpsOrIfs, Stack stack, ConstantPool constants, List actions, int start, int end, int version) { - log("Entering " + start + "-" + end + (actions.size() > 0 ? (" (" + actions.get(start).toString() + " - " + actions.get(end == actions.size() ? end - 1 : end) + ")") : "")); + public static List actionsPartToTree(HashMap registerNames, Stack stack, List actions, int start, int end, int version) { + if (start < actions.size() && (end > 0) && (start > 0)) { + log("Entering " + start + "-" + end + (actions.size() > 0 ? (" (" + actions.get(start).toString() + " - " + actions.get(end == actions.size() ? end - 1 : end) + ")") : "")); + } List output = new ArrayList(); int ip = start; boolean isWhile = false; @@ -641,259 +649,71 @@ public class Action { while (ip <= end + 1) { long addr = ip2adr(actions, ip, version); - if (unknownJumps.contains(addr)) { - unknownJumps.remove(new Long(addr)); - boolean switchFound = false; - for (int i = output.size() - 1; i >= 0; i--) { - if (output.get(i) instanceof SwitchTreeItem) { - if (((SwitchTreeItem) output.get(i)).defaultCommands == null) { - List continues = ((SwitchTreeItem) output.get(i)).getContinues(); - boolean breakFound = false; - for (ContinueTreeItem cti : continues) { - if (cti.loopPos == addr) { - cti.isKnown = true; - cti.isBreak = true; - ((SwitchTreeItem) output.get(i)).loopBreak = addr; - breakFound = true; - } - } - if (breakFound) { - switchFound = true; - ((SwitchTreeItem) output.get(i)).defaultCommands = new ArrayList(); - for (int k = i + 1; k < output.size(); k++) { - ((SwitchTreeItem) output.get(i)).defaultCommands.add(output.remove(i + 1)); - } - } - } - break; - } - } - if (!switchFound) { - throw new UnknownJumpException(stack, addr, output); - } - } + /*if (unknownJumps.contains(addr)) { + unknownJumps.remove(new Long(addr)); + boolean switchFound = false; + for (int i = output.size() - 1; i >= 0; i--) { + if (output.get(i) instanceof SwitchTreeItem) { + if (((SwitchTreeItem) output.get(i)).defaultCommands == null) { + List continues = ((SwitchTreeItem) output.get(i)).getContinues(); + boolean breakFound = false; + for (ContinueTreeItem cti : continues) { + if (cti.loopPos == addr) { + cti.isKnown = true; + cti.isBreak = true; + ((SwitchTreeItem) output.get(i)).loopBreak = addr; + breakFound = true; + } + } + if (breakFound) { + switchFound = true; + ((SwitchTreeItem) output.get(i)).defaultCommands = new ArrayList(); + for (int k = i + 1; k < output.size(); k++) { + ((SwitchTreeItem) output.get(i)).defaultCommands.add(output.remove(i + 1)); + } + } + } + break; + } + } + if (!switchFound) { + throw new UnknownJumpException(stack, addr, output); + } + }*/ if (ip > end) { break; } Action action = actions.get(ip); - log("" + Helper.formatAddress(addr) + " ip:" + ip + " action:" + action); - for (int j = 0; j < jumpsOrIfs.size(); j++) { - Action jif = jumpsOrIfs.get(j); - if (jif instanceof ActionIf) { - if (((ActionIf) jif).getRef(version) == addr) { - if (jif.getAddress() > addr) { - jumpsOrIfs.remove(j); - List doBody = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, stack, constants, actions, ip, adr2ip(actions, jif.getAddress(), version) - 1, version); - Loop currentLoop = new Loop(ip, adr2ip(actions, jif.getAddress(), version) + 1); - loopList.add(currentLoop); - TreeItem expression = stack.pop(); - boolean isForInReturn = false; - //Before return in for..in clause, stack must be emptied - if (doBody.isEmpty()) { - TreeItem e = expression; - if (e instanceof NotTreeItem) { - e = ((NotTreeItem) e).value; - if (e instanceof EqTreeItem) { - e = ((EqTreeItem) e).leftSide; - if (e instanceof EnumerateTreeItem) { - isForInReturn = true; - } - } - } - } - if (!isForInReturn) { - output.add(new DoWhileTreeItem(action, adr2ip(actions, jif.getAddress(), version) + 1, ip, doBody, expression)); - } - ip = adr2ip(actions, jif.getAddress(), version) + 1; - continue loopip; - } - } - } - - } - for (int j = 0; j < jumpsOrIfs.size(); j++) { - Action jif = jumpsOrIfs.get(j); - if (jif instanceof ActionJump) { - if (((ActionJump) jif).getRef(version) == addr) { - if (jif.getAddress() > addr) { - isWhile = true; - loopStart = ip; - break; - } - } - } - } - if (action instanceof ActionJump) { - int jumpIp = adr2ip(actions, ((ActionJump) action).getRef(version), version); - for (Loop l : loopList) { - if (l.loopBreak == ((ActionJump) action).getRef(version)) { - output.add(new BreakTreeItem(action, l.loopBreak)); - ip = ip + 1; - continue loopip; - } - if (l.loopContinue == ((ActionJump) action).getRef(version)) { - l.continueCount++; - output.add(new ContinueTreeItem(action, l.loopBreak)); - ip = ip + 1; - continue loopip; - } - } - output.add(new ContinueTreeItem(action, ((ActionJump) action).getRef(version), false)); - - if (!unknownJumps.contains(((ActionJump) action).getRef(version))) { - unknownJumps.add(((ActionJump) action).getRef(version)); - } - break; - - } else if (action instanceof ActionIf) { - int jumpIp = adr2ip(actions, ((ActionIf) action).getRef(version), version); - if (jumpIp < ip) { - output.add(new UnsupportedTreeItem(action, "ActionIf to jump back")); - break; - } - TreeItem expression = null; - if (!isForIn) { - expression = stack.pop(); - if (expression instanceof NotTreeItem) { - expression = ((NotTreeItem) expression).value; - } else { - expression = new NotTreeItem(action, expression); - } - } - List onTrue = new ArrayList(); - List onFalse = new ArrayList(); - boolean hasElse = false; - int jumpElseIp = 0; - Stack falseStack = (Stack) stack.clone(); - Stack trueStack = (Stack) stack.clone();// new Stack(); - //if (!isWhile) { - if (actions.get(jumpIp - 1) instanceof ActionJump) { - long ref = ((ActionJump) actions.get(jumpIp - 1)).getRef(version); - int refIp = adr2ip(actions, ref, version); - if ((refIp > jumpIp) && (refIp <= end + 1)) { - hasElse = true; - jumpElseIp = adr2ip(actions, ((ActionJump) actions.get(jumpIp - 1)).getRef(version), version); - } - } - //} - Loop currentLoop = null; - if (isWhile || isForIn) { - currentLoop = new Loop(ip2adr(actions, loopStart, version), ip2adr(actions, jumpIp, version)); - loopList.add(currentLoop); - } - boolean isFor = false; - boolean isTernar = false; - List finalExpression = null; - - TreeItem variableName = null; - try { - int falseStackSizeBefore = falseStack.size(); - if (hasElse) { - log("Going to onfalse"); - onFalse = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, falseStack, constants, actions, jumpIp, jumpElseIp - 1, version); - } - int trueStackSizeBefore = trueStack.size(); - log("Going to ontrue"); - onTrue = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, trueStack, constants, actions, ip + 1, jumpIp - 1 - (hasElse || isWhile || isForIn ? 1 : 0), version); - if (onTrue.isEmpty() && trueStack.size() > trueStackSizeBefore && onFalse.isEmpty() && falseStack.size() > falseStackSizeBefore) { - isTernar = true; - } - int next = (hasElse ? jumpElseIp : jumpIp); - if (actions.size() > next) { - if (!isTernar) { - Action nea = actions.get(next); - if (nea instanceof ActionPop) { - if (trueStack.size() > 0) { - nea.translate(trueStack, constants, onTrue, registerNames); - } - } - } - } - } catch (UnknownJumpException uje) { - if ((adr2ip(actions, uje.addr, version) >= start) && (adr2ip(actions, uje.addr, version) <= end)) { - if (currentLoop == null) { - output.add(new UnsupportedTreeItem(action, "UnknownJump")); - } else { - currentLoop.loopContinue = uje.addr; - onTrue = uje.output; - List contList = new ArrayList(); - for (TreeItem ti : onTrue) { - if (ti instanceof ContinueTreeItem) { - contList.add((ContinueTreeItem) ti); - } - if (ti instanceof Block) { - List subcont = ((Block) ti).getContinues(); - for (int k = 0; k < subcont.size(); k++) { - contList.add(subcont.get(k)); - } - } - } - for (int u = 0; u < contList.size(); u++) { - if (contList.get(u) instanceof ContinueTreeItem) { - if (((ContinueTreeItem) contList.get(u)).loopPos == uje.addr) { - if (!((ContinueTreeItem) contList.get(u)).isKnown) { - ((ContinueTreeItem) contList.get(u)).isKnown = true; - ((ContinueTreeItem) contList.get(u)).loopPos = currentLoop.loopBreak; - } - } - } - } - finalExpression = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, stack, constants, actions, adr2ip(actions, uje.addr, version), jumpIp - 2, version); - isFor = true; - } - } else { - //throw new ConvertException("Unknown pattern: jump to nowhere", ip); - } - } - if (isForIn) { - variableName = onTrue.remove(0); - if (variableName instanceof SetTypeTreeItem) { - variableName = ((SetTypeTreeItem) variableName).getObject(); - } - output.add(new ForInTreeItem(action, jumpIp, loopStart, variableName, inItem, onTrue)); - } else if (isFor) { - output.add(new ForTreeItem(action, currentLoop.loopBreak, currentLoop.loopContinue, new ArrayList(), expression, finalExpression, onTrue)); - } else if (isTernar) { - stack.push(new TernarOpTreeItem(action, expression, trueStack.pop(), falseStack.pop())); - } else if (isWhile) { - output.add(new WhileTreeItem(action, jumpIp, loopStart, expression, onTrue)); - } else { - output.add(new IfTreeItem(action, expression, onTrue, onFalse)); - } - ip = (hasElse ? jumpElseIp : jumpIp); - isWhile = false; - isFor = false; - isForIn = false; - continue; - } else if ((action instanceof ActionEnumerate2) || (action instanceof ActionEnumerate)) { + /*ActionJump && ActionIf removed*/ + if ((action instanceof ActionEnumerate2) || (action instanceof ActionEnumerate)) { loopStart = ip + 1; isForIn = true; ip += 4; - action.translate(stack, constants, output, registerNames); + action.translate(stack, output, registerNames); EnumerateTreeItem en = (EnumerateTreeItem) stack.peek(); inItem = en.object; continue; } else if (action instanceof ActionTry) { ActionTry atry = (ActionTry) action; - List tryCommands = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, atry.tryBody, 0, atry.tryBody.size() - 1, version); + List tryCommands = ActionGraph.translateViaGraph(registerNames, atry.tryBody, version); TreeItem catchName; if (atry.catchInRegisterFlag) { - catchName = new DirectValueTreeItem(atry, new RegisterNumber(atry.catchRegister), constants); + catchName = new DirectValueTreeItem(atry,-1, new RegisterNumber(atry.catchRegister), new ArrayList()); } else { - catchName = new DirectValueTreeItem(atry, atry.catchName, constants); + catchName = new DirectValueTreeItem(atry,-1, atry.catchName, new ArrayList()); } List catchExceptions = new ArrayList(); catchExceptions.add(catchName); List> catchCommands = new ArrayList>(); - catchCommands.add(actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, atry.catchBody, 0, atry.catchBody.size() - 1, version)); - List finallyCommands = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, atry.finallyBody, 0, atry.finallyBody.size() - 1, version); + catchCommands.add(ActionGraph.translateViaGraph(registerNames, atry.catchBody, version)); + List finallyCommands = ActionGraph.translateViaGraph(registerNames, atry.finallyBody, version); output.add(new TryTreeItem(tryCommands, catchExceptions, catchCommands, finallyCommands)); } else if (action instanceof ActionWith) { ActionWith awith = (ActionWith) action; - List withCommands = actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, awith.actions, 0, awith.actions.size() - 1, version); + List withCommands = ActionGraph.translateViaGraph(registerNames, awith.actions, version); output.add(new WithTreeItem(action, stack.pop(), withCommands)); } else if (action instanceof ActionDefineFunction) { - FunctionTreeItem fti = new FunctionTreeItem(action, ((ActionDefineFunction) action).functionName, ((ActionDefineFunction) action).paramNames, actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, ((ActionDefineFunction) action).code, 0, ((ActionDefineFunction) action).code.size() - 1, version), constants); + FunctionTreeItem fti = new FunctionTreeItem(action, ((ActionDefineFunction) action).functionName, ((ActionDefineFunction) action).paramNames, ActionGraph.translateViaGraph(registerNames, ((ActionDefineFunction) action).code, version), ((ActionDefineFunction) action).constantPool, 1); stack.push(fti); } else if (action instanceof ActionDefineFunction2) { HashMap funcRegNames = (HashMap) registerNames.clone(); @@ -929,87 +749,89 @@ public class Action { pos++; } - FunctionTreeItem fti = new FunctionTreeItem(action, ((ActionDefineFunction2) action).functionName, ((ActionDefineFunction2) action).paramNames, actionsToTree(funcRegNames, unknownJumps, loopList, jumpsOrIfs, new Stack(), constants, ((ActionDefineFunction2) action).code, 0, ((ActionDefineFunction2) action).code.size() - 1, version), constants); + FunctionTreeItem fti = new FunctionTreeItem(action, ((ActionDefineFunction2) action).functionName, ((ActionDefineFunction2) action).paramNames, ActionGraph.translateViaGraph(funcRegNames, ((ActionDefineFunction2) action).code, version), ((ActionDefineFunction2) action).constantPool, ((ActionDefineFunction2) action).getFirstRegister()); stack.push(fti); - } else if (action instanceof ActionPushDuplicate) { - do { - if (actions.get(ip + 1) instanceof ActionNot) { - if (actions.get(ip + 2) instanceof ActionIf) { - int nextPos = adr2ip(actions, ((ActionIf) actions.get(ip + 2)).getRef(version), version); - stack.push(new AndTreeItem(action, stack.pop(), actionsToStackTree(registerNames, jumpsOrIfs, actions, constants, ip + 4 /*je tam pop*/, nextPos - 1, version).pop())); - ip = nextPos; - } else { - output.add(new UnsupportedTreeItem(action, "ActionPushDuplicate with Not")); - break; - } - } else if (actions.get(ip + 1) instanceof ActionIf) { - int nextPos = adr2ip(actions, ((ActionIf) actions.get(ip + 1)).getRef(version), version); - stack.push(new OrTreeItem(action, stack.pop(), actionsToStackTree(registerNames, jumpsOrIfs, actions, constants, ip + 3, nextPos - 1, version).pop())); - ip = nextPos; - } else { - output.add(new UnsupportedTreeItem(action, "ActionPushDuplicate with no If")); - break loopip; - } - action = actions.get(ip); - } while (action instanceof ActionPushDuplicate); - continue; - } else if (action instanceof ActionStoreRegister) { + } /*else if (action instanceof ActionPushDuplicate) { + do { + if (actions.get(ip + 1) instanceof ActionNot) { + if (actions.get(ip + 2) instanceof ActionIf) { + int nextPos = adr2ip(actions, ((ActionIf) actions.get(ip + 2)).getRef(version), version); + stack.push(new AndTreeItem(action, stack.pop(), actionsToStackTree(registerNames, actions, constants, ip + 4, nextPos - 1, version).pop())); + ip = nextPos; + } else { + output.add(new UnsupportedTreeItem(action, "ActionPushDuplicate with Not")); + break; + } + } else if (actions.get(ip + 1) instanceof ActionIf) { + int nextPos = adr2ip(actions, ((ActionIf) actions.get(ip + 1)).getRef(version), version); + stack.push(new OrTreeItem(action, stack.pop(), actionsToStackTree(registerNames, actions, constants, ip + 3, nextPos - 1, version).pop())); + ip = nextPos; + } else { + output.add(new UnsupportedTreeItem(action, "ActionPushDuplicate with no If")); + break loopip; + } + action = actions.get(ip); + } while (action instanceof ActionPushDuplicate); + continue; + }*/ else if (action instanceof ActionStoreRegister) { if ((ip + 1 <= end) && (actions.get(ip + 1) instanceof ActionPop)) { - action.translate(stack, constants, output, registerNames); + action.translate(stack, output, registerNames); stack.pop(); ip++; } else { - action.translate(stack, constants, output, registerNames); + action.translate(stack, output, registerNames); } - } else if (action instanceof ActionStrictEquals) { - if ((ip + 1 < actions.size()) && (actions.get(ip + 1) instanceof ActionIf)) { - List caseValues = new ArrayList(); - List> caseCommands = new ArrayList>(); - caseValues.add(stack.pop()); - TreeItem switchedObject = stack.pop(); - if (output.size() > 0) { - if (output.get(output.size() - 1) instanceof StoreRegisterTreeItem) { - output.remove(output.size() - 1); - } - } - int caseStart = ip + 2; - List caseBodyIps = new ArrayList(); - long defaultAddr = 0; - caseBodyIps.add(adr2ip(actions, ((ActionIf) actions.get(ip + 1)).getRef(version), version)); - ip++; - do { - ip++; - if ((actions.get(ip - 1) instanceof ActionStrictEquals) && (actions.get(ip) instanceof ActionIf)) { - caseValues.add(actionsToStackTree(registerNames, jumpsOrIfs, actions, constants, caseStart, ip - 2, version).pop()); - caseStart = ip + 1; - caseBodyIps.add(adr2ip(actions, ((ActionIf) actions.get(ip)).getRef(version), version)); - if (actions.get(ip + 1) instanceof ActionJump) { - defaultAddr = ((ActionJump) actions.get(ip + 1)).getRef(version); - ip = adr2ip(actions, defaultAddr, version); - break; - } - } - } while (ip < end); - loopList.add(new Loop(-1, ip2adr(actions, ip, version))); - for (int i = 0; i < caseBodyIps.size(); i++) { - int caseEnd = ip - 1; - if (i < caseBodyIps.size() - 1) { - caseEnd = caseBodyIps.get(i + 1) - 1; - } - caseCommands.add(actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, stack, constants, actions, caseBodyIps.get(i), caseEnd, version)); - } - output.add(new SwitchTreeItem(action, defaultAddr, switchedObject, caseValues, caseCommands, null)); - continue; - } else { - action.translate(stack, constants, output, registerNames); - } - } else { + } /*else if (action instanceof ActionStrictEquals) { + if ((ip + 1 < actions.size()) && (actions.get(ip + 1) instanceof ActionIf)) { + List caseValues = new ArrayList(); + List> caseCommands = new ArrayList>(); + caseValues.add(stack.pop()); + TreeItem switchedObject = stack.pop(); + if (output.size() > 0) { + if (output.get(output.size() - 1) instanceof StoreRegisterTreeItem) { + output.remove(output.size() - 1); + } + } + int caseStart = ip + 2; + List caseBodyIps = new ArrayList(); + long defaultAddr = 0; + caseBodyIps.add(adr2ip(actions, ((ActionIf) actions.get(ip + 1)).getRef(version), version)); + ip++; + do { + ip++; + if ((actions.get(ip - 1) instanceof ActionStrictEquals) && (actions.get(ip) instanceof ActionIf)) { + caseValues.add(actionsToStackTree(registerNames, jumpsOrIfs, actions, constants, caseStart, ip - 2, version).pop()); + caseStart = ip + 1; + caseBodyIps.add(adr2ip(actions, ((ActionIf) actions.get(ip)).getRef(version), version)); + if (actions.get(ip + 1) instanceof ActionJump) { + defaultAddr = ((ActionJump) actions.get(ip + 1)).getRef(version); + ip = adr2ip(actions, defaultAddr, version); + break; + } + } + } while (ip < end); + + for (int i = 0; i < caseBodyIps.size(); i++) { + int caseEnd = ip - 1; + if (i < caseBodyIps.size() - 1) { + caseEnd = caseBodyIps.get(i + 1) - 1; + } + caseCommands.add(actionsToTree(registerNames, unknownJumps, loopList, jumpsOrIfs, stack, constants, actions, caseBodyIps.get(i), caseEnd, version)); + } + output.add(new SwitchTreeItem(action, defaultAddr, switchedObject, caseValues, caseCommands, null)); + continue; + } else { + action.translate(stack, constants, output, registerNames); + } + } */ else { try { - action.translate(stack, constants, output, registerNames); + action.translate(stack, output, registerNames); } catch (EmptyStackException ese) { + System.err.println("EMPTYSTACK==========================="); Logger.getLogger(Action.class.getName()).log(Level.SEVERE, null, ese); output.add(new UnsupportedTreeItem(action, "Empty stack")); } + } ip++; @@ -1022,7 +844,7 @@ public class Action { } } } - output = checkClass(output); + //output = checkClass(output); log("Leaving " + start + "-" + end); return output; } @@ -1042,7 +864,7 @@ public class Action { if (v.value instanceof DirectValueTreeItem) { if (((DirectValueTreeItem) v.value).value instanceof String) { if (((DirectValueTreeItem) v.value).value.equals("_global")) { - GetVariableTreeItem gvt = new GetVariableTreeItem(null, ((GetMemberTreeItem) t).functionName); + GetVariableTreeItem gvt = new GetVariableTreeItem(null, ((GetMemberTreeItem) t).memberName); if (lastMember == null) { return gvt; } else { @@ -1055,7 +877,7 @@ public class Action { return ti; } - private static List checkClass(List output) { + public static List checkClass(List output) { List ret = new ArrayList(); List functions = new ArrayList(); List staticFunctions = new ArrayList(); @@ -1071,7 +893,7 @@ public class Action { if (it.expression instanceof NotTreeItem) { NotTreeItem nti = (NotTreeItem) it.expression; if (nti.value instanceof GetMemberTreeItem) { - if (it.onFalse.isEmpty()) { + if (true) { //it.onFalse.isEmpty()){ //||(it.onFalse.get(0) instanceof UnsupportedTreeItem)) { if ((it.onTrue.size() == 1) && (it.onTrue.get(0) instanceof SetMemberTreeItem) && (((SetMemberTreeItem) it.onTrue.get(0)).value instanceof NewObjectTreeItem)) { //ignore } else { @@ -1085,7 +907,7 @@ public class Action { TreeItem ti2 = ((StoreRegisterTreeItem) parts.get(0)).value; if (ti1 == ti2) { if (((SetMemberTreeItem) parts.get(1)).value instanceof FunctionTreeItem) { - ((FunctionTreeItem) ((SetMemberTreeItem) parts.get(1)).value).calculatedFunctionName = (className instanceof GetMemberTreeItem) ? ((GetMemberTreeItem) className).functionName : className; + ((FunctionTreeItem) ((SetMemberTreeItem) parts.get(1)).value).calculatedFunctionName = (className instanceof GetMemberTreeItem) ? ((GetMemberTreeItem) className).memberName : className; functions.add((FunctionTreeItem) ((SetMemberTreeItem) parts.get(1)).value); int pos = 2; if (parts.size() <= pos) { @@ -1171,15 +993,10 @@ public class Action { } else { ok = false; } - } else if (parts.get(pos) instanceof VoidTreeItem) { - VoidTreeItem v = (VoidTreeItem) parts.get(pos); - if (v.value instanceof CallFunctionTreeItem) { - //if(((CallFunctionTreeItem)parts.get(pos)).functionName){ - if (((CallFunctionTreeItem) v.value).functionName instanceof DirectValueTreeItem) { - if (((DirectValueTreeItem) ((CallFunctionTreeItem) v.value).functionName).value.equals("ASSetPropFlags")) { - } else { - ok = false; - } + } else if (parts.get(pos) instanceof CallFunctionTreeItem) { + //if(((CallFunctionTreeItem)parts.get(pos)).functionName){ + if (((CallFunctionTreeItem) parts.get(pos)).functionName instanceof DirectValueTreeItem) { + if (((DirectValueTreeItem) ((CallFunctionTreeItem) parts.get(pos)).functionName).value.equals("ASSetPropFlags")) { } else { ok = false; } diff --git a/trunk/src/com/jpexs/asdec/action/ActionGraph.java b/trunk/src/com/jpexs/asdec/action/ActionGraph.java new file mode 100644 index 000000000..0d0859fe5 --- /dev/null +++ b/trunk/src/com/jpexs/asdec/action/ActionGraph.java @@ -0,0 +1,758 @@ +/* + * Copyright (C) 2010-2013 JPEXS + * + * 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 3 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, see . + */ +package com.jpexs.asdec.action; + +import com.jpexs.asdec.graph.Graph; +import com.jpexs.asdec.graph.GraphPart; +import com.jpexs.asdec.graph.Loop; +import com.jpexs.asdec.graph.GraphPartMulti; +import com.jpexs.asdec.action.swf4.ActionIf; +import com.jpexs.asdec.action.swf4.ActionJump; +import com.jpexs.asdec.action.swf4.Null; +import com.jpexs.asdec.action.swf5.ActionReturn; +import com.jpexs.asdec.action.swf6.ActionStrictEquals; +import com.jpexs.asdec.action.swf7.ActionThrow; +import com.jpexs.asdec.action.treemodel.BreakTreeItem; +import com.jpexs.asdec.action.treemodel.ContinueTreeItem; +import com.jpexs.asdec.action.treemodel.DirectValueTreeItem; +import com.jpexs.asdec.action.treemodel.StoreRegisterTreeItem; +import com.jpexs.asdec.action.treemodel.TreeItem; +import com.jpexs.asdec.action.treemodel.UnsupportedTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.DoWhileTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.ForTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.IfTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.SwitchTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.TernarOpTreeItem; +import com.jpexs.asdec.action.treemodel.clauses.WhileTreeItem; +import com.jpexs.asdec.action.treemodel.operations.AndTreeItem; +import com.jpexs.asdec.action.treemodel.operations.LogicalOp; +import com.jpexs.asdec.action.treemodel.operations.NotTreeItem; +import com.jpexs.asdec.action.treemodel.operations.OrTreeItem; +import com.jpexs.asdec.action.treemodel.operations.StrictEqTreeItem; +import com.jpexs.asdec.helpers.Highlighting; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Stack; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * + * @author JPEXS + */ +public class ActionGraph extends Graph { + + private List code; + private int version; + + public ActionGraph(List code, int version) { + this.version = version; + this.code = code; + heads = makeGraph(code, new ArrayList()); + for (GraphPart head : heads) { + fixGraph(head); + makeMulti(head, new ArrayList()); + } + + } + + public static List translateViaGraph(HashMap registerNames, List code, int version) { + ActionGraph g = new ActionGraph(code, version); + List allParts = new ArrayList(); + for (GraphPart head : g.heads) { + populateParts(head, allParts); + } + return Action.checkClass(g.printGraph(registerNames, new Stack(), allParts, null, g.heads.get(0), null, new ArrayList(), new HashMap>())); + } + + private TreeItem translatePartGetStack(GraphPart part, Stack stack, HashMap registerNames) { + stack = (Stack) stack.clone(); + translatePart(part, stack, registerNames); + return stack.pop(); + } + + private List translatePart(GraphPart part, Stack stack, HashMap registerNames) { + List sub = part.getSubParts(); + List ret = new ArrayList(); + int end = 0; + for (GraphPart p : sub) { + if (p.end == -1) { + p.end = code.size() - 1; + } + if (p.start == code.size()) { + continue; + } else if (p.end == code.size()) { + p.end--; + } + end = p.end; + int start = p.start; + if (code.get(end) instanceof ActionJump) { + end--; + } else if (code.get(end) instanceof ActionIf) { + end--; + } + ret.addAll(Action.actionsPartToTree(registerNames, stack, code, start, end, version)); + } + return ret; + } + + private TreeItem checkLoop(GraphPart part, GraphPart stopPart, List loops) { + if (part == stopPart) { + return null; + } + for (Loop l : loops) { + if (l.loopContinue == part) { + return (new ContinueTreeItem(null, l.loopBreak == null ? -1 : l.loopBreak.start)); + } + if (l.loopBreak == part) { + return (new BreakTreeItem(null, part.start)); + } + } + return null; + } + private boolean doDecompile = true; + + private List printGraph(HashMap registerNames, Stack stack, List allParts, GraphPart parent, GraphPart part, GraphPart stopPart, List loops, HashMap> forFinalCommands) { + List ret = new ArrayList(); + boolean debugMode = false; + if (part.start >= code.size()) { + return ret; + } + + if (!doDecompile) { + // ret.add(new CommentTreeItem(null, "not decompiled")); + return ret; + } + + if (debugMode) { + System.err.println("PART " + part); + } + + if (part == stopPart) { + return ret; + } + if (part.ignored) { + return ret; + } + List fqn = new ArrayList(); + HashMap lrn = new HashMap(); + List output = new ArrayList(); + boolean isSwitch = false; + List parts = new ArrayList(); + if (part instanceof GraphPartMulti) { + parts = ((GraphPartMulti) part).parts; + } else { + parts.add(part); + } + boolean isIf = false; + int end = part.end; + if (end == -1) { + end = code.size() - 1; + } + if (end == code.size()) { + end--; + } + output.addAll(translatePart(part, stack, registerNames)); + if (end > -1) { + if (code.get(end) instanceof ActionJump) { + end--; + } else if (code.get(end) instanceof ActionIf) { + end--; + isIf = true; + } + } + if (isIf) { + Action ins = code.get(end + 1); + if ((stack.size() >= 2) && (stack.get(stack.size() - 1) instanceof NotTreeItem) && (((NotTreeItem) stack.get(stack.size() - 1)).value == stack.get(stack.size() - 2))) { + ret.addAll(output); + printGraph(registerNames, stack, allParts, parent, part.nextParts.get(1), part.nextParts.get(0), loops, forFinalCommands); + TreeItem second = stack.pop(); + TreeItem first = stack.pop(); + stack.push(new AndTreeItem(ins, first, second)); + ret.addAll(printGraph(registerNames, stack, allParts, parent, part.nextParts.get(0), stopPart, loops, forFinalCommands)); + return ret; + } else if ((stack.size() >= 2) && (stack.get(stack.size() - 1) == stack.get(stack.size() - 2))) { + ret.addAll(output); + printGraph(registerNames, stack, allParts, parent, part.nextParts.get(1), part.nextParts.get(0), loops, forFinalCommands); + TreeItem second = stack.pop(); + TreeItem first = stack.pop(); + stack.push(new OrTreeItem(ins, first, second)); + ret.addAll(printGraph(registerNames, stack, allParts, parent, part.nextParts.get(0), stopPart, loops, forFinalCommands)); + return ret; + } else if (stack.peek() instanceof StrictEqTreeItem) { + + TreeItem switchedObject = null; + if (!output.isEmpty()) { + if (output.get(output.size() - 1) instanceof StoreRegisterTreeItem) { + switchedObject = ((StoreRegisterTreeItem) output.get(output.size() - 1)).value; + } + } + if (switchedObject == null) { + switchedObject = new DirectValueTreeItem(null,-1, new Null(), null); + } + HashMap caseValuesMap = new HashMap(); + + int pos = 0; + StrictEqTreeItem set = (StrictEqTreeItem) stack.pop(); + caseValuesMap.put(pos, set.rightSide); + + //GraphPart switchLoc = part.nextParts.get(1).nextParts.get(0); + List caseBodyParts = new ArrayList(); + caseBodyParts.add(part.nextParts.get(0)); + TreeItem top = null; + int cnt = 1; + while (part.nextParts.size() > 1 + && part.nextParts.get(1).getHeight() > 1 + && code.get(part.nextParts.get(1).end) instanceof ActionIf + && ((top = translatePartGetStack(part.nextParts.get(1), stack, registerNames)) instanceof StrictEqTreeItem)) { + cnt++; + part = part.nextParts.get(1); + pos++; + caseBodyParts.add(part.nextParts.get(0)); + /*List subparts=part.getSubParts(); + for(GraphPart p:subparts){ + Action.actionsPartToTree(registerNames, stack, code, p.start, p.end - 1, version); + }*/ + set = (StrictEqTreeItem) top; + caseValuesMap.put(pos, set.rightSide); + } + if (cnt == 1) { + stack.push(set); + } else { + part = part.nextParts.get(1); + + GraphPart defaultPart = part; + //caseBodyParts.add(defaultPart); + + + + List defaultAndLastPart = new ArrayList(); + defaultAndLastPart.add(defaultPart); + defaultAndLastPart.add(caseBodyParts.get(caseBodyParts.size() - 1)); + + GraphPart defaultPart2 = getCommonPart(defaultAndLastPart); + + List defaultCommands = new ArrayList(); + + defaultCommands = printGraph(registerNames, stack, allParts, null, defaultPart, defaultPart2, loops, forFinalCommands); + + + List loopContinues = new ArrayList(); + for (Loop l : loops) { + if (l.loopContinue != null) { + loopContinues.add(l.loopContinue); + } + } + + List breakParts = new ArrayList(); + for (int g = 0; g < caseBodyParts.size(); g++) { + if (g < caseBodyParts.size() - 1) { + if (caseBodyParts.get(g).leadsTo(caseBodyParts.get(g + 1), loopContinues)) { + continue; + } + } + GraphPart nsp = caseBodyParts.get(g).getNextSuperPartPath(loopContinues); + if (nsp != null) { + breakParts.add(nsp); + } + } + /*GraphPart nspd=defaultPart.getNextSuperPartPath(loopContinues); + if(nspd!=null){ + breakParts.add(nspd); + }*/ + + Collections.sort(breakParts, new Comparator() { + @Override + public int compare(GraphPart o1, GraphPart o2) { + return o2.path.length() - o1.path.length(); + } + }); + + GraphPart breakPart = breakParts.isEmpty() ? null : breakParts.get(0); + if ((defaultPart2 != breakPart) && (defaultCommands.isEmpty())) { + defaultPart = defaultPart2; + } + + + List caseValues = new ArrayList(); + for (int i = 0; i < caseBodyParts.size(); i++) { + if (caseValuesMap.containsKey(i)) { + caseValues.add(caseValuesMap.get(i)); + } else { + continue; + } + } + + List> caseCommands = new ArrayList>(); + GraphPart next = null; + + + + next = breakPart; + + TreeItem ti = checkLoop(next, stopPart, loops); + loops.add(new Loop(null, next)); + //switchLoc.getNextPartPath(new ArrayList()); + List valuesMapping = new ArrayList(); + List caseBodies = new ArrayList(); + for (int i = 0; i < caseValues.size(); i++) { + GraphPart cur = caseBodyParts.get(i); + if (!caseBodies.contains(cur)) { + caseBodies.add(cur); + } + valuesMapping.add(caseBodies.indexOf(cur)); + } + + + + + if (defaultPart == breakPart) { + defaultPart = null; + } + if ((defaultPart != null) && (defaultCommands.isEmpty())) { + defaultCommands = printGraph(registerNames, stack, allParts, null, defaultPart, next, loops, forFinalCommands); + } + + List ignored = new ArrayList(); + for (Loop l : loops) { + ignored.add(l.loopContinue); + } + + for (int i = 0; i < caseBodies.size(); i++) { + List cc = new ArrayList(); + GraphPart nextCase = null; + nextCase = next; + if (next != null) { + if (i < caseBodies.size() - 1) { + if (!caseBodies.get(i).leadsTo(caseBodies.get(i + 1), ignored)) { + cc.add(new BreakTreeItem(null, next.start)); + } else { + nextCase = caseBodies.get(i + 1); + } + } else if (!defaultCommands.isEmpty()) { + if (!caseBodies.get(i).leadsTo(defaultPart, ignored)) { + cc.add(new BreakTreeItem(null, next.start)); + } else { + nextCase = defaultPart; + } + } + } + cc.addAll(0, printGraph(registerNames, stack, allParts, null, caseBodies.get(i), nextCase, loops, forFinalCommands)); + if (cc.size() >= 2) { + if (cc.get(cc.size() - 1) instanceof BreakTreeItem) { + if ((cc.get(cc.size() - 2) instanceof ContinueTreeItem) || (cc.get(cc.size() - 2) instanceof BreakTreeItem)) { + cc.remove(cc.size() - 1); + } + } + } + caseCommands.add(cc); + } + + SwitchTreeItem sti = new SwitchTreeItem(null, next == null ? -1 : next.start, switchedObject, caseValues, caseCommands, defaultCommands, valuesMapping); + ret.add(sti); + + if (next != null) { + if (ti != null) { + ret.add(ti); + } else { + ret.addAll(printGraph(registerNames, stack, allParts, null, next, stopPart, loops, forFinalCommands)); + } + } + return ret; + } + } else { + /*ins.translate*/ + } + //((IfTypeIns)ins.definition).translateInverted(new HashMap(), co.stack, ins); + } + + int ip = part.start; + List loopContinues = new ArrayList(); + for (Loop l : loops) { + if (l.loopContinue != null) { + loopContinues.add(l.loopContinue); + } + } + boolean loop = false; + boolean reversed = false; + if ((!part.nextParts.isEmpty()) && part.nextParts.get(0).leadsTo(part, loopContinues)) { + loop = true; + } else if ((part.nextParts.size() > 1) && part.nextParts.get(1).leadsTo(part, loopContinues)) { + loop = true; + reversed = true; + } + if (((part.nextParts.size() == 2) || ((part.nextParts.size() == 1) && loop)) && (!isSwitch)) { + + boolean doWhile = loop; + if (loop && output.isEmpty()) { + doWhile = false; + } + Loop currentLoop = new Loop(part, null); + if (loop) { + loops.add(currentLoop); + } + + + + loopContinues = new ArrayList(); + for (Loop l : loops) { + if (l.loopContinue != null) { + loopContinues.add(l.loopContinue); + } + } + + if (part.nextParts.size() > 1) { + currentLoop.loopBreak = part.nextParts.get(reversed ? 0 : 1); + } + + forFinalCommands.put(currentLoop, new ArrayList()); + + int breakIp = -1; + if (currentLoop.loopBreak != null) { + breakIp = currentLoop.loopBreak.start; + } + TreeItem expr = null; + if ((code.get(part.end) instanceof ActionJump) || (!(code.get(part.end) instanceof ActionIf))) { + expr = new DirectValueTreeItem(null,-1, (Boolean) true, new ArrayList()); + } else { + if (stack.isEmpty()) { + } + expr = stack.pop(); + } + if (doWhile) { + ret.add(new DoWhileTreeItem(null, breakIp, part.start, output, expr)); + } else { + ret.addAll(output); + } + + GraphPart next = part.getNextPartPath(loopContinues); + + if (loop && (!doWhile)) { + + if (reversed && (expr instanceof LogicalOp)) { + expr = ((LogicalOp) expr).invert(); + } + List loopBody = null; + List finalCommands = null; + GraphPart finalPart = null; + loopBody = printGraph(registerNames, stack, allParts, part, part.nextParts.get(reversed ? 1 : 0), stopPart, loops, forFinalCommands); + + finalCommands = forFinalCommands.get(currentLoop); + if (!finalCommands.isEmpty()) { + ret.add(new ForTreeItem(null, breakIp, currentLoop.loopContinue.start, new ArrayList(), expr, finalCommands, loopBody)); + } /*else if ((expr instanceof HasNextTreeItem) && (!loopBody.isEmpty()) && (loopBody.get(0) instanceof SetTypeTreeItem) && (((SetTypeTreeItem) loopBody.get(0)).getValue().getNotCoerced() instanceof NextValueTreeItem)) { + TreeItem obj = ((SetTypeTreeItem) loopBody.get(0)).getObject(); + loopBody.remove(0); + ret.add(new ForEachInTreeItem(null, breakIp, part.start, new InTreeItem(expr.instruction, obj, ((HasNextTreeItem) expr).collection), loopBody)); + } else if ((expr instanceof HasNextTreeItem) && (!loopBody.isEmpty()) && (loopBody.get(0) instanceof SetTypeTreeItem) && (((SetTypeTreeItem) loopBody.get(0)).getValue().getNotCoerced() instanceof NextNameTreeItem)) { + TreeItem obj = ((SetTypeTreeItem) loopBody.get(0)).getObject(); + loopBody.remove(0); + ret.add(new ForInTreeItem(null, breakIp, part.start, new InTreeItem(expr.instruction, obj, ((HasNextTreeItem) expr).collection), loopBody)); + }*/ else { + ret.add(new WhileTreeItem(null, breakIp, part.start, expr, loopBody)); + } + } else if (!loop) { + if (expr instanceof LogicalOp) { + expr = ((LogicalOp) expr).invert(); + } else { + expr = new NotTreeItem(null, expr); + } + + int stackSizeBefore = stack.size(); + Stack trueStack = (Stack) stack.clone(); + Stack falseStack = (Stack) stack.clone(); + TreeItem lopTrue = checkLoop(part.nextParts.get(1), stopPart, loops); + TreeItem lopFalse = null; + if (next != part.nextParts.get(0)) { + lopFalse = checkLoop(part.nextParts.get(0), stopPart, loops); + } + List onTrue = new ArrayList(); + if (lopTrue != null) { + onTrue.add(lopTrue); + } else { + if (debugMode) { + System.err.println("ONTRUE: (inside " + part + ")"); + } + onTrue = printGraph(registerNames, trueStack, allParts, part, part.nextParts.get(1), next == null ? stopPart : next, loops, forFinalCommands); + if (debugMode) { + System.err.println("/ONTRUE (inside " + part + ")"); + } + } + List onFalse = new ArrayList(); + if (lopFalse != null) { + onFalse.add(lopFalse); + } else { + if (debugMode) { + System.err.println("ONFALSE: (inside " + part + ")"); + } + onFalse = (((next == part.nextParts.get(0)) || (part.nextParts.get(0).path.equals(part.path) || part.nextParts.get(0).path.length() < part.path.length())) ? new ArrayList() : printGraph(registerNames, falseStack, allParts, part, part.nextParts.get(0), next == null ? stopPart : next, loops, forFinalCommands)); + if (debugMode) { + System.err.println("/ONFALSE (inside " + part + ")"); + } + } + + if (onTrue.isEmpty() && onFalse.isEmpty() && (trueStack.size() > stackSizeBefore) && (falseStack.size() > stackSizeBefore)) { + stack.push(new TernarOpTreeItem(null, expr, trueStack.pop(), falseStack.pop())); + } else { + ret.add(new IfTreeItem(null, expr, onTrue, onFalse)); + + //Same continues in onTrue and onFalse gets continue on parent level + if ((!onTrue.isEmpty()) && (!onFalse.isEmpty())) { + if (onTrue.get(onTrue.size() - 1) instanceof ContinueTreeItem) { + if (onFalse.get(onFalse.size() - 1) instanceof ContinueTreeItem) { + if (((ContinueTreeItem) onTrue.get(onTrue.size() - 1)).loopPos == ((ContinueTreeItem) onFalse.get(onFalse.size() - 1)).loopPos) { + onTrue.remove(onTrue.size() - 1); + ret.add(onFalse.remove(onFalse.size() - 1)); + } + } + } + } + } + } + if (loop && (part.nextParts.size() > 1)) { + loops.remove(currentLoop); //remove loop so no break shows up + ret.addAll(printGraph(registerNames, stack, allParts, part, part.nextParts.get(reversed ? 0 : 1), stopPart, loops, forFinalCommands)); + } + + if (next != null) { + TreeItem ti = checkLoop(next, stopPart, loops); + if (ti != null) { + ret.add(ti); + } else { + if (debugMode) { + System.err.println("NEXT: (inside " + part + ")"); + } + ret.addAll(printGraph(registerNames, stack, allParts, part, next, stopPart, loops, forFinalCommands)); + if (debugMode) { + System.err.println("/NEXT: (inside " + part + ")"); + } + } + + } + } else { + ret.addAll(output); + } + onepart: + if (part.nextParts.size() == 1 && (!loop)) { + + + GraphPart p = part.nextParts.get(0); + TreeItem lop = checkLoop(p, stopPart, loops); + if (lop == null) { + if (p.path.length() == part.path.length()) { + ret.addAll(printGraph(registerNames, stack, allParts, part, p, stopPart, loops, forFinalCommands)); + } else { + if ((p != stopPart) && (p.refs.size() > 1)) { + List nextList = new ArrayList(); + populateParts(p, nextList); + Loop nearestLoop = null; + loopn: + for (GraphPart n : nextList) { + for (Loop l : loops) { + if (l.loopContinue == n) { + nearestLoop = l; + break loopn; + } + } + } + if ((nearestLoop != null) && (nearestLoop.loopBreak != null)) { + List finalCommands = printGraph(registerNames, stack, allParts, part, p, nearestLoop.loopContinue, loops, forFinalCommands); + nearestLoop.loopContinue = p; + forFinalCommands.put(nearestLoop, finalCommands); + ContinueTreeItem cti = new ContinueTreeItem(null, nearestLoop.loopBreak.start); + ret.add(cti); + } + } + } + } else { + ret.add(lop); + } + } + return ret; + } + private List posCache; + + private void buildCache() { + posCache = new ArrayList(); + int pos = 0; + for (int i = 0; i < code.size(); i++) { + posCache.add(pos); + pos += code.get(i).getBytes(version).length; + } + posCache.add(pos); + } + + private int pos2adr(int pos) { + if (posCache == null) { + buildCache(); + } + return posCache.get(pos); + } + + private int adr2pos(int adr) { + if (posCache == null) { + buildCache(); + } + return posCache.indexOf(adr); + } + + private void visitCode(int ip, int lastIp, HashMap> refs) { + while (ip < code.size()) { + refs.get(ip).add(lastIp); + lastIp = ip; + if (refs.get(ip).size() > 1) { + break; + } + Action ins = code.get(ip); + if (ins instanceof ActionThrow) { + break; + } + if (ins instanceof ActionReturn) { + break; + } + + /*if (ins.definition instanceof LookupSwitchIns) { + try { + for (int i = 2; i < ins.operands.length; i++) { + visitCode(adr2pos(pos2adr(ip) + ins.operands[i]), ip, refs); + } + ip = adr2pos(pos2adr(ip) + ins.operands[0]); + continue; + } catch (ConvertException ex) { + } + }*/ + if (ins instanceof ActionJump) { + ip = adr2pos(pos2adr(ip) + ins.getBytes(version).length + ((ActionJump) ins).offset); + continue; + } else if (ins instanceof ActionIf) { + visitCode(adr2pos(pos2adr(ip) + ins.getBytes(version).length + ((ActionIf) ins).offset), ip, refs); + } + ip++; + }; + } + + public HashMap> visitCode() { + HashMap> refs = new HashMap>(); + for (int i = 0; i < code.size(); i++) { + refs.put(i, new ArrayList()); + } + visitCode(0, 0, refs); + return refs; + } + + private List makeGraph(List actions, List allBlocks) { + HashMap> refs = visitCode(); + List ret = new ArrayList(); + boolean visited[] = new boolean[code.size()]; + ret.add(makeGraph(null, "0", code, 0, 0, allBlocks, refs, visited)); + return ret; + } + + private GraphPart makeGraph(GraphPart parent, String path, List code, int startip, int lastIp, List allBlocks, HashMap> refs, boolean visited2[]) { + + int ip = startip; + for (GraphPart p : allBlocks) { + if (p.start == ip) { + p.refs.add(parent); + return p; + } + } + GraphPart g; + GraphPart ret = new GraphPart(ip, -1); + ret.path = path; + GraphPart part = ret; + while (ip < code.size()) { + if (visited2[ip] || ((ip != startip) && (refs.get(ip).size() > 1))) { + part.end = lastIp; + GraphPart found = null; + for (GraphPart p : allBlocks) { + if (p.start == ip) { + found = p; + break; + } + } + + allBlocks.add(part); + + if (found != null) { + part.nextParts.add(found); + found.refs.add(part); + break; + } else { + GraphPart gp = new GraphPart(ip, -1); + gp.path = path; + part.nextParts.add(gp); + gp.refs.add(part); + part = gp; + } + } + lastIp = ip; + Action ins = code.get(ip); + if ((ins instanceof ActionThrow) || (ins instanceof ActionReturn)) { + part.end = ip; + allBlocks.add(part); + break; + } + /*if (ins.definition instanceof LookupSwitchIns) { + part.end = ip; + allBlocks.add(part); + try { + part.nextParts.add(g = makeGraph(part, path + "0", code, code.adr2pos(code.pos2adr(ip) + ins.operands[0]), ip, allBlocks, refs, visited2)); + g.refs.add(part); + for (int i = 2; i < ins.operands.length; i++) { + part.nextParts.add(g = makeGraph(part, path + (i - 1), code, code.adr2pos(code.pos2adr(ip) + ins.operands[i]), ip, allBlocks, refs, visited2)); + g.refs.add(part); + } + break; + } catch (ConvertException ex) { + } + }*/ + if (ins instanceof ActionJump) { + part.end = ip; + allBlocks.add(part); + int newip = adr2pos(pos2adr(ip) + ins.getBytes(version).length + ((ActionJump) ins).offset); + part.nextParts.add(g = makeGraph(part, path, code, newip, lastIp, allBlocks, refs, visited2)); + g.refs.add(part); + break; + } else if (ins instanceof ActionIf) { + part.end = ip; + allBlocks.add(part); + part.nextParts.add(g = makeGraph(part, path + "0", code, adr2pos(pos2adr(ip) + ins.getBytes(version).length + ((ActionIf) ins).offset), ip, allBlocks, refs, visited2)); + g.refs.add(part); + part.nextParts.add(g = makeGraph(part, path + "1", code, ip + 1, ip, allBlocks, refs, visited2)); + g.refs.add(part); + + break; + } + ip++; + }; + if (ip == code.size()) { + allBlocks.add(part); + if (part.start == ip) { + part.end = ip; + } else { + part.end = code.size() - 1; + part.nextParts.add(makeGraph(part, path, code, ip, ip, allBlocks, refs, visited2)); + } + + } + return ret; + } +} diff --git a/trunk/src/com/jpexs/asdec/action/IgnoredPair.java b/trunk/src/com/jpexs/asdec/action/IgnoredPair.java new file mode 100644 index 000000000..03b7b3632 --- /dev/null +++ b/trunk/src/com/jpexs/asdec/action/IgnoredPair.java @@ -0,0 +1,16 @@ +package com.jpexs.asdec.action; + +/** + * + * @author JPEXS + */ +public class IgnoredPair { + public Action action; + public int pos; + + public IgnoredPair(Action action, int pos) { + this.action = action; + this.pos = pos; + } + +} diff --git a/trunk/src/com/jpexs/asdec/action/flashlite/ActionFSCommand2.java b/trunk/src/com/jpexs/asdec/action/flashlite/ActionFSCommand2.java index b7e220762..7afd2b673 100644 --- a/trunk/src/com/jpexs/asdec/action/flashlite/ActionFSCommand2.java +++ b/trunk/src/com/jpexs/asdec/action/flashlite/ActionFSCommand2.java @@ -36,7 +36,7 @@ public class ActionFSCommand2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { long numArgs = popLong(stack); TreeItem command = stack.pop(); List args = new ArrayList(); diff --git a/trunk/src/com/jpexs/asdec/action/flashlite/ActionStrictMode.java b/trunk/src/com/jpexs/asdec/action/flashlite/ActionStrictMode.java index a5dc876bb..a29ec1f0c 100644 --- a/trunk/src/com/jpexs/asdec/action/flashlite/ActionStrictMode.java +++ b/trunk/src/com/jpexs/asdec/action/flashlite/ActionStrictMode.java @@ -61,7 +61,7 @@ public class ActionStrictMode extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new StrictModeTreeItem(this, mode)); } } diff --git a/trunk/src/com/jpexs/asdec/action/gui/ActionPanel.java b/trunk/src/com/jpexs/asdec/action/gui/ActionPanel.java index b7335f7e4..a8d27e10e 100644 --- a/trunk/src/com/jpexs/asdec/action/gui/ActionPanel.java +++ b/trunk/src/com/jpexs/asdec/action/gui/ActionPanel.java @@ -18,7 +18,9 @@ package com.jpexs.asdec.action.gui; import com.jpexs.asdec.Main; import com.jpexs.asdec.SWF; +import com.jpexs.asdec.abc.gui.GraphFrame; import com.jpexs.asdec.abc.gui.LineMarkedEditorPane; +import com.jpexs.asdec.action.ActionGraph; import com.jpexs.asdec.action.TagNode; import com.jpexs.asdec.action.parser.ASMParser; import com.jpexs.asdec.action.parser.ParseException; @@ -54,6 +56,7 @@ public class ActionPanel extends JPanel implements TreeSelectionListener, Action public JButton saveButton = new JButton("Save"); public JButton editButton = new JButton("Edit"); public JButton cancelButton = new JButton("Cancel"); + public JButton graphButton = new JButton("Graph"); public JButton saveHexButton = new JButton("Save hex"); public JButton loadHexButton = new JButton("Load hex"); public JLabel asmLabel = new JLabel("P-code source"); @@ -63,6 +66,7 @@ public class ActionPanel extends JPanel implements TreeSelectionListener, Action private String lastDisasm = ""; private boolean ignoreCarret = false; private boolean editMode = false; + private List lastCode; public ActionPanel(List list) { this.list = list; @@ -92,10 +96,13 @@ public class ActionPanel extends JPanel implements TreeSelectionListener, Action buttonsPan.add(editButton); buttonsPan.add(saveButton); buttonsPan.add(cancelButton); + buttonsPan.add(graphButton); //buttonsPan.add(saveHexButton); //buttonsPan.add(loadHexButton); panB.add(buttonsPan, BorderLayout.SOUTH); + graphButton.addActionListener(this); + graphButton.setActionCommand("GRAPH"); saveHexButton.addActionListener(this); saveHexButton.setActionCommand("SAVEHEXACTION"); loadHexButton.addActionListener(this); @@ -207,6 +214,7 @@ public class ActionPanel extends JPanel implements TreeSelectionListener, Action editor.setText(lastDisasm); if (Main.DO_DECOMPILE) { List as = asm.getActions(SWF.DEFAULT_VERSION); + lastCode = as; com.jpexs.asdec.action.Action.setActionsAddresses(as, 0, SWF.DEFAULT_VERSION); decompiledEditor.setText("//Decompiling..."); String s = com.jpexs.asdec.action.Action.actionsToSource(as, SWF.DEFAULT_VERSION); @@ -258,7 +266,12 @@ public class ActionPanel extends JPanel implements TreeSelectionListener, Action } public void actionPerformed(ActionEvent e) { - if (e.getActionCommand().equals("EDITACTION")) { + if (e.getActionCommand().equals("GRAPH")) { + if (lastCode != null) { + GraphFrame gf = new GraphFrame(new ActionGraph(lastCode, SWF.DEFAULT_VERSION), ""); + gf.setVisible(true); + } + } else if (e.getActionCommand().equals("EDITACTION")) { setEditMode(true); } else if (e.getActionCommand().equals("CANCELACTION")) { setEditMode(false); diff --git a/trunk/src/com/jpexs/asdec/action/parser/ASMParser.java b/trunk/src/com/jpexs/asdec/action/parser/ASMParser.java index 0ad415ea8..373127188 100644 --- a/trunk/src/com/jpexs/asdec/action/parser/ASMParser.java +++ b/trunk/src/com/jpexs/asdec/action/parser/ASMParser.java @@ -19,6 +19,7 @@ package com.jpexs.asdec.action.parser; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.flashlite.ActionFSCommand2; import com.jpexs.asdec.action.flashlite.ActionStrictMode; +import com.jpexs.asdec.action.special.ActionNop; import com.jpexs.asdec.action.swf3.*; import com.jpexs.asdec.action.swf4.*; import com.jpexs.asdec.action.swf5.*; @@ -243,6 +244,8 @@ public class ASMParser { list.add(new ActionFSCommand2()); } else if (instructionName.equals("StrictMode".toLowerCase())) { list.add(new ActionStrictMode(lexer)); + } else if (instructionName.equals("Nop".toLowerCase())) { + list.add(new ActionNop()); } else { throw new ParseException("Unknown instruction name :" + instructionName, lexer.yyline()); } diff --git a/trunk/src/com/jpexs/asdec/action/special/ActionNop.java b/trunk/src/com/jpexs/asdec/action/special/ActionNop.java index f100fa3ca..870e8c63e 100644 --- a/trunk/src/com/jpexs/asdec/action/special/ActionNop.java +++ b/trunk/src/com/jpexs/asdec/action/special/ActionNop.java @@ -35,7 +35,7 @@ public class ActionNop extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { - output.add(new SimpleActionTreeItem(this, "nop();")); + public void translate(Stack stack, List output, java.util.HashMap regNames) { + //output.add(new SimpleActionTreeItem(this, "nop();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionGetURL.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionGetURL.java index c93119947..1a85f04f9 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionGetURL.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionGetURL.java @@ -69,7 +69,7 @@ public class ActionGetURL extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new GetURLTreeItem(this, urlString, targetString)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionGoToLabel.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionGoToLabel.java index 430a42525..c0a7cf607 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionGoToLabel.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionGoToLabel.java @@ -65,7 +65,7 @@ public class ActionGoToLabel extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new GotoLabelTreeItem(this, label)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionGotoFrame.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionGotoFrame.java index 671a61b50..6e38db7b2 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionGotoFrame.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionGotoFrame.java @@ -61,7 +61,7 @@ public class ActionGotoFrame extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new GotoFrameTreeItem(this, frame)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionNextFrame.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionNextFrame.java index a97374096..896d3377b 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionNextFrame.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionNextFrame.java @@ -35,7 +35,7 @@ public class ActionNextFrame extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "nextFrame();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionPlay.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionPlay.java index 405b53377..18fbfbe9a 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionPlay.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionPlay.java @@ -35,7 +35,7 @@ public class ActionPlay extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "Play();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionPrevFrame.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionPrevFrame.java index 34168ec42..c6d59ef0c 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionPrevFrame.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionPrevFrame.java @@ -35,7 +35,7 @@ public class ActionPrevFrame extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "prevFrame();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionSetTarget.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionSetTarget.java index 71ebb6877..f72739d4e 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionSetTarget.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionSetTarget.java @@ -65,7 +65,7 @@ public class ActionSetTarget extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SetTargetTreeItem(this, targetName)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionStop.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionStop.java index f512f4332..64b8e55b1 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionStop.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionStop.java @@ -35,7 +35,7 @@ public class ActionStop extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "stop();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionStopSounds.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionStopSounds.java index 968decd36..c1bd950ec 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionStopSounds.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionStopSounds.java @@ -35,7 +35,7 @@ public class ActionStopSounds extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "stopAllSounds();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionToggleQuality.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionToggleQuality.java index d40fa9d36..deac40131 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionToggleQuality.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionToggleQuality.java @@ -35,7 +35,7 @@ public class ActionToggleQuality extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "toggleHighQuality();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf3/ActionWaitForFrame.java b/trunk/src/com/jpexs/asdec/action/swf3/ActionWaitForFrame.java index b0ebec076..547b8f474 100644 --- a/trunk/src/com/jpexs/asdec/action/swf3/ActionWaitForFrame.java +++ b/trunk/src/com/jpexs/asdec/action/swf3/ActionWaitForFrame.java @@ -65,7 +65,7 @@ public class ActionWaitForFrame extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new WaitForFrameTreeItem(this, frame, skipCount)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionAdd.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionAdd.java index a957b362e..6a329f28a 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionAdd.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionAdd.java @@ -35,7 +35,7 @@ public class ActionAdd extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new AddTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionAnd.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionAnd.java index 320e793b4..0d97db802 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionAnd.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionAnd.java @@ -35,7 +35,7 @@ public class ActionAnd extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new AndTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionAsciiToChar.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionAsciiToChar.java index df48e2653..42d811689 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionAsciiToChar.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionAsciiToChar.java @@ -35,7 +35,7 @@ public class ActionAsciiToChar extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new AsciiToCharTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionCall.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionCall.java index 59321e43f..628493d19 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionCall.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionCall.java @@ -35,7 +35,7 @@ public class ActionCall extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new CallTreeItem(this, stack.pop())); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionCharToAscii.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionCharToAscii.java index f95c1256a..5561d3b7a 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionCharToAscii.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionCharToAscii.java @@ -35,7 +35,7 @@ public class ActionCharToAscii extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new CharToAsciiTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionCloneSprite.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionCloneSprite.java index b12f31d52..77ea00cdc 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionCloneSprite.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionCloneSprite.java @@ -35,7 +35,7 @@ public class ActionCloneSprite extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem depth = stack.pop(); TreeItem target = stack.pop(); TreeItem source = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionDivide.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionDivide.java index bd7db8c66..ff75a9362 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionDivide.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionDivide.java @@ -35,7 +35,7 @@ public class ActionDivide extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new DivideTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionEndDrag.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionEndDrag.java index 5745dee24..8af8fbcf3 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionEndDrag.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionEndDrag.java @@ -35,7 +35,7 @@ public class ActionEndDrag extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { output.add(new SimpleActionTreeItem(this, "stopDrag();")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionEquals.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionEquals.java index 08c3a540f..d7916a3f4 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionEquals.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionEquals.java @@ -35,7 +35,7 @@ public class ActionEquals extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new EqTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetProperty.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetProperty.java index b98002ae0..48fdc0ccf 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetProperty.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetProperty.java @@ -36,7 +36,7 @@ public class ActionGetProperty extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem index = stack.pop(); TreeItem target = stack.pop(); int indexInt = 0; diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetTime.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetTime.java index 397ea7372..f296f42e5 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetTime.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetTime.java @@ -35,7 +35,7 @@ public class ActionGetTime extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { stack.push(new SimpleActionTreeItem(this, "getTimer()")); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetURL2.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetURL2.java index a8430add4..63795670c 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetURL2.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetURL2.java @@ -73,7 +73,7 @@ public class ActionGetURL2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem targetString = stack.pop(); TreeItem urlString = stack.pop(); output.add(new GetURL2TreeItem(this, urlString, targetString, sendVarsMethod, loadTargetFlag, loadTargetFlag)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetVariable.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetVariable.java index cd540e992..cbb0522f6 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionGetVariable.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionGetVariable.java @@ -35,7 +35,7 @@ public class ActionGetVariable extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); stack.push(new GetVariableTreeItem(this, value)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionGotoFrame2.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionGotoFrame2.java index 53d0c5251..4f6cb4b54 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionGotoFrame2.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionGotoFrame2.java @@ -77,7 +77,7 @@ public class ActionGotoFrame2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem frame = stack.pop(); output.add(new GotoFrame2TreeItem(this, frame, sceneBiasFlag, playFlag, sceneBias)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionLess.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionLess.java index 79f2692e1..227716525 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionLess.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionLess.java @@ -35,7 +35,7 @@ public class ActionLess extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new LtTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBAsciiToChar.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBAsciiToChar.java index 558656900..b2cd7d4ea 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBAsciiToChar.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBAsciiToChar.java @@ -35,7 +35,7 @@ public class ActionMBAsciiToChar extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new MBAsciiToCharTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBCharToAscii.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBCharToAscii.java index a7a5188fd..4216068c2 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBCharToAscii.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBCharToAscii.java @@ -35,7 +35,7 @@ public class ActionMBCharToAscii extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new MBCharToAsciiTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringExtract.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringExtract.java index bcc310567..2ea1a24a1 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringExtract.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringExtract.java @@ -35,7 +35,7 @@ public class ActionMBStringExtract extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem count = stack.pop(); TreeItem index = stack.pop(); TreeItem value = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringLength.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringLength.java index da0bf0f6c..76a47bdbd 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringLength.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionMBStringLength.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.swf4; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.TreeItem; -import com.jpexs.asdec.action.treemodel.operations.MBStringLengthTreeItem; +import com.jpexs.asdec.action.treemodel.MBStringLengthTreeItem; import java.util.List; import java.util.Stack; @@ -35,7 +35,7 @@ public class ActionMBStringLength extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new MBStringLengthTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionMultiply.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionMultiply.java index 890d461cf..32b4cf2ae 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionMultiply.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionMultiply.java @@ -35,7 +35,7 @@ public class ActionMultiply extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new MultiplyTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionNot.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionNot.java index a9508c426..4f6861cfe 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionNot.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionNot.java @@ -35,7 +35,7 @@ public class ActionNot extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new NotTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionOr.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionOr.java index 430c8e121..7b2b8a2bd 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionOr.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionOr.java @@ -35,7 +35,7 @@ public class ActionOr extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new OrTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionPop.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionPop.java index 336817790..a5a53b520 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionPop.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionPop.java @@ -17,6 +17,8 @@ package com.jpexs.asdec.action.swf4; import com.jpexs.asdec.action.Action; +import com.jpexs.asdec.action.treemodel.CallFunctionTreeItem; +import com.jpexs.asdec.action.treemodel.CallMethodTreeItem; import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.DirectValueTreeItem; import com.jpexs.asdec.action.treemodel.TreeItem; @@ -36,13 +38,16 @@ public class ActionPop extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { if (stack.isEmpty()) { return; } TreeItem val = stack.pop(); - if (!(val instanceof DirectValueTreeItem)) { - output.add(new VoidTreeItem(this, val)); + if((val instanceof CallFunctionTreeItem)||(val instanceof CallMethodTreeItem)){ + output.add(val); } + /*if (!(val instanceof DirectValueTreeItem)) { + output.add(new VoidTreeItem(this, val)); + }*/ } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionPush.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionPush.java index 2e5acfc6c..58a9cbd08 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionPush.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionPush.java @@ -37,6 +37,7 @@ public class ActionPush extends Action { public List values; public List constantPool; + public List ignoredParts=new ArrayList(); public ActionPush(int actionLength, SWFInputStream sis, int version) throws IOException { super(0x96, actionLength); @@ -177,10 +178,15 @@ public class ActionPush extends Action { @Override public String toString() { String ret = "Push "; + int pos=0; for (int i = 0; i < values.size(); i++) { - if (i > 0) { + if(ignoredParts.contains(i)){ + continue; + } + if (pos > 0) { ret += " "; } + pos++; if (values.get(i) instanceof ConstantIndex) { ((ConstantIndex) values.get(i)).constantPool = constantPool; ret += ((ConstantIndex) values.get(i)).toString(); @@ -198,13 +204,14 @@ public class ActionPush extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { + int pos=0; for (Object o : values) { if (o instanceof ConstantIndex) { - if((constants==null)||(((ConstantIndex) o).index>=constants.constants.size())){ + if((constantPool==null)||(((ConstantIndex) o).index>=constantPool.size())){ o="CONSTNOTFOUND"; }else{ - o = constants.constants.get(((ConstantIndex) o).index); + o = constantPool.get(((ConstantIndex) o).index); } } if (o instanceof RegisterNumber) { @@ -212,7 +219,8 @@ public class ActionPush extends Action { ((RegisterNumber) o).name = regNames.get(((RegisterNumber) o).number); } } - stack.push(new DirectValueTreeItem(this, o, constants)); + stack.push(new DirectValueTreeItem(this, pos,o, constantPool)); + pos++; } } } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionRandomNumber.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionRandomNumber.java index 4a3375797..75805c1b2 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionRandomNumber.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionRandomNumber.java @@ -35,7 +35,7 @@ public class ActionRandomNumber extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem maximum = stack.pop(); stack.push(new RandomNumberTreeItem(this, maximum)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionRemoveSprite.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionRemoveSprite.java index d9f59f591..c577965b3 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionRemoveSprite.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionRemoveSprite.java @@ -35,7 +35,7 @@ public class ActionRemoveSprite extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem target = stack.pop(); output.add(new RemoveSpriteTreeItem(this, target)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetProperty.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetProperty.java index 5a4e459b6..a34feeae0 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetProperty.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetProperty.java @@ -36,7 +36,7 @@ public class ActionSetProperty extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); TreeItem index = stack.pop(); TreeItem target = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetTarget2.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetTarget2.java index eaa3911be..3a8226c99 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetTarget2.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetTarget2.java @@ -35,7 +35,7 @@ public class ActionSetTarget2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem target = stack.pop(); output.add(new SetTarget2TreeItem(this, target)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetVariable.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetVariable.java index 1e9402965..a9ff5bb33 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionSetVariable.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionSetVariable.java @@ -35,7 +35,7 @@ public class ActionSetVariable extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); TreeItem name = stack.pop(); output.add(new SetVariableTreeItem(this, name, value)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStartDrag.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStartDrag.java index 368c7ab0a..ca74885ef 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStartDrag.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStartDrag.java @@ -36,7 +36,7 @@ public class ActionStartDrag extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem target = stack.pop(); TreeItem lockCenter = stack.pop(); TreeItem constrain = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringAdd.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringAdd.java index 23865f775..8ddbc7b27 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringAdd.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringAdd.java @@ -35,7 +35,7 @@ public class ActionStringAdd extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new StringAddTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringEquals.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringEquals.java index 803585cb0..5dc5c0297 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringEquals.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringEquals.java @@ -35,7 +35,7 @@ public class ActionStringEquals extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new StringEqTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringExtract.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringExtract.java index 48ae649e4..619051b91 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringExtract.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringExtract.java @@ -35,7 +35,7 @@ public class ActionStringExtract extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem count = stack.pop(); TreeItem index = stack.pop(); TreeItem value = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLength.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLength.java index e944f2425..d03c75d43 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLength.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLength.java @@ -35,7 +35,7 @@ public class ActionStringLength extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new StringLengthTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLess.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLess.java index 4b6a23de5..db2a8d228 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLess.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionStringLess.java @@ -35,7 +35,7 @@ public class ActionStringLess extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new StringLtTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionSubtract.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionSubtract.java index dcb415f47..d9fa1e6d8 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionSubtract.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionSubtract.java @@ -35,7 +35,7 @@ public class ActionSubtract extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new SubtractTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionToInteger.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionToInteger.java index 645689e3d..cbf83b57d 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionToInteger.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionToInteger.java @@ -35,7 +35,7 @@ public class ActionToInteger extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new ToIntegerTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionTrace.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionTrace.java index 44e99a082..8c1bf060e 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionTrace.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionTrace.java @@ -35,7 +35,7 @@ public class ActionTrace extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); output.add(new TraceTreeItem(this, value)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/ActionWaitForFrame2.java b/trunk/src/com/jpexs/asdec/action/swf4/ActionWaitForFrame2.java index 384c4e5f9..8ffa8682f 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/ActionWaitForFrame2.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/ActionWaitForFrame2.java @@ -61,7 +61,7 @@ public class ActionWaitForFrame2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem frame = stack.pop(); output.add(new WaitForFrame2TreeItem(this, frame, skipCount)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf4/RegisterNumber.java b/trunk/src/com/jpexs/asdec/action/swf4/RegisterNumber.java index d5408bc31..abf3e2f76 100644 --- a/trunk/src/com/jpexs/asdec/action/swf4/RegisterNumber.java +++ b/trunk/src/com/jpexs/asdec/action/swf4/RegisterNumber.java @@ -27,7 +27,7 @@ public class RegisterNumber { @Override public String toString() { - if (name == null) { + if (name == null || name.trim().equals("")) { return "register" + number; } return name; diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionAdd2.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionAdd2.java index e829a44dd..6c810fcac 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionAdd2.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionAdd2.java @@ -35,7 +35,7 @@ public class ActionAdd2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new AddTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitAnd.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitAnd.java index 1f72dbe85..5f4a6c1b4 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitAnd.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitAnd.java @@ -35,7 +35,7 @@ public class ActionBitAnd extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new BitAndTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitLShift.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitLShift.java index 9934d8bce..55504c426 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitLShift.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitLShift.java @@ -35,7 +35,7 @@ public class ActionBitLShift extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new LShiftTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitOr.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitOr.java index 0ce095a77..27c3d4989 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitOr.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitOr.java @@ -35,7 +35,7 @@ public class ActionBitOr extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new BitOrTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitRShift.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitRShift.java index b04ef0f13..3c66ba539 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitRShift.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitRShift.java @@ -35,7 +35,7 @@ public class ActionBitRShift extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new RShiftTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitURShift.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitURShift.java index d318d5ebc..99550b2b4 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitURShift.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitURShift.java @@ -35,7 +35,7 @@ public class ActionBitURShift extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new URShiftTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitXor.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitXor.java index a327f88f0..31d6ffd27 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionBitXor.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionBitXor.java @@ -35,7 +35,7 @@ public class ActionBitXor extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new BitXorTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionCallFunction.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionCallFunction.java index c1f512a30..0b70b9312 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionCallFunction.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionCallFunction.java @@ -36,7 +36,7 @@ public class ActionCallFunction extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem functionName = stack.pop(); long numArgs = popLong(stack); List args = new ArrayList(); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionCallMethod.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionCallMethod.java index 9cc4e5473..d28935aee 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionCallMethod.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionCallMethod.java @@ -36,7 +36,7 @@ public class ActionCallMethod extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem methodName = stack.pop(); TreeItem scriptObject = stack.pop(); long numArgs = popLong(stack); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionConstantPool.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionConstantPool.java index 72f993d74..50668666c 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionConstantPool.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionConstantPool.java @@ -86,7 +86,7 @@ public class ActionConstantPool extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { - constants.constants = constantPool; + public void translate(Stack stack, List output, java.util.HashMap regNames) { + } } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDecrement.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDecrement.java index db1d7deea..c42e91183 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDecrement.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDecrement.java @@ -35,7 +35,7 @@ public class ActionDecrement extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new DecrementTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineFunction.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineFunction.java index 9190140f6..813d30de9 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineFunction.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineFunction.java @@ -44,8 +44,10 @@ public class ActionDefineFunction extends Action { public List code; public int codeSize; private int version; + public List constantPool; public void setConstantPool(List constantPool){ + this.constantPool=constantPool; for(Action a:code){ if(a instanceof ActionPush){ ((ActionPush)a).constantPool=constantPool; @@ -152,7 +154,14 @@ public class ActionDefineFunction extends Action { @Override - public void translate(Stack stack, ConstantPool constants, List output, HashMap regNames) { - stack.push(new FunctionTreeItem(this, functionName, paramNames, Action.actionsToTree(regNames, code,version ), constants)); + public void translate(Stack stack, List output, HashMap regNames) { + stack.push(new FunctionTreeItem(this, functionName, paramNames, Action.actionsToTree(regNames, code,version ), constantPool,1)); } + + @Override + public String toString() { + return "DefineFunction"; + } + + } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal.java index 28c0f8321..ebdf63734 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal.java @@ -35,7 +35,7 @@ public class ActionDefineLocal extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); TreeItem name = stack.pop(); output.add(new DefineLocalTreeItem(this, name, value)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal2.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal2.java index 07d0e0311..7b4fa7ae6 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal2.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDefineLocal2.java @@ -35,7 +35,7 @@ public class ActionDefineLocal2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem name = stack.pop(); output.add(new DefineLocalTreeItem(this, name, null)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete.java index 4259ac5d1..7df130f2a 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete.java @@ -21,6 +21,7 @@ import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.DeleteTreeItem; import com.jpexs.asdec.action.treemodel.DirectValueTreeItem; import com.jpexs.asdec.action.treemodel.TreeItem; +import java.util.ArrayList; import java.util.List; import java.util.Stack; @@ -36,11 +37,11 @@ public class ActionDelete extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem propertyName = stack.pop(); TreeItem object = stack.pop(); output.add(new DeleteTreeItem(this, object, propertyName)); - stack.push(new DirectValueTreeItem(this, Boolean.TRUE, constants)); + stack.push(new DirectValueTreeItem(this,-1, Boolean.TRUE, new ArrayList())); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete2.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete2.java index bf4493cab..c3cdb1b46 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete2.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionDelete2.java @@ -21,6 +21,7 @@ import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.DeleteTreeItem; import com.jpexs.asdec.action.treemodel.DirectValueTreeItem; import com.jpexs.asdec.action.treemodel.TreeItem; +import java.util.ArrayList; import java.util.List; import java.util.Stack; @@ -36,10 +37,10 @@ public class ActionDelete2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem propertyName = stack.pop(); output.add(new DeleteTreeItem(this, null, propertyName)); - stack.push(new DirectValueTreeItem(this, Boolean.TRUE, constants)); + stack.push(new DirectValueTreeItem(this,-1, Boolean.TRUE, new ArrayList())); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionEnumerate.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionEnumerate.java index 588a0a3f6..dd982be27 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionEnumerate.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionEnumerate.java @@ -35,7 +35,7 @@ public class ActionEnumerate extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new EnumerateTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionEquals2.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionEquals2.java index 1a3a63553..f0b37edbb 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionEquals2.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionEquals2.java @@ -35,7 +35,7 @@ public class ActionEquals2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new EqTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionGetMember.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionGetMember.java index b57d89991..ff2cdf765 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionGetMember.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionGetMember.java @@ -35,7 +35,7 @@ public class ActionGetMember extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem functionName = stack.pop(); TreeItem object = stack.pop(); stack.push(new GetMemberTreeItem(this, object, functionName)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionIncrement.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionIncrement.java index ad34b5139..13b894a00 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionIncrement.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionIncrement.java @@ -35,7 +35,7 @@ public class ActionIncrement extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); stack.push(new IncrementTreeItem(this, a)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionInitArray.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionInitArray.java index d69f24a1d..cfe39490c 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionInitArray.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionInitArray.java @@ -31,7 +31,7 @@ public class ActionInitArray extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { long numArgs = popLong(stack); List args = new ArrayList(); for (int l = 0; l < numArgs; l++) { diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionInitObject.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionInitObject.java index c9562d653..1904561c5 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionInitObject.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionInitObject.java @@ -36,7 +36,7 @@ public class ActionInitObject extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { long numArgs = popLong(stack); List values = new ArrayList(); List names = new ArrayList(); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionLess2.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionLess2.java index 4c9d49bc6..ee7f60a8c 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionLess2.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionLess2.java @@ -35,7 +35,7 @@ public class ActionLess2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new LtTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionModulo.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionModulo.java index 080c814be..e6e9f4557 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionModulo.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionModulo.java @@ -35,7 +35,7 @@ public class ActionModulo extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new ModuloTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionNewMethod.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionNewMethod.java index 5c60b1b86..5b5b1549f 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionNewMethod.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionNewMethod.java @@ -36,7 +36,7 @@ public class ActionNewMethod extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem methodName = stack.pop(); TreeItem scriptObject = stack.pop(); long numArgs = popLong(stack); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionNewObject.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionNewObject.java index 4e6dfca13..ca0c18059 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionNewObject.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionNewObject.java @@ -36,7 +36,7 @@ public class ActionNewObject extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem objectName = stack.pop(); long numArgs = popLong(stack); List args = new ArrayList(); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionPushDuplicate.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionPushDuplicate.java index e567089d1..16f31e0ef 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionPushDuplicate.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionPushDuplicate.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.swf5; import com.jpexs.asdec.action.Action; +import com.jpexs.asdec.action.IgnoredPair; import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.TreeItem; import java.util.List; @@ -34,9 +35,10 @@ public class ActionPushDuplicate extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); stack.push(value); stack.push(value); + value.moreInstructions.add(new IgnoredPair(this,0)); } } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionReturn.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionReturn.java index 47ec6ba38..4f15527a5 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionReturn.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionReturn.java @@ -35,7 +35,7 @@ public class ActionReturn extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); output.add(new ReturnTreeItem(this, value)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionSetMember.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionSetMember.java index a6f932457..1e00bfae9 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionSetMember.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionSetMember.java @@ -35,7 +35,7 @@ public class ActionSetMember extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem value = stack.pop(); TreeItem objectName = stack.pop(); TreeItem object = stack.pop(); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionStackSwap.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionStackSwap.java index 80555a863..0a407576e 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionStackSwap.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionStackSwap.java @@ -34,7 +34,7 @@ public class ActionStackSwap extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(a); diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionStoreRegister.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionStoreRegister.java index bb1e924ee..e61dcf783 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionStoreRegister.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionStoreRegister.java @@ -62,7 +62,7 @@ public class ActionStoreRegister extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem item = stack.peek(); RegisterNumber rn = new RegisterNumber(registerNumber); if (regNames.containsKey(registerNumber)) { diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionTargetPath.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionTargetPath.java index 3da107245..ac9a9b4cc 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionTargetPath.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionTargetPath.java @@ -35,7 +35,7 @@ public class ActionTargetPath extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new TargetPathTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionToNumber.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionToNumber.java index ee897bcc9..240a4a31d 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionToNumber.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionToNumber.java @@ -35,7 +35,7 @@ public class ActionToNumber extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new ToNumberTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionToString.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionToString.java index fb4b90df5..625e31966 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionToString.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionToString.java @@ -35,7 +35,7 @@ public class ActionToString extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new ToStringTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf5/ActionTypeOf.java b/trunk/src/com/jpexs/asdec/action/swf5/ActionTypeOf.java index 5bf1c7ddf..f8ad5d90a 100644 --- a/trunk/src/com/jpexs/asdec/action/swf5/ActionTypeOf.java +++ b/trunk/src/com/jpexs/asdec/action/swf5/ActionTypeOf.java @@ -35,7 +35,7 @@ public class ActionTypeOf extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new TypeOfTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf6/ActionEnumerate2.java b/trunk/src/com/jpexs/asdec/action/swf6/ActionEnumerate2.java index 5b113802f..d9d2d9427 100644 --- a/trunk/src/com/jpexs/asdec/action/swf6/ActionEnumerate2.java +++ b/trunk/src/com/jpexs/asdec/action/swf6/ActionEnumerate2.java @@ -35,7 +35,7 @@ public class ActionEnumerate2 extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); stack.push(new EnumerateTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/swf6/ActionGreater.java b/trunk/src/com/jpexs/asdec/action/swf6/ActionGreater.java index 5c07e3bff..348d929b7 100644 --- a/trunk/src/com/jpexs/asdec/action/swf6/ActionGreater.java +++ b/trunk/src/com/jpexs/asdec/action/swf6/ActionGreater.java @@ -35,7 +35,7 @@ public class ActionGreater extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new GtTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf6/ActionInstanceOf.java b/trunk/src/com/jpexs/asdec/action/swf6/ActionInstanceOf.java index b71602505..6f15092ba 100644 --- a/trunk/src/com/jpexs/asdec/action/swf6/ActionInstanceOf.java +++ b/trunk/src/com/jpexs/asdec/action/swf6/ActionInstanceOf.java @@ -35,7 +35,7 @@ public class ActionInstanceOf extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new InstanceOfTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf6/ActionStrictEquals.java b/trunk/src/com/jpexs/asdec/action/swf6/ActionStrictEquals.java index 4096c3a9a..623b37a2d 100644 --- a/trunk/src/com/jpexs/asdec/action/swf6/ActionStrictEquals.java +++ b/trunk/src/com/jpexs/asdec/action/swf6/ActionStrictEquals.java @@ -35,7 +35,7 @@ public class ActionStrictEquals extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new StrictEqTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf6/ActionStringGreater.java b/trunk/src/com/jpexs/asdec/action/swf6/ActionStringGreater.java index f9c3fb38e..08a3aed9e 100644 --- a/trunk/src/com/jpexs/asdec/action/swf6/ActionStringGreater.java +++ b/trunk/src/com/jpexs/asdec/action/swf6/ActionStringGreater.java @@ -35,7 +35,7 @@ public class ActionStringGreater extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem a = stack.pop(); TreeItem b = stack.pop(); stack.push(new GtTreeItem(this, b, a)); diff --git a/trunk/src/com/jpexs/asdec/action/swf7/ActionCastOp.java b/trunk/src/com/jpexs/asdec/action/swf7/ActionCastOp.java index 934e62ea6..9bedb95c2 100644 --- a/trunk/src/com/jpexs/asdec/action/swf7/ActionCastOp.java +++ b/trunk/src/com/jpexs/asdec/action/swf7/ActionCastOp.java @@ -35,7 +35,7 @@ public class ActionCastOp extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); TreeItem constructor = stack.pop(); stack.push(new CastOpTreeItem(this, constructor, object)); diff --git a/trunk/src/com/jpexs/asdec/action/swf7/ActionDefineFunction2.java b/trunk/src/com/jpexs/asdec/action/swf7/ActionDefineFunction2.java index c6529c21b..3ac281e63 100644 --- a/trunk/src/com/jpexs/asdec/action/swf7/ActionDefineFunction2.java +++ b/trunk/src/com/jpexs/asdec/action/swf7/ActionDefineFunction2.java @@ -55,24 +55,26 @@ public class ActionDefineFunction2 extends Action { public int codeSize; public List code; private int version; + public List constantPool; - public void setConstantPool(List constantPool){ - for(Action a:code){ - if(a instanceof ActionPush){ - ((ActionPush)a).constantPool=constantPool; + public void setConstantPool(List constantPool) { + this.constantPool = constantPool; + for (Action a : code) { + if (a instanceof ActionPush) { + ((ActionPush) a).constantPool = constantPool; } - if(a instanceof ActionDefineFunction2){ - ((ActionDefineFunction2)a).setConstantPool(constantPool); + if (a instanceof ActionDefineFunction2) { + ((ActionDefineFunction2) a).setConstantPool(constantPool); } - if(a instanceof ActionDefineFunction){ - ((ActionDefineFunction)a).setConstantPool(constantPool); + if (a instanceof ActionDefineFunction) { + ((ActionDefineFunction) a).setConstantPool(constantPool); } } } - + public ActionDefineFunction2(int actionLength, SWFInputStream sis, int version) throws IOException { super(0x8E, actionLength); - this.version=version; + this.version = version; functionName = sis.readString(); int numParams = sis.readUI16(); registerCount = sis.readUI8(); @@ -213,12 +215,33 @@ public class ActionDefineFunction2 extends Action { return "DefineFunction2"; } - @Override - public void translate(Stack stack, ConstantPool constants, List output, HashMap regNames) { - stack.push(new FunctionTreeItem(this, functionName, paramNames, Action.actionsToTree(regNames, code,version ), constants)); + public int getFirstRegister() { + int pos = 1; + if (preloadThisFlag) { + pos++; + } + if (preloadArgumentsFlag) { + pos++; + } + if (preloadSuperFlag) { + pos++; + } + if (preloadRootFlag) { + pos++; + } + if (preloadParentFlag) { + pos++; + } + if (preloadGlobalFlag) { + pos++; + } + return pos; + } + + @Override + public void translate(Stack stack, List output, HashMap regNames) { + stack.push(new FunctionTreeItem(this, functionName, paramNames, Action.actionsToTree(regNames, code, version), constantPool,getFirstRegister())); } - - @Override public List getAllRefs(int version) { diff --git a/trunk/src/com/jpexs/asdec/action/swf7/ActionExtends.java b/trunk/src/com/jpexs/asdec/action/swf7/ActionExtends.java index c67e57b89..ce432d283 100644 --- a/trunk/src/com/jpexs/asdec/action/swf7/ActionExtends.java +++ b/trunk/src/com/jpexs/asdec/action/swf7/ActionExtends.java @@ -35,7 +35,7 @@ public class ActionExtends extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem superclass = stack.pop(); TreeItem subclass = stack.pop(); output.add(new ExtendsTreeItem(this, subclass, superclass)); diff --git a/trunk/src/com/jpexs/asdec/action/swf7/ActionImplementsOp.java b/trunk/src/com/jpexs/asdec/action/swf7/ActionImplementsOp.java index edeb8eafe..b3b888256 100644 --- a/trunk/src/com/jpexs/asdec/action/swf7/ActionImplementsOp.java +++ b/trunk/src/com/jpexs/asdec/action/swf7/ActionImplementsOp.java @@ -36,7 +36,7 @@ public class ActionImplementsOp extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem subclass = stack.pop(); long inCount = popLong(stack); List superclasses = new ArrayList(); diff --git a/trunk/src/com/jpexs/asdec/action/swf7/ActionThrow.java b/trunk/src/com/jpexs/asdec/action/swf7/ActionThrow.java index 1d0e73649..a1e4fb736 100644 --- a/trunk/src/com/jpexs/asdec/action/swf7/ActionThrow.java +++ b/trunk/src/com/jpexs/asdec/action/swf7/ActionThrow.java @@ -35,7 +35,7 @@ public class ActionThrow extends Action { } @Override - public void translate(Stack stack, ConstantPool constants, List output, java.util.HashMap regNames) { + public void translate(Stack stack, List output, java.util.HashMap regNames) { TreeItem object = stack.pop(); output.add(new ThrowTreeItem(this, object)); } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/AsciiToCharTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/AsciiToCharTreeItem.java index aff0ba4be..0e73fe1a3 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/AsciiToCharTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/AsciiToCharTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class AsciiToCharTreeItem extends TreeItem { @@ -31,4 +32,13 @@ public class AsciiToCharTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("ord(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } + + } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CallFunctionTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CallFunctionTreeItem.java index 967b465d1..5c8e31081 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CallFunctionTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CallFunctionTreeItem.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; import java.util.List; public class CallFunctionTreeItem extends TreeItem { @@ -41,4 +41,14 @@ public class CallFunctionTreeItem extends TreeItem { } return stripQuotes(functionName) + hilight("(") + paramStr + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(functionName.getNeededActions()); + for(TreeItem ti:arguments){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CallMethodTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CallMethodTreeItem.java index 062b942c6..073e25478 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CallMethodTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CallMethodTreeItem.java @@ -18,7 +18,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.swf4.Undefined; -import java.util.List; +import java.util.HashMap; import java.util.List; public class CallMethodTreeItem extends TreeItem { @@ -58,4 +58,15 @@ public class CallMethodTreeItem extends TreeItem { } return scriptObject.toString(constants) + hilight(".") + stripQuotes(methodName) + hilight("(") + paramStr + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(methodName.getNeededActions()); + ret.addAll(scriptObject.getNeededActions()); + for(TreeItem ti:arguments){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CallTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CallTreeItem.java index bec874a17..5d4f993e4 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CallTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CallTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class CallTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class CallTreeItem extends TreeItem { public String toString(ConstantPool constants) { return stripQuotes(value) + hilight("()"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CastOpTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CastOpTreeItem.java index a9567c1a1..f67171588 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CastOpTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CastOpTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class CastOpTreeItem extends TreeItem { @@ -33,4 +34,12 @@ public class CastOpTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("(") + stripQuotes(constructor) + hilight(")") + object.toString(constants); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(constructor.getNeededActions()); + ret.addAll(object.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CharToAsciiTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CharToAsciiTreeItem.java index 89470a80e..5b1e5ff43 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CharToAsciiTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CharToAsciiTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class CharToAsciiTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class CharToAsciiTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("chr(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/CloneSpriteTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/CloneSpriteTreeItem.java index ea2af67dc..b969123a9 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/CloneSpriteTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/CloneSpriteTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class CloneSpriteTreeItem extends TreeItem { @@ -35,4 +36,13 @@ public class CloneSpriteTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("duplicateMovieClip(") + target.toString(constants) + hilight(",") + source.toString(constants) + hilight(",") + depth.toString(constants) + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(source.getNeededActions()); + ret.addAll(target.getNeededActions()); + ret.addAll(depth.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ConstantPool.java b/trunk/src/com/jpexs/asdec/action/treemodel/ConstantPool.java index 5a82f43d0..35041a788 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ConstantPool.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ConstantPool.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import java.util.ArrayList; -import java.util.List; +import java.util.HashMap; import java.util.List; public class ConstantPool { diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/DecrementTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/DecrementTreeItem.java index 31f228bd7..b3fbb4451 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/DecrementTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/DecrementTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class DecrementTreeItem extends TreeItem { @@ -42,5 +43,10 @@ public class DecrementTreeItem extends TreeItem { return object.toNumber()-1; } - + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/DefineLocalTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/DefineLocalTreeItem.java index 8215f7b7a..e815af2e5 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/DefineLocalTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/DefineLocalTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class DefineLocalTreeItem extends TreeItem { @@ -36,4 +37,12 @@ public class DefineLocalTreeItem extends TreeItem { } return hilight("var ") + stripQuotes(name) + hilight("=") + value.toString(constants); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + ret.addAll(name.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/DeleteTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/DeleteTreeItem.java index 2cf3a5eac..30eae5d9a 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/DeleteTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/DeleteTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class DeleteTreeItem extends TreeItem { @@ -36,4 +37,12 @@ public class DeleteTreeItem extends TreeItem { } return hilight("delete ") + object.toString(constants) + "." + stripQuotes(propertyName); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + ret.addAll(propertyName.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/DirectValueTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/DirectValueTreeItem.java index 580fe0985..c9a4cff1c 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/DirectValueTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/DirectValueTreeItem.java @@ -19,19 +19,18 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.swf4.ConstantIndex; import com.jpexs.asdec.helpers.Helper; -import java.util.List; +import java.util.HashMap; import java.util.List; public class DirectValueTreeItem extends TreeItem { public Object value; public List constants; - public DirectValueTreeItem(Action instruction, Object value, ConstantPool constants) { + public DirectValueTreeItem(Action instruction,int instructionPos, Object value, List constants) { super(instruction, PRECEDENCE_PRIMARY); - if (constants != null) { - this.constants = constants.constants; - } + this.constants = constants; this.value = value; + this.instructionPos=instructionPos; } @Override @@ -50,8 +49,19 @@ public class DirectValueTreeItem extends TreeItem { @Override public boolean toBoolean() { - boolean ret=(value instanceof Boolean)?(Boolean)value:false; - return ret; + if(value instanceof Boolean){ + return (Boolean)value; + } + if(value instanceof Double){ + return Double.compare((Double)value,0.0)!=0; + } + if(value instanceof Float){ + return Float.compare((Float)value,0.0f)!=0; + } + if(value instanceof Long){ + return ((Long)value)!=0; + } + return false; } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/EachTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/EachTreeItem.java index 6b9c4cdac..544f2eac9 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/EachTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/EachTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class EachTreeItem extends TreeItem { @@ -33,4 +34,12 @@ public class EachTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("each (") + object.toString(constants) + hilight(" in ") + collection.toString(constants) + ")"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + ret.addAll(collection.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/EnumerateTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/EnumerateTreeItem.java index 75dd9ee89..d6db7b7b9 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/EnumerateTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/EnumerateTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class EnumerateTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class EnumerateTreeItem extends TreeItem { public String toString(ConstantPool constants) { return "enumerate " + object.toString(constants); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ExtendsTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ExtendsTreeItem.java index 4d02c2d8c..38cab682f 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ExtendsTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ExtendsTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ExtendsTreeItem extends TreeItem { @@ -33,4 +34,12 @@ public class ExtendsTreeItem extends TreeItem { public String toString(ConstantPool constants) { return subclass.toString(constants) + hilight(" extends ") + stripQuotes(superclass); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(subclass.getNeededActions()); + ret.addAll(superclass.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/FSCommand2TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/FSCommand2TreeItem.java index 586fe717a..6c7df9c2f 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/FSCommand2TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/FSCommand2TreeItem.java @@ -17,7 +17,8 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; +import java.util.HashMap; import java.util.List; public class FSCommand2TreeItem extends TreeItem { @@ -40,4 +41,14 @@ public class FSCommand2TreeItem extends TreeItem { } return hilight("FSCommand2(") + command.toString(constants) + paramStr + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(command.getNeededActions()); + for(TreeItem ti:arguments){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/FunctionTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/FunctionTreeItem.java index c48d0619a..029ded679 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/FunctionTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/FunctionTreeItem.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; import java.util.List; public class FunctionTreeItem extends TreeItem { @@ -26,13 +26,15 @@ public class FunctionTreeItem extends TreeItem { public String functionName; public List paramNames; public TreeItem calculatedFunctionName; + private int regStart; - public FunctionTreeItem(Action instruction, String functionName, List paramNames, List actions, ConstantPool constants) { + public FunctionTreeItem(Action instruction, String functionName, List paramNames, List actions, List constants,int regStart) { super(instruction, PRECEDENCE_PRIMARY); this.actions = actions; - this.constants = constants==null?null:constants.constants; + this.constants = constants; this.functionName = functionName; this.paramNames = paramNames; + this.regStart = regStart; } @Override @@ -48,9 +50,23 @@ public class FunctionTreeItem extends TreeItem { if (p > 0) { ret += hilight(", "); } - ret += hilight(paramNames.get(p)); + String pname=paramNames.get(p); + if(pname==null || pname.equals("")){ + pname="register"+(regStart+p); + } + ret += hilight(pname); } ret += hilight(")") + "\r\n{\r\n" + Action.treeToString(actions) + "}"; return ret; } + + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + for(TreeItem ti:actions){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/GetMemberTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/GetMemberTreeItem.java index e52d38f03..0725ea06c 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/GetMemberTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/GetMemberTreeItem.java @@ -17,24 +17,33 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class GetMemberTreeItem extends TreeItem { public TreeItem object; - public TreeItem functionName; + public TreeItem memberName; - public GetMemberTreeItem(Action instruction, TreeItem object, TreeItem functionName) { + public GetMemberTreeItem(Action instruction, TreeItem object, TreeItem memberName) { super(instruction, PRECEDENCE_PRIMARY); this.object = object; - this.functionName = functionName; + this.memberName = memberName; } @Override public String toString(ConstantPool constants) { - if (!((functionName instanceof DirectValueTreeItem) && (((DirectValueTreeItem) functionName).value instanceof String))) { + if (!((memberName instanceof DirectValueTreeItem) && (((DirectValueTreeItem) memberName).value instanceof String))) { //if(!(functionName instanceof GetVariableTreeItem)) - return object.toString(constants) + "[" + stripQuotes(functionName) + "]"; + return object.toString(constants) + "[" + stripQuotes(memberName) + "]"; } - return object.toString(constants) + "." + stripQuotes(functionName); + return object.toString(constants) + "." + stripQuotes(memberName); + } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + ret.addAll(memberName.getNeededActions()); + return ret; } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/GetPropertyTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/GetPropertyTreeItem.java index 775af0192..d1ffcacba 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/GetPropertyTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/GetPropertyTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class GetPropertyTreeItem extends TreeItem { @@ -36,4 +37,11 @@ public class GetPropertyTreeItem extends TreeItem { } return target.toString(constants) + hilight("." + Action.propertyNames[propertyIndex]); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(target.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/GetURL2TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/GetURL2TreeItem.java index 178272c1a..4a054c13b 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/GetURL2TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/GetURL2TreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class GetURL2TreeItem extends TreeItem { @@ -53,4 +54,12 @@ public class GetURL2TreeItem extends TreeItem { this.loadTargetFlag = loadTargetFlag; this.loadVariablesFlag = loadVariablesFlag; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(urlString.getNeededActions()); + ret.addAll(targetString.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/GetVariableTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/GetVariableTreeItem.java index a84868b64..ce4fab145 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/GetVariableTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/GetVariableTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class GetVariableTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class GetVariableTreeItem extends TreeItem { public String toString(ConstantPool constants) { return stripQuotes(value); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/GotoFrame2TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/GotoFrame2TreeItem.java index 64b800a14..3b92364c3 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/GotoFrame2TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/GotoFrame2TreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class GotoFrame2TreeItem extends TreeItem { @@ -41,4 +42,11 @@ public class GotoFrame2TreeItem extends TreeItem { } return hilight(prefix + "(") + frame.toString(constants) + (sceneBiasFlag ? "," + sceneBias : "") + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(frame.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ImplementsOpTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ImplementsOpTreeItem.java index 16366816a..683c1ac1d 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ImplementsOpTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ImplementsOpTreeItem.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; import java.util.List; public class ImplementsOpTreeItem extends TreeItem { @@ -41,4 +41,14 @@ public class ImplementsOpTreeItem extends TreeItem { } return subclass.toString(constants) + hilight(" implements ") + impStr; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(subclass.getNeededActions()); + for(TreeItem ti:superclasses){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/IncrementTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/IncrementTreeItem.java index 1f5b30026..ace9d2fa5 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/IncrementTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/IncrementTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class IncrementTreeItem extends TreeItem { @@ -42,5 +43,12 @@ public class IncrementTreeItem extends TreeItem { return object.toNumber()+1; } + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + return ret; + } + } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/InitArrayTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/InitArrayTreeItem.java index 117aba8f9..ecf7197c1 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/InitArrayTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/InitArrayTreeItem.java @@ -17,7 +17,9 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import com.jpexs.asdec.action.IgnoredPair; +import com.sun.org.apache.xml.internal.security.utils.IgnoreAllErrorHandler; +import java.util.HashMap; import java.util.List; public class InitArrayTreeItem extends TreeItem { @@ -39,4 +41,13 @@ public class InitArrayTreeItem extends TreeItem { } return hilight("[") + arrStr + hilight("]"); } + + @Override + public List getNeededActions() { + List ret = super.getNeededActions(); + for (TreeItem value : values) { + ret.addAll(value.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/InitObjectTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/InitObjectTreeItem.java index 395ace3ff..0e2727108 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/InitObjectTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/InitObjectTreeItem.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; import java.util.List; public class InitObjectTreeItem extends TreeItem { @@ -41,4 +41,16 @@ public class InitObjectTreeItem extends TreeItem { } return hilight("{") + objStr + hilight("}"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + for(TreeItem name:names){ + ret.addAll(name.getNeededActions()); + } + for(TreeItem value:values){ + ret.addAll(value.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/MBAsciiToCharTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/MBAsciiToCharTreeItem.java index b13af4c7d..e4a31e467 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/MBAsciiToCharTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/MBAsciiToCharTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class MBAsciiToCharTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class MBAsciiToCharTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("mbord(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/MBCharToAsciiTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/MBCharToAsciiTreeItem.java index a412ab0ef..c4d361c58 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/MBCharToAsciiTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/MBCharToAsciiTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class MBCharToAsciiTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class MBCharToAsciiTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("mbchr(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/MBStringExtractTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/MBStringExtractTreeItem.java index 25ebc9a52..4939d0ea8 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/MBStringExtractTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/MBStringExtractTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class MBStringExtractTreeItem extends TreeItem { @@ -35,4 +36,13 @@ public class MBStringExtractTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("mbsubstring(") + value.toString(constants) + hilight(",") + index.toString(constants) + hilight(",") + count.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + ret.addAll(index.getNeededActions()); + ret.addAll(count.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/MBStringLengthTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/MBStringLengthTreeItem.java similarity index 77% rename from trunk/src/com/jpexs/asdec/action/treemodel/operations/MBStringLengthTreeItem.java rename to trunk/src/com/jpexs/asdec/action/treemodel/MBStringLengthTreeItem.java index 5a62bfa47..363149326 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/MBStringLengthTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/MBStringLengthTreeItem.java @@ -14,11 +14,12 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ -package com.jpexs.asdec.action.treemodel.operations; +package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.ConstantPool; import com.jpexs.asdec.action.treemodel.TreeItem; +import java.util.HashMap; import java.util.List; public class MBStringLengthTreeItem extends TreeItem { @@ -37,4 +38,11 @@ public class MBStringLengthTreeItem extends TreeItem { } return hilight("mblength(") + s + ")"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/NewMethodTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/NewMethodTreeItem.java index 23575b3c6..cbdfca359 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/NewMethodTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/NewMethodTreeItem.java @@ -18,7 +18,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.swf4.Undefined; -import java.util.List; +import java.util.HashMap; import java.util.List; public class NewMethodTreeItem extends TreeItem { @@ -63,4 +63,15 @@ public class NewMethodTreeItem extends TreeItem { } return hilight("new ") + scriptObject.toString(constants) + hilight(".") + methodNameStr + hilight("(") + paramStr + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(methodName.getNeededActions()); + ret.addAll(scriptObject.getNeededActions()); + for(TreeItem ti:arguments){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/NewObjectTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/NewObjectTreeItem.java index 8ea863de5..3218f665f 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/NewObjectTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/NewObjectTreeItem.java @@ -17,7 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; -import java.util.List; +import java.util.HashMap; import java.util.List; public class NewObjectTreeItem extends TreeItem { @@ -41,4 +41,14 @@ public class NewObjectTreeItem extends TreeItem { } return hilight("new ") + stripQuotes(objectName) + hilight("(") + paramStr + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(objectName.getNeededActions()); + for(TreeItem ti:arguments){ + ret.addAll(ti.getNeededActions()); + } + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/RandomNumberTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/RandomNumberTreeItem.java index e35a5ec0b..e22977ae6 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/RandomNumberTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/RandomNumberTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class RandomNumberTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class RandomNumberTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("random(") + maximum.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(maximum.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/RemoveSpriteTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/RemoveSpriteTreeItem.java index 0ddf09608..3426a7a73 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/RemoveSpriteTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/RemoveSpriteTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class RemoveSpriteTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class RemoveSpriteTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("removeMovieClip(") + target.toString(constants) + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(target.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ReturnTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ReturnTreeItem.java index da2c736f0..a5ad27ebf 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ReturnTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ReturnTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ReturnTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class ReturnTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("return ") + value.toString(constants) + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/SetMemberTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/SetMemberTreeItem.java index b64633bc8..db2e1dbb7 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/SetMemberTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/SetMemberTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class SetMemberTreeItem extends TreeItem implements SetTypeTreeItem { @@ -40,4 +41,13 @@ public class SetMemberTreeItem extends TreeItem implements SetTypeTreeItem { public TreeItem getObject() { return new GetMemberTreeItem(instruction, object, objectName); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + ret.addAll(objectName.getNeededActions()); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/SetPropertyTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/SetPropertyTreeItem.java index ce882815f..89a0c8b3e 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/SetPropertyTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/SetPropertyTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class SetPropertyTreeItem extends TreeItem implements SetTypeTreeItem { @@ -43,4 +44,12 @@ public class SetPropertyTreeItem extends TreeItem implements SetTypeTreeItem { public TreeItem getObject() { return new GetPropertyTreeItem(instruction, target, propertyIndex); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(target.getNeededActions()); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/SetTarget2TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/SetTarget2TreeItem.java index a7e64c6de..267303aa7 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/SetTarget2TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/SetTarget2TreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class SetTarget2TreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class SetTarget2TreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("tellTarget(") + target.toString(constants) + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(target.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/SetVariableTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/SetVariableTreeItem.java index 016d45943..570f55484 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/SetVariableTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/SetVariableTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class SetVariableTreeItem extends TreeItem implements SetTypeTreeItem { @@ -38,4 +39,12 @@ public class SetVariableTreeItem extends TreeItem implements SetTypeTreeItem { public TreeItem getObject() { return new GetVariableTreeItem(instruction, value); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(name.getNeededActions()); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/StartDragTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/StartDragTreeItem.java index 5dd951674..9d12ecaed 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/StartDragTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/StartDragTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class StartDragTreeItem extends TreeItem { @@ -56,4 +57,16 @@ public class StartDragTreeItem extends TreeItem { } return hilight("startDrag(") + target.toString(constants) + hilight(",") + lockCenter.toString(constants) + (hasConstrains ? hilight(",") + x1.toString(constants) + hilight(",") + y1.toString(constants) + hilight(",") + x2.toString(constants) + hilight(",") + y2.toString(constants) : "") + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(target.getNeededActions()); + ret.addAll(constrain.getNeededActions()); + ret.addAll(x1.getNeededActions()); + ret.addAll(x2.getNeededActions()); + ret.addAll(y1.getNeededActions()); + ret.addAll(y2.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/StoreRegisterTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/StoreRegisterTreeItem.java index 7ef4e6103..2e5475d7f 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/StoreRegisterTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/StoreRegisterTreeItem.java @@ -18,6 +18,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.swf4.RegisterNumber; +import java.util.HashMap; import java.util.List; public class StoreRegisterTreeItem extends TreeItem implements SetTypeTreeItem { @@ -37,6 +38,13 @@ public class StoreRegisterTreeItem extends TreeItem implements SetTypeTreeItem { @Override public TreeItem getObject() { - return new DirectValueTreeItem(instruction, register, null); + return new DirectValueTreeItem(instruction,-1, register, null); + } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/StringExtractTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/StringExtractTreeItem.java index d10a33dc8..6d2bde82b 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/StringExtractTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/StringExtractTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class StringExtractTreeItem extends TreeItem { @@ -35,4 +36,13 @@ public class StringExtractTreeItem extends TreeItem { public String toString(ConstantPool constants) { return value.toString(constants) + ".substr(" + index.toString(constants) + "," + count.toString(constants) + ")"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + ret.addAll(index.getNeededActions()); + ret.addAll(count.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/TargetPathTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/TargetPathTreeItem.java index 9fc64ddf4..a65c71d95 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/TargetPathTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/TargetPathTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class TargetPathTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class TargetPathTreeItem extends TreeItem { public String toString(ConstantPool constants) { return "targetPath(" + object.toString(constants) + ");"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ThrowTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ThrowTreeItem.java index d2d28afce..63a61305b 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ThrowTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ThrowTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ThrowTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class ThrowTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("throw ") + object.toString(constants) + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(object.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ToIntegerTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ToIntegerTreeItem.java index cc31a1a32..8c22b2f75 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ToIntegerTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ToIntegerTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ToIntegerTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class ToIntegerTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("int(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ToNumberTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ToNumberTreeItem.java index 5ccb963dc..c31f598b8 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ToNumberTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ToNumberTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ToNumberTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class ToNumberTreeItem extends TreeItem { public String toString(ConstantPool constants) { return value.toString(constants) + hilight(".valueOf()"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/ToStringTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/ToStringTreeItem.java index 45865172a..d16cf0dd6 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/ToStringTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/ToStringTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class ToStringTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class ToStringTreeItem extends TreeItem { public String toString(ConstantPool constants) { return value.toString(constants) + hilight(".toString()"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/TraceTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/TraceTreeItem.java index ea39fef81..f220f0f8f 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/TraceTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/TraceTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class TraceTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class TraceTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("trace(") + value.toString(constants) + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/TreeItem.java index acec9a3c1..048b518e8 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/TreeItem.java @@ -17,7 +17,11 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import com.jpexs.asdec.action.IgnoredPair; import com.jpexs.asdec.helpers.Highlighting; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashMap; import java.util.List; public abstract class TreeItem { @@ -40,6 +44,8 @@ public abstract class TreeItem { public static final int NOPRECEDENCE = 16; public int precedence = NOPRECEDENCE; public Action instruction; + public int instructionPos=0; + public List moreInstructions=new ArrayList(); public TreeItem(Action instruction, int precedence) { this.instruction = instruction; @@ -109,4 +115,13 @@ public abstract class TreeItem { public boolean toBoolean(){ return Double.compare(toNumber(),0.0)!=0; } + + public List getNeededActions(){ + List ret=new ArrayList(); + if(instruction!=null){ + ret.add(new IgnoredPair(instruction,instructionPos)); + } + ret.addAll(moreInstructions); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/TypeOfTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/TypeOfTreeItem.java index e9a8fcd38..4aeb433b9 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/TypeOfTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/TypeOfTreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class TypeOfTreeItem extends TreeItem { @@ -31,4 +32,11 @@ public class TypeOfTreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("typeof(") + value.toString(constants) + hilight(")"); } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/WaitForFrame2TreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/WaitForFrame2TreeItem.java index 73838a596..1343072ce 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/WaitForFrame2TreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/WaitForFrame2TreeItem.java @@ -17,6 +17,7 @@ package com.jpexs.asdec.action.treemodel; import com.jpexs.asdec.action.Action; +import java.util.HashMap; import java.util.List; public class WaitForFrame2TreeItem extends TreeItem { @@ -33,4 +34,11 @@ public class WaitForFrame2TreeItem extends TreeItem { public String toString(ConstantPool constants) { return hilight("waitForFrame2(") + frame.toString(constants) + "," + skipCount + hilight(")") + ";"; } + + @Override + public List getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(frame.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/clauses/ForTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/clauses/ForTreeItem.java index 07aa65e0e..f09f8b688 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/clauses/ForTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/clauses/ForTreeItem.java @@ -36,6 +36,12 @@ public class ForTreeItem extends LoopTreeItem implements Block { this.expression = expression; this.finalCommands = finalCommands; this.commands = commands; + + if ((!commands.isEmpty()) && (commands.get(commands.size() - 1) instanceof ContinueTreeItem)) { + if (((ContinueTreeItem) commands.get(commands.size() - 1)).loopPos == loopBreak) { + commands.remove(commands.size() - 1); + } + } } private String stripSemicolon(String s) { diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/clauses/SwitchTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/clauses/SwitchTreeItem.java index b290ab5b6..ab949af83 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/clauses/SwitchTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/clauses/SwitchTreeItem.java @@ -29,13 +29,15 @@ public class SwitchTreeItem extends LoopTreeItem implements Block { public List caseValues; public List> caseCommands; public List defaultCommands; + public List valuesMapping; - public SwitchTreeItem(Action instruction, long switchBreak, TreeItem switchedObject, List caseValues, List> caseCommands, List defaultCommands) { + public SwitchTreeItem(Action instruction, long switchBreak, TreeItem switchedObject, List caseValues, List> caseCommands, List defaultCommands,List valuesMapping) { super(instruction, switchBreak, -1); this.switchedObject = switchedObject; this.caseValues = caseValues; this.caseCommands = caseCommands; this.defaultCommands = defaultCommands; + this.valuesMapping=valuesMapping; } @Override @@ -43,8 +45,12 @@ public class SwitchTreeItem extends LoopTreeItem implements Block { String ret = ""; ret += "loopswitch" + loopBreak + ":\r\n"; ret += hilight("switch(") + switchedObject.toString(constants) + hilight(")") + "\r\n{\r\n"; - for (int i = 0; i < caseValues.size(); i++) { - ret += "case " + caseValues.get(i).toString(constants) + ":\r\n"; + for (int i = 0; i < caseCommands.size(); i++) { + for(int k=0;k getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(leftSide.getNeededActions()); + ret.addAll(rightSide.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/EqTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/EqTreeItem.java index 6eb961fba..88f142d2b 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/EqTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/EqTreeItem.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.treemodel.operations; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.TreeItem; -public class EqTreeItem extends BinaryOpTreeItem { +public class EqTreeItem extends BinaryOpTreeItem implements LogicalOp{ public EqTreeItem(Action instruction, TreeItem leftSide, TreeItem rightSide) { super(instruction, PRECEDENCE_EQUALITY, leftSide, rightSide, "=="); @@ -29,6 +29,11 @@ public class EqTreeItem extends BinaryOpTreeItem { public boolean toBoolean() { return (leftSide.toBoolean()==rightSide.toBoolean())&&(leftSide.toNumber()==rightSide.toNumber()); } + + @Override + public TreeItem invert() { + return new NeqTreeItem(instruction, leftSide, rightSide); + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/GeTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/GeTreeItem.java index 59ab77f09..99f940091 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/GeTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/GeTreeItem.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.treemodel.operations; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.TreeItem; -public class GeTreeItem extends BinaryOpTreeItem { +public class GeTreeItem extends BinaryOpTreeItem implements LogicalOp{ public GeTreeItem(Action instruction, TreeItem leftSide, TreeItem rightSide) { super(instruction, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">="); @@ -30,5 +30,8 @@ public class GeTreeItem extends BinaryOpTreeItem { return leftSide.toNumber()>=rightSide.toNumber(); } - + @Override + public TreeItem invert() { + return new LtTreeItem(instruction, leftSide, rightSide); + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/GtTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/GtTreeItem.java index 9840b108d..ed7603db2 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/GtTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/GtTreeItem.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.treemodel.operations; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.TreeItem; -public class GtTreeItem extends BinaryOpTreeItem { +public class GtTreeItem extends BinaryOpTreeItem implements LogicalOp{ public GtTreeItem(Action instruction, TreeItem leftSide, TreeItem rightSide) { super(instruction, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">"); @@ -29,4 +29,9 @@ public class GtTreeItem extends BinaryOpTreeItem { public boolean toBoolean() { return leftSide.toNumber()>rightSide.toNumber(); } + + @Override + public TreeItem invert() { + return new LeTreeItem(instruction, leftSide, rightSide); + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/LeTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LeTreeItem.java index 02b9d6c25..c1c5393cb 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/LeTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LeTreeItem.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.treemodel.operations; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.TreeItem; -public class LeTreeItem extends BinaryOpTreeItem { +public class LeTreeItem extends BinaryOpTreeItem implements LogicalOp{ public LeTreeItem(Action instruction, TreeItem leftSide, TreeItem rightSide) { super(instruction, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<="); @@ -29,4 +29,9 @@ public class LeTreeItem extends BinaryOpTreeItem { public boolean toBoolean() { return leftSide.toNumber()<=rightSide.toNumber(); } + + @Override + public TreeItem invert() { + return new GtTreeItem(instruction, leftSide, rightSide); + } } diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/LogicalOp.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LogicalOp.java new file mode 100644 index 000000000..b87d68f3b --- /dev/null +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LogicalOp.java @@ -0,0 +1,11 @@ +package com.jpexs.asdec.action.treemodel.operations; + +import com.jpexs.asdec.action.treemodel.TreeItem; + +/** + * + * @author JPEXS + */ +public interface LogicalOp { + public TreeItem invert(); +} diff --git a/trunk/src/com/jpexs/asdec/action/treemodel/operations/LtTreeItem.java b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LtTreeItem.java index 4c6809a5b..fe22b5511 100644 --- a/trunk/src/com/jpexs/asdec/action/treemodel/operations/LtTreeItem.java +++ b/trunk/src/com/jpexs/asdec/action/treemodel/operations/LtTreeItem.java @@ -19,7 +19,7 @@ package com.jpexs.asdec.action.treemodel.operations; import com.jpexs.asdec.action.Action; import com.jpexs.asdec.action.treemodel.TreeItem; -public class LtTreeItem extends BinaryOpTreeItem { +public class LtTreeItem extends BinaryOpTreeItem implements LogicalOp{ public LtTreeItem(Action instruction, TreeItem leftSide, TreeItem rightSide) { super(instruction, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<"); @@ -29,4 +29,9 @@ public class LtTreeItem extends BinaryOpTreeItem { public boolean toBoolean() { return leftSide.toNumber() getNeededActions() { + List ret=super.getNeededActions(); + ret.addAll(value.getNeededActions()); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/graph/Graph.java b/trunk/src/com/jpexs/asdec/graph/Graph.java index 34d85685f..70d692bd0 100644 --- a/trunk/src/com/jpexs/asdec/graph/Graph.java +++ b/trunk/src/com/jpexs/asdec/graph/Graph.java @@ -1,5 +1,7 @@ package com.jpexs.asdec.graph; +import com.jpexs.asdec.abc.gui.GraphFrame; +import com.jpexs.asdec.helpers.Helper; import java.util.ArrayList; import java.util.List; @@ -7,7 +9,7 @@ import java.util.List; * * @author JPEXS */ -public abstract class Graph { +public class Graph { public List heads; protected static void populateParts(GraphPart part, List allParts) { @@ -167,4 +169,78 @@ public abstract class Graph { makeMulti(part.nextParts.get(i), visited); } } + + public GraphPart deepCopy(GraphPart part,List visited,List copies){ + if(visited==null){ + visited=new ArrayList(); + } + if(copies==null){ + copies=new ArrayList(); + } + if(visited.contains(part)){ + return copies.get(visited.indexOf(part)); + } + visited.add(part); + GraphPart copy=new GraphPart(part.start,part.end); + copy.path=part.path; + copies.add(copy); + copy.nextParts=new ArrayList(); + for(int i=0;i visited){ + if(visited.contains(part)){ + return; + } + visited.add(part); + int pos=0; + for(GraphPart p:part.nextParts){ + if(!visited.contains(p)){ + p.path=part.path+pos; + } + resetGraph(p, visited); + pos++; + } + } + + public GraphPart getCommonPart(List parts){ + GraphPart head=new GraphPart(0, 0); + head.nextParts.addAll(parts); + List allVisited=new ArrayList(); + head=deepCopy(head,allVisited,null); + for(GraphPart g:head.nextParts){ + for(GraphPart r:g.refs){ + r.nextParts.remove(g); + } + g.refs.clear(); + g.refs.add(head); + } + head.path="0"; + resetGraph(head,new ArrayList()); + fixGraph(head); + + /*Graph gr=new Graph(); + gr.heads=new ArrayList(); + gr.heads.add(head); + GraphFrame gf=new GraphFrame(gr, ""); + gf.setVisible(true); + */ + + GraphPart next=head.getNextPartPath(new ArrayList()); + if(next==null){ + return null; + } + for(GraphPart g:allVisited){ + if(g.start==next.start){ + return g; + } + } + return null; + } } diff --git a/trunk/src/com/jpexs/asdec/graph/GraphPart.java b/trunk/src/com/jpexs/asdec/graph/GraphPart.java index 90853466b..9ee2b5743 100644 --- a/trunk/src/com/jpexs/asdec/graph/GraphPart.java +++ b/trunk/src/com/jpexs/asdec/graph/GraphPart.java @@ -94,7 +94,34 @@ public class GraphPart { visited.addAll(ignored); return getNextPartPath(this,path,visited); } + + public GraphPart getNextSuperPartPath(List ignored){ + List visited=new ArrayList(); + visited.addAll(ignored); + return getNextSuperPartPath(this,path,visited); + } + private GraphPart getNextSuperPartPath(GraphPart original,String path,List visited){ + if(visited.contains(this)){ + return null; + } + visited.add(this); + for(GraphPart p:nextParts){ + if(p==original){ + continue; + } + if(p.path.length()()); } + + public List getSubParts(){ + List ret=new ArrayList(); + ret.add(this); + return ret; + } } diff --git a/trunk/src/com/jpexs/asdec/graph/GraphPartMulti.java b/trunk/src/com/jpexs/asdec/graph/GraphPartMulti.java index 8293355fe..9c24a88fd 100644 --- a/trunk/src/com/jpexs/asdec/graph/GraphPartMulti.java +++ b/trunk/src/com/jpexs/asdec/graph/GraphPartMulti.java @@ -1,5 +1,6 @@ package com.jpexs.asdec.graph; +import java.util.Collections; import java.util.List; /** @@ -41,4 +42,26 @@ public class GraphPartMulti extends GraphPart { } return ret; } + + @Override + public int getPosAt(int offset) { + int ofs=0; + int pos=0; + for(GraphPart p:parts){ + for(int i=0;i getSubParts(){ + return Collections.unmodifiableList(parts); + } + }