diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/AVM2Code.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/AVM2Code.java index f61b7dcaa..136efa1ba 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/AVM2Code.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/AVM2Code.java @@ -1507,6 +1507,9 @@ public class AVM2Code implements Cloneable { break; } + if (Configuration.autoDeobfuscate.get()) { + stack.simplify(); + } visited[ip] = true; AVM2Instruction ins = code.get(ip); if (stack.isEmpty()) { diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimple.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimple.java index ccd69bb40..5b389e12f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimple.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimple.java @@ -52,10 +52,13 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.GreaterThanIn import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.LessEqualsIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.LessThanIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.StrictEqualsIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewArrayIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewFunctionIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewObjectIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.jumps.JumpIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.localregs.GetLocalTypeIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.localregs.SetLocalTypeIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.other.GetPropertyIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.DupIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.PopIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.PushByteIns; @@ -255,6 +258,9 @@ public class AVM2DeobfuscatorSimple extends SWFDecompilerAdapter { || def instanceof GetLocalTypeIns || def instanceof SetLocalTypeIns || def instanceof NewFunctionIns + || def instanceof NewArrayIns + || def instanceof NewObjectIns + || def instanceof GetPropertyIns || def instanceof CoerceOrConvertTypeIns) { ok = true; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimpleOld.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimpleOld.java index c3fd7cfdd..8a3cf51c8 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimpleOld.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/deobfuscation/AVM2DeobfuscatorSimpleOld.java @@ -42,6 +42,7 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.arithmetic.NotIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.arithmetic.SubtractIIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.arithmetic.SubtractIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.bitwise.BitAndIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.bitwise.BitNotIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.bitwise.BitOrIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.bitwise.BitXorIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.bitwise.LShiftIns; @@ -53,10 +54,15 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.GreaterThanIn import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.LessEqualsIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.LessThanIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.comparison.StrictEqualsIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.ConstructIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewArrayIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewFunctionIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.construction.NewObjectIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.executing.CallIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.jumps.JumpIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.localregs.GetLocalTypeIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.localregs.SetLocalTypeIns; +import com.jpexs.decompiler.flash.abc.avm2.instructions.other.GetPropertyIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.DupIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.PopIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.PushByteIns; @@ -71,7 +77,9 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.PushUndefinedIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.stack.SwapIns; import com.jpexs.decompiler.flash.abc.avm2.instructions.types.CoerceOrConvertTypeIns; import com.jpexs.decompiler.flash.abc.avm2.model.FloatValueAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.GetPropertyAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.IntegerValueAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.NewArrayAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.NullAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.StringAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.UndefinedAVM2Item; @@ -314,14 +322,32 @@ public class AVM2DeobfuscatorSimpleOld extends SWFDecompilerAdapter { || def instanceof GreaterEqualsIns || def instanceof GreaterThanIns || def instanceof LessThanIns + || def instanceof BitNotIns || def instanceof StrictEqualsIns || def instanceof PopIns || def instanceof GetLocalTypeIns || def instanceof NewFunctionIns - || def instanceof CoerceOrConvertTypeIns) { + || def instanceof NewArrayIns + || def instanceof NewObjectIns + || def instanceof GetPropertyIns + || def instanceof CoerceOrConvertTypeIns + || def instanceof ConstructIns + || def instanceof CallIns) { ok = true; } + if (def instanceof GetPropertyIns) { + GetPropertyAVM2Item avi = (GetPropertyAVM2Item) stack.peek(); + ok = false; + if (avi.object instanceof NewArrayAVM2Item) { + if (((NewArrayAVM2Item) avi.object).values.isEmpty()) { + stack.pop(); + stack.push(new UndefinedAVM2Item(null, null)); + ok = true; + } + } + } + if (!ok) { break; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewArrayIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewArrayIns.java index 05bd92fb0..c72491ba2 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewArrayIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewArrayIns.java @@ -19,10 +19,14 @@ package com.jpexs.decompiler.flash.abc.avm2.instructions.construction; import com.jpexs.decompiler.flash.abc.ABC; import com.jpexs.decompiler.flash.abc.AVM2LocalData; import com.jpexs.decompiler.flash.abc.avm2.AVM2Code; +import com.jpexs.decompiler.flash.abc.avm2.AVM2ConstantPool; +import com.jpexs.decompiler.flash.abc.avm2.LocalDataArea; +import com.jpexs.decompiler.flash.abc.avm2.exceptions.AVM2ExecutionException; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.InstructionDefinition; import com.jpexs.decompiler.flash.abc.avm2.model.NewArrayAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.NullAVM2Item; +import com.jpexs.decompiler.flash.ecma.ArrayType; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.TranslateStack; import com.jpexs.decompiler.graph.model.PopItem; @@ -39,6 +43,16 @@ public class NewArrayIns extends InstructionDefinition { super(0x56, "newarray", new int[]{AVM2Code.DAT_ARG_COUNT}, true); } + @Override + public boolean execute(LocalDataArea lda, AVM2ConstantPool constants, AVM2Instruction ins) throws AVM2ExecutionException { + //TODO: moar + if (ins.operands[0] == 0) { + lda.operandStack.push(ArrayType.EMPTY_ARRAY); + return true; + } + return false; + } + @Override public void translate(AVM2LocalData localData, TranslateStack stack, AVM2Instruction ins, List output, String path) { int argCount = ins.operands[0]; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewObjectIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewObjectIns.java index be99c3164..67051f05d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewObjectIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/construction/NewObjectIns.java @@ -19,11 +19,16 @@ package com.jpexs.decompiler.flash.abc.avm2.instructions.construction; import com.jpexs.decompiler.flash.abc.ABC; import com.jpexs.decompiler.flash.abc.AVM2LocalData; import com.jpexs.decompiler.flash.abc.avm2.AVM2Code; +import com.jpexs.decompiler.flash.abc.avm2.AVM2ConstantPool; +import com.jpexs.decompiler.flash.abc.avm2.LocalDataArea; +import com.jpexs.decompiler.flash.abc.avm2.exceptions.AVM2ExecutionException; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.InstructionDefinition; import com.jpexs.decompiler.flash.abc.avm2.model.NameValuePair; import com.jpexs.decompiler.flash.abc.avm2.model.NewObjectAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.NullAVM2Item; +import com.jpexs.decompiler.flash.ecma.ArrayType; +import com.jpexs.decompiler.flash.ecma.ObjectType; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.TranslateStack; import com.jpexs.decompiler.graph.model.PopItem; @@ -40,6 +45,16 @@ public class NewObjectIns extends InstructionDefinition { super(0x55, "newobject", new int[]{AVM2Code.DAT_ARG_COUNT}, true); } + @Override + public boolean execute(LocalDataArea lda, AVM2ConstantPool constants, AVM2Instruction ins) throws AVM2ExecutionException { + //TODO: moar + if (ins.operands[0] == 0) { + lda.operandStack.push(ObjectType.EMPTY_OBJECT); + return true; + } + return false; + } + @Override public void translate(AVM2LocalData localData, TranslateStack stack, AVM2Instruction ins, List output, String path) throws InterruptedException { int argCount = ins.operands[0]; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/localregs/GetLocalTypeIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/localregs/GetLocalTypeIns.java index 1b293aa3e..10f8a619e 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/localregs/GetLocalTypeIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/localregs/GetLocalTypeIns.java @@ -26,10 +26,15 @@ import com.jpexs.decompiler.flash.abc.avm2.model.ClassAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.LocalRegAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.ScriptAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.ThisAVM2Item; +import com.jpexs.decompiler.flash.abc.types.Multiname; +import com.jpexs.decompiler.flash.abc.types.traits.Trait; +import com.jpexs.decompiler.flash.abc.types.traits.TraitMethodGetterSetter; import com.jpexs.decompiler.flash.ecma.Undefined; +import com.jpexs.decompiler.graph.DottedChain; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.NotCompileTimeItem; import com.jpexs.decompiler.graph.TranslateStack; +import java.util.ArrayList; import java.util.List; /** @@ -62,7 +67,26 @@ public abstract class GetLocalTypeIns extends InstructionDefinition { if (localData.isStatic) { stack.push(new ClassAVM2Item(localData.getInstanceInfo().get(localData.classIndex).getName(localData.getConstants()))); } else { - stack.push(new ThisAVM2Item(ins, localData.lineStartInstruction, localData.getInstanceInfo().get(localData.classIndex).getName(localData.getConstants()))); + + List ts = localData.getInstanceInfo().get(localData.classIndex).instance_traits.traits; + boolean isBasicObject = true; + if (!"Object".equals(localData.getConstants().getMultiname(localData.getInstanceInfo().get(localData.classIndex).super_index).getNameWithNamespace(localData.getConstants()).toRawString())) { + //TODO: check for toString and valueOf in parent object + isBasicObject = false; + } else { + for (Trait t : ts) { + if (t instanceof TraitMethodGetterSetter) { + if ("toString".equals(t.getName(localData.abc).getName(localData.getConstants(), new ArrayList<>(), true))) { + isBasicObject = false; + } + if ("valueOf".equals(t.getName(localData.abc).getName(localData.getConstants(), new ArrayList<>(), true))) { + isBasicObject = false; + } + } + } + } + Multiname m = localData.getInstanceInfo().get(localData.classIndex).getName(localData.getConstants()); + stack.push(new ThisAVM2Item(ins, localData.lineStartInstruction, m, m.getNameWithNamespace(localData.getConstants()), isBasicObject)); } return; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetLexIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetLexIns.java index 2e5a7ac1c..817050bbe 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetLexIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetLexIns.java @@ -41,7 +41,7 @@ public class GetLexIns extends InstructionDefinition { public void translate(AVM2LocalData localData, TranslateStack stack, AVM2Instruction ins, List output, String path) { int multinameIndex = ins.operands[0]; Multiname multiname = localData.getConstants().getMultiname(multinameIndex); - stack.push(new GetLexAVM2Item(ins, localData.lineStartInstruction, multiname)); + stack.push(new GetLexAVM2Item(ins, localData.lineStartInstruction, multiname, localData.getConstants())); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetPropertyIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetPropertyIns.java index 6fcf20e16..3dfe6a39d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetPropertyIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetPropertyIns.java @@ -19,10 +19,18 @@ package com.jpexs.decompiler.flash.abc.avm2.instructions.other; import com.jpexs.decompiler.flash.abc.ABC; import com.jpexs.decompiler.flash.abc.AVM2LocalData; import com.jpexs.decompiler.flash.abc.avm2.AVM2Code; +import com.jpexs.decompiler.flash.abc.avm2.AVM2ConstantPool; +import com.jpexs.decompiler.flash.abc.avm2.LocalDataArea; +import com.jpexs.decompiler.flash.abc.avm2.exceptions.AVM2ExecutionException; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.InstructionDefinition; import com.jpexs.decompiler.flash.abc.avm2.model.FullMultinameAVM2Item; import com.jpexs.decompiler.flash.abc.avm2.model.GetPropertyAVM2Item; +import com.jpexs.decompiler.flash.abc.types.Multiname; +import com.jpexs.decompiler.flash.ecma.ArrayType; +import com.jpexs.decompiler.flash.ecma.EcmaScript; +import com.jpexs.decompiler.flash.ecma.ObjectType; +import com.jpexs.decompiler.flash.ecma.Undefined; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.TranslateStack; import java.util.List; @@ -37,6 +45,28 @@ public class GetPropertyIns extends InstructionDefinition { super(0x66, "getproperty", new int[]{AVM2Code.DAT_MULTINAME_INDEX}, true); } + @Override + public boolean execute(LocalDataArea lda, AVM2ConstantPool constants, AVM2Instruction ins) throws AVM2ExecutionException { + if (constants.getMultiname(ins.operands[0]).kind == Multiname.MULTINAMEL) { + String name = EcmaScript.toString(lda.operandStack.pop()); + Object obj = lda.operandStack.pop(); + if (obj == ArrayType.EMPTY_ARRAY) { + if ("length".equals(name)) { + lda.operandStack.push(0L); + } else { + lda.operandStack.push(Undefined.INSTANCE); + } + return true; + } + if (obj == ObjectType.EMPTY_OBJECT) { + lda.operandStack.push(Undefined.INSTANCE); + return true; + } + return true; + } + return false; + } + @Override public void translate(AVM2LocalData localData, TranslateStack stack, AVM2Instruction ins, List output, String path) { int multinameIndex = ins.operands[0]; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetSlotIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetSlotIns.java index db584f774..b55572417 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetSlotIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/GetSlotIns.java @@ -56,7 +56,7 @@ public class GetSlotIns extends InstructionDefinition { } else if (obj instanceof ClassAVM2Item) { slotname = ((ClassAVM2Item) obj).className; } else if (obj instanceof ThisAVM2Item) { - slotname = ((ThisAVM2Item) obj).className; + slotname = ((ThisAVM2Item) obj).classMultiname; } else if (obj instanceof ScriptAVM2Item) { List traits = localData.getScriptInfo().get(((ScriptAVM2Item) obj).scriptIndex).traits.traits; for (int t = 0; t < traits.size(); t++) { diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/SetSlotIns.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/SetSlotIns.java index 3fe7538f4..6dfa5870a 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/SetSlotIns.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/instructions/other/SetSlotIns.java @@ -76,7 +76,7 @@ public class SetSlotIns extends InstructionDefinition implements SetTypeIns { } else if (obj instanceof ClassAVM2Item) { slotname = ((ClassAVM2Item) obj).className; } else if (obj instanceof ThisAVM2Item) { - slotname = ((ThisAVM2Item) obj).className; + slotname = ((ThisAVM2Item) obj).classMultiname; } else if (obj instanceof ScriptAVM2Item) { List traits = localData.getScriptInfo().get(((ScriptAVM2Item) obj).scriptIndex).traits.traits; for (int t = 0; t < traits.size(); t++) { diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CallAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CallAVM2Item.java index a8a920e5d..10892e0de 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CallAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CallAVM2Item.java @@ -16,12 +16,23 @@ */ package com.jpexs.decompiler.flash.abc.avm2.model; +import com.jpexs.decompiler.flash.ecma.EcmaScript; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; +import com.jpexs.helpers.utf8.Utf8Helper; +import java.io.UnsupportedEncodingException; +import java.net.URLDecoder; +import java.net.URLEncoder; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.logging.Level; +import java.util.logging.Logger; /** * @@ -35,6 +46,101 @@ public class CallAVM2Item extends AVM2Item { public List arguments; + private static abstract class Func implements Callable { + + @Override + public Object call(String methodName, List args) { + return call(args); + } + } + + private static Map bundledFunctions = new HashMap<>(); + + static { + bundledFunctions.put("parseInt", new Func() { + @Override + public Object call(List args) { + Object v = args.get(0); + Object r = args.size() > 1 ? args.get(0) : 0L; + return EcmaScript.parseInt(v, r); + } + }); + bundledFunctions.put("parseFloat", new Func() { + @Override + public Object call(List args) { + return EcmaScript.parseFloat(args.get(0)); + } + }); + bundledFunctions.put("Number", new Func() { + @Override + public Object call(List args) { + return EcmaScript.toNumber(args.get(0)); + } + }); + bundledFunctions.put("isNaN", new Func() { + @Override + public Object call(List args) { + return EcmaScript.isNaN(args.get(0)); + } + }); + + bundledFunctions.put("int", new Func() { + @Override + public Object call(List args) { + return EcmaScript.toInt32(args.get(0)); + } + }); + + bundledFunctions.put("uint", new Func() { + @Override + public Object call(List args) { + return EcmaScript.toUint32(args.get(0)); + } + }); + + bundledFunctions.put("encodeURI", new Func() { + @Override + public Object call(List args) { + return EcmaScript.encodeUri(args.get(0)); + } + }); + + bundledFunctions.put("decodeURI", new Func() { + @Override + public Object call(List args) { + return EcmaScript.decodeUri(args.get(0)); + } + }); + + bundledFunctions.put("encodeURIComponent", new Func() { + @Override + public Object call(List args) { + return EcmaScript.encodeUriComponent(args.get(0)); + } + }); + + bundledFunctions.put("decodeURIComponent", new Func() { + @Override + public Object call(List args) { + return EcmaScript.decodeUriComponent(args.get(0)); + } + }); + + bundledFunctions.put("escape", new Func() { + @Override + public Object call(List args) { + return EcmaScript.escape(args.get(0)); + } + }); + + bundledFunctions.put("unescape", new Func() { + @Override + public Object call(List args) { + return EcmaScript.unescape(args.get(0)); + } + }); + } + public CallAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem receiver, GraphTargetItem function, List arguments) { super(instruction, lineStartIns, PRECEDENCE_PRIMARY); this.receiver = receiver; @@ -42,6 +148,51 @@ public class CallAVM2Item extends AVM2Item { this.arguments = arguments; } + @Override + public Object getResult() { + if (!isCompileTime()) { + return null; + } + List oargs = new ArrayList<>(); + for (GraphTargetItem ot : arguments) { + Object r = ot.getResult(); + if (r == null) { + return false; + } + oargs.add(r); + } + if (function instanceof GetLexAVM2Item) { + String propName = ((GetLexAVM2Item) function).getRawPropertyName(); + if (bundledFunctions.containsKey(propName)) { + return bundledFunctions.get(propName).call(oargs); + } + } else if (function instanceof Callable) { + return ((Callable) function).call(oargs); + } + return null; + } + + @Override + public boolean isCompileTime(Set dependencies) { + + for (GraphTargetItem a : arguments) { + if (!a.isCompileTime(dependencies)) { + return false; + } + } + + //TODO: receiver? + if ((function instanceof Callable) && (function.isCompileTime())) { + return true; + } else if (function instanceof GetLexAVM2Item) { + String propName = ((GetLexAVM2Item) function).getRawPropertyName(); + if (bundledFunctions.containsKey(propName)) { + return true; + } + } + return false; + } + @Override public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { /*String recPart = ""; receiver.toString(constants, localRegNames) + writer.append("."); diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/Callable.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/Callable.java new file mode 100644 index 000000000..ae0e339e8 --- /dev/null +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/Callable.java @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2010-2016 JPEXS, All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. + */ +package com.jpexs.decompiler.flash.abc.avm2.model; + +import java.util.List; + +/** + * + * @author JPEXS + */ +public interface Callable { + + public Object call(String methodName, List args); + + public Object call(List args); +} diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CoerceAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CoerceAVM2Item.java index cdc9026e7..7d28c1408 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CoerceAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/CoerceAVM2Item.java @@ -81,6 +81,9 @@ public class CoerceAVM2Item extends AVM2Item { if (ret == Undefined.INSTANCE) { return Null.INSTANCE; } + if (ret == null) { + return null; + } return ret.toString(); case "*": break; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FloatValueAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FloatValueAVM2Item.java index 9d0d44b8b..f0dcba15d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FloatValueAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FloatValueAVM2Item.java @@ -20,6 +20,7 @@ import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; import com.jpexs.decompiler.flash.abc.avm2.parser.script.AVM2SourceGenerator; +import com.jpexs.decompiler.flash.ecma.EcmaScript; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; @@ -45,7 +46,7 @@ public class FloatValueAVM2Item extends NumberValueAVM2Item { @Override public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) { - return writer.append(value); + return writer.append(EcmaScript.toString(value)); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FullMultinameAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FullMultinameAVM2Item.java index 053bfd858..821f80fdd 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FullMultinameAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/FullMultinameAVM2Item.java @@ -106,7 +106,11 @@ public class FullMultinameAVM2Item extends AVM2Item { } if (name != null) { writer.append("["); - name.toString(writer, localData); + if (name instanceof IntegerValueAVM2Item) { + name.toString(writer, localData); + } else { + name.toStringString(writer, localData); + } writer.append("]"); } else { AVM2ConstantPool constants = localData.constantsAvm2; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetLexAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetLexAVM2Item.java index 772da1ac6..2c3a67ef6 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetLexAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetLexAVM2Item.java @@ -16,12 +16,15 @@ */ package com.jpexs.decompiler.flash.abc.avm2.model; +import com.jpexs.decompiler.flash.abc.avm2.AVM2ConstantPool; import com.jpexs.decompiler.flash.abc.types.Multiname; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; +import com.jpexs.decompiler.graph.DottedChain; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; +import java.util.ArrayList; /** * @@ -30,10 +33,16 @@ import com.jpexs.decompiler.graph.model.LocalData; public class GetLexAVM2Item extends AVM2Item { public Multiname propertyName; + private DottedChain fullPropertyName; - public GetLexAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, Multiname propertyName) { + public GetLexAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, Multiname propertyName, AVM2ConstantPool constants) { super(instruction, lineStartIns, PRECEDENCE_PRIMARY); this.propertyName = propertyName; + this.fullPropertyName = propertyName.getNameWithNamespace(constants); + } + + public String getRawPropertyName() { + return fullPropertyName.toRawString(); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetPropertyAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetPropertyAVM2Item.java index 4ce49c27f..c29ee8f3d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetPropertyAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/GetPropertyAVM2Item.java @@ -20,6 +20,7 @@ import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; import com.jpexs.decompiler.flash.abc.avm2.parser.script.AVM2SourceGenerator; +import com.jpexs.decompiler.flash.ecma.Undefined; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; @@ -28,6 +29,7 @@ import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; import java.util.List; +import java.util.Set; /** * @@ -39,6 +41,36 @@ public class GetPropertyAVM2Item extends AVM2Item { public GraphTargetItem propertyName; + @Override + public boolean isCompileTime(Set dependencies) { + if (object instanceof NewArrayAVM2Item) { + if (((NewArrayAVM2Item) object).values.isEmpty()) { + return true; + } + } + if (object instanceof NewObjectAVM2Item) { + if (((NewObjectAVM2Item) object).pairs.isEmpty()) { + return true; + } + } + return false; + } + + @Override + public Object getResult() { + if (object instanceof NewArrayAVM2Item) { + if (((NewArrayAVM2Item) object).values.isEmpty()) { + return Undefined.INSTANCE; + } + } + if (object instanceof NewObjectAVM2Item) { + if (((NewObjectAVM2Item) object).pairs.isEmpty()) { + return Undefined.INSTANCE; + } + } + return null; + } + public GetPropertyAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem object, GraphTargetItem propertyName) { super(instruction, lineStartIns, PRECEDENCE_PRIMARY); this.object = object; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/HasNextAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/HasNextAVM2Item.java index 7529357f2..c3b2ab415 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/HasNextAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/HasNextAVM2Item.java @@ -58,13 +58,13 @@ public class HasNextAVM2Item extends AVM2Item { writer.append("§§hasnext("); if (obj != null) { - obj.appendTo(writer, localData); + obj.appendTry(writer, localData); } else { writer.append("null"); } writer.append(","); if (index != null) { - index.appendTo(writer, localData); + index.appendTry(writer, localData); } else { writer.append("null"); } @@ -74,7 +74,7 @@ public class HasNextAVM2Item extends AVM2Item { @Override public GraphTargetItem returnType() { - return TypeItem.UNBOUNDED; + return TypeItem.BOOLEAN; } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/InitVectorAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/InitVectorAVM2Item.java index f4e1623ab..6e77a22dd 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/InitVectorAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/InitVectorAVM2Item.java @@ -80,14 +80,14 @@ public class InitVectorAVM2Item extends AVM2Item { @Override public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { writer.append("<"); - subtype.appendTo(writer, localData); + subtype.appendTry(writer, localData); writer.append(">"); writer.append("["); for (int i = 0; i < arguments.size(); i++) { if (i > 0) { writer.append(","); } - arguments.get(i).appendTo(writer, localData); + arguments.get(i).appendTry(writer, localData); } writer.append("]"); return writer; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/IntegerValueAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/IntegerValueAVM2Item.java index 74b52561c..52a8ee326 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/IntegerValueAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/IntegerValueAVM2Item.java @@ -21,6 +21,7 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; import com.jpexs.decompiler.flash.abc.avm2.parser.script.AVM2SourceGenerator; import com.jpexs.decompiler.flash.configuration.Configuration; +import com.jpexs.decompiler.flash.ecma.EcmaScript; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.DottedChain; @@ -117,7 +118,7 @@ public class IntegerValueAVM2Item extends NumberValueAVM2Item implements Integer } } - return writer.append(value); + return writer.append(EcmaScript.toString(value)); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/LocalRegAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/LocalRegAVM2Item.java index bca2924bf..242d3dc5f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/LocalRegAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/LocalRegAVM2Item.java @@ -27,6 +27,7 @@ import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; +import java.util.HashSet; import java.util.List; import java.util.Set; @@ -49,13 +50,11 @@ public class LocalRegAVM2Item extends AVM2Item { this.regIndex = regIndex; if (computedValue == null) { computedResult = null; + } else if (computedValue.isCompileTime()) { + computedResult = computedValue.getResult(); + isCT = true; } else { - if (computedValue.isCompileTime()) { - computedResult = computedValue.getResult(); - isCT = true; - } else { - computedResult = null; - } + computedResult = null; } this.computedValue = computedValue; } @@ -81,17 +80,31 @@ public class LocalRegAVM2Item extends AVM2Item { @Override public Object getResult() { + if (computedValue == null) { + return null; + } return computedValue.getResult(); } @Override public Double getResultAsNumber() { + if (computedValue == null) { + return null; + } return computedValue.getResultAsNumber(); } @Override public boolean isCompileTime(Set dependencies) { - return computedValue instanceof UndefinedAVM2Item; + return (computedValue instanceof UndefinedAVM2Item); + } + + @Override + public boolean isConvertedCompileTime(Set dependencies) { + if (computedValue == null) { + return false; + } + return ((computedValue instanceof ThisAVM2Item) && computedValue.isConvertedCompileTime(dependencies)); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewArrayAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewArrayAVM2Item.java index f88c3f224..37e905a8b 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewArrayAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewArrayAVM2Item.java @@ -19,6 +19,7 @@ package com.jpexs.decompiler.flash.abc.avm2.model; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; +import com.jpexs.decompiler.flash.ecma.ArrayType; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; @@ -26,7 +27,9 @@ import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; +import java.util.ArrayList; import java.util.List; +import java.util.Set; /** * @@ -58,6 +61,37 @@ public class NewArrayAVM2Item extends AVM2Item { return TypeItem.ARRAY; } + @Override + public Object getResult() { + List ovalues = new ArrayList<>(); + for (GraphTargetItem it : values) { + Object o = it.getResult(); + if (o == null) { + return null; + } + ovalues.add(o); + } + return new ArrayType(ovalues); + } + + @Override + public GraphTargetItem simplify(String implicitCoerce) { + if (implicitCoerce.isEmpty()) { + return this; + } + return super.simplify(implicitCoerce); + } + + @Override + public boolean isCompileTime(Set dependencies) { + for (GraphTargetItem v : values) { + if (!v.isCompileTime()) { + return false; + } + } + return true; + } + @Override public boolean hasReturnValue() { return true; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewObjectAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewObjectAVM2Item.java index 21989c1cd..b2837140e 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewObjectAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/NewObjectAVM2Item.java @@ -19,6 +19,8 @@ package com.jpexs.decompiler.flash.abc.avm2.model; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; +import com.jpexs.decompiler.flash.ecma.EcmaScript; +import com.jpexs.decompiler.flash.ecma.ObjectType; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.DottedChain; @@ -28,7 +30,10 @@ import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.Set; /** * @@ -87,4 +92,32 @@ public class NewObjectAVM2Item extends AVM2Item { new AVM2Instruction(0, AVM2Instructions.NewObject, new int[]{pairs.size()}) ); } + + @Override + public Object getResult() { + Map props = new HashMap<>(); + for (NameValuePair v : pairs) { + props.put(EcmaScript.toString(v.name.getResult()), v.value.getResult()); + } + return new ObjectType(props); + } + + @Override + public GraphTargetItem simplify(String implicitCoerce) { + if (implicitCoerce.isEmpty()) { + return this; + } else { + return super.simplify(implicitCoerce); + } + } + + @Override + public boolean isCompileTime(Set dependencies) { + for (NameValuePair v : pairs) { + if (!v.name.isCompileTime() || !v.value.isCompileTime()) { + return false; + } + } + return true; + } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/RegExpAvm2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/RegExpAvm2Item.java index 03f2c6d99..c479ded89 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/RegExpAvm2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/RegExpAvm2Item.java @@ -7,6 +7,9 @@ import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; import com.jpexs.decompiler.flash.abc.avm2.parser.script.AVM2SourceGenerator; import com.jpexs.decompiler.flash.abc.types.Namespace; import com.jpexs.decompiler.flash.configuration.Configuration; +import com.jpexs.decompiler.flash.ecma.ArrayType; +import com.jpexs.decompiler.flash.ecma.EcmaScript; +import com.jpexs.decompiler.flash.ecma.Undefined; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; @@ -15,13 +18,16 @@ import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; import com.jpexs.helpers.Helper; +import java.util.ArrayList; import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; /** * * @author JPEXS */ -public class RegExpAvm2Item extends AVM2Item { +public class RegExpAvm2Item extends AVM2Item implements Callable { public String pattern; @@ -33,6 +39,11 @@ public class RegExpAvm2Item extends AVM2Item { this.modifier = modifier; } + @Override + public boolean isCompileTime() { + return true; + } + public static String escapeRegExpString(String s) { StringBuilder ret = new StringBuilder(s.length()); for (int i = 0; i < s.length(); i++) { @@ -101,4 +112,55 @@ public class RegExpAvm2Item extends AVM2Item { ins(AVM2Instructions.Construct, hasModifier ? 2 : 1) ); } + + @Override + public Object call(String methodName, List args) { + int flags = 0; + for (char c : modifier.toCharArray()) { + switch (c) { + case 'g': + //global (??) + break; + case 'i': + flags |= Pattern.CASE_INSENSITIVE; + break; + case 's': + flags |= Pattern.DOTALL; + break; + case 'm': + flags |= Pattern.MULTILINE; + break; + case 'x': + flags |= Pattern.COMMENTS; //? + break; + default: + //? + break; + } + } + Pattern p = Pattern.compile(pattern, flags); + switch (methodName) { + case "exec": + String estr = EcmaScript.toString(args.get(0)); + Matcher m = p.matcher(estr); + m.find(); + List avals = new ArrayList<>(); + for (int i = 0; i <= m.groupCount(); i++) { + avals.add(m.group(i)); + } + ArrayType a = new ArrayType(avals); + a.setAttribute("input", estr); + a.setAttribute("index", m.start()); + return a; + case "test": + String tstr = EcmaScript.toString(args.get(0)); + return p.matcher(tstr).find(); //boolean + } + return Undefined.INSTANCE; //? + } + + @Override + public Object call(List args) { + return call("exec", args); + } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/ThisAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/ThisAVM2Item.java index eb0ef6a29..0524b5c7e 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/ThisAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/ThisAVM2Item.java @@ -17,17 +17,22 @@ package com.jpexs.decompiler.flash.abc.avm2.model; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; +import com.jpexs.decompiler.flash.abc.avm2.AVM2ConstantPool; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; import com.jpexs.decompiler.flash.abc.types.Multiname; +import com.jpexs.decompiler.flash.ecma.ObjectType; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; +import com.jpexs.decompiler.graph.DottedChain; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.TypeItem; import com.jpexs.decompiler.graph.model.LocalData; +import java.util.HashMap; import java.util.List; +import java.util.Set; /** * @@ -35,14 +40,41 @@ import java.util.List; */ public class ThisAVM2Item extends AVM2Item { - public Multiname className; + public DottedChain className; + public boolean basicObject; + public Multiname classMultiname; - public ThisAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, Multiname className) { + public ThisAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, Multiname classMultiname, DottedChain className, boolean basicObject) { super(instruction, lineStartIns, PRECEDENCE_PRIMARY); this.className = className; + this.classMultiname = classMultiname; + this.basicObject = basicObject; getSrcData().localName = "this"; } + public boolean isBasicObject() { + return basicObject; + } + + @Override + public boolean isConvertedCompileTime(Set dependencies) { + return isBasicObject(); + } + + @Override + public Object getResult() { + if (basicObject) { + return new ObjectType(new HashMap<>()) { + @Override + public String toString() { + return "[object " + className.getLast() + "]"; + } + + }; + } + return null; + } + @Override public String toString() { return "this"; diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/DeclarationAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/DeclarationAVM2Item.java index 70ca0a0aa..befc41053 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/DeclarationAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/DeclarationAVM2Item.java @@ -96,7 +96,7 @@ public class DeclarationAVM2Item extends AVM2Item { writer.append("var "); writer.append(localName); writer.append(":"); - coerType.appendTo(writer, localData); + coerType.appendTry(writer, localData); writer.append(" = "); return lti.value.toString(writer, localData); } @@ -110,7 +110,7 @@ public class DeclarationAVM2Item extends AVM2Item { ssti.getName(writer, localData); writer.append(":"); - type.appendTo(writer, localData); + type.appendTry(writer, localData); writer.append(" = "); return ssti.value.toString(writer, localData); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/FilterAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/FilterAVM2Item.java index 3fb0243d0..f6c656955 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/FilterAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/clauses/FilterAVM2Item.java @@ -43,7 +43,7 @@ public class FilterAVM2Item extends AVM2Item { public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { collection.toString(writer, localData); writer.append(".("); - expression.toString(writer, localData); + expression.toStringBoolean(writer, localData); return writer.append(")"); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AddAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AddAVM2Item.java index fc9454ac6..afb25072f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AddAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AddAVM2Item.java @@ -39,7 +39,7 @@ import java.util.List; public class AddAVM2Item extends BinaryOpItem { public AddAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "+"); + super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "+", "", ""); //? } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AsTypeAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AsTypeAVM2Item.java index a2d05f8f5..a81884f0c 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AsTypeAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/AsTypeAVM2Item.java @@ -33,7 +33,7 @@ import java.util.List; public class AsTypeAVM2Item extends BinaryOpItem { public AsTypeAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value, GraphTargetItem type) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "as"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "as", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitAndAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitAndAVM2Item.java index 773f710ab..a43f53b5c 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitAndAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitAndAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class BitAndAVM2Item extends BinaryOpItem { public BitAndAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEAND, leftSide, rightSide, "&"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEAND, leftSide, rightSide, "&", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitNotAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitNotAVM2Item.java index f29641445..4caaf9890 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitNotAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitNotAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class BitNotAVM2Item extends UnaryOpItem { public BitNotAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "~"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "~", "int"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitOrAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitOrAVM2Item.java index 6e3205d2a..fadc8a4c0 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitOrAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitOrAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class BitOrAVM2Item extends BinaryOpItem { public BitOrAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEOR, leftSide, rightSide, "|"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEOR, leftSide, rightSide, "|", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitXorAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitXorAVM2Item.java index f0e78d527..a43e89e34 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitXorAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/BitXorAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class BitXorAVM2Item extends BinaryOpItem { public BitXorAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEXOR, leftSide, rightSide, "^"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEXOR, leftSide, rightSide, "^", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/DivideAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/DivideAVM2Item.java index 3669a3881..c495c95f8 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/DivideAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/DivideAVM2Item.java @@ -36,7 +36,7 @@ import java.util.List; public class DivideAVM2Item extends BinaryOpItem { public DivideAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "/"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "/", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/EqAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/EqAVM2Item.java index 87280c7eb..af47abae0 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/EqAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/EqAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class EqAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition, EqualsTypeItem { public EqAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "=="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "==", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GeAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GeAVM2Item.java index 07e4476f6..d6ff97cdc 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GeAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GeAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class GeAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public GeAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">="); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">=", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GtAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GtAVM2Item.java index 7b7a85ac3..5b449f5ab 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GtAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/GtAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class GtAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public GtAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InAVM2Item.java index bbe2647f9..2a5edb5c6 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InAVM2Item.java @@ -35,7 +35,7 @@ import java.util.List; public class InAVM2Item extends BinaryOpItem { public InAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem name, GraphTargetItem object) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, name, object, "in"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, name, object, "in", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InstanceOfAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InstanceOfAVM2Item.java index 28641593a..12181df58 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InstanceOfAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/InstanceOfAVM2Item.java @@ -35,7 +35,7 @@ import java.util.List; public class InstanceOfAVM2Item extends BinaryOpItem { public InstanceOfAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value, GraphTargetItem type) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "instanceof"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "instanceof", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/IsTypeAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/IsTypeAVM2Item.java index 44da55666..24c73358b 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/IsTypeAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/IsTypeAVM2Item.java @@ -35,7 +35,7 @@ import java.util.List; public class IsTypeAVM2Item extends BinaryOpItem { public IsTypeAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value, GraphTargetItem type) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "is"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "is", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LShiftAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LShiftAVM2Item.java index 01b4c3c9e..83953174e 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LShiftAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LShiftAVM2Item.java @@ -19,11 +19,13 @@ package com.jpexs.decompiler.flash.abc.avm2.model.operations; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instruction; import com.jpexs.decompiler.flash.abc.avm2.instructions.AVM2Instructions; +import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphTargetItem; import com.jpexs.decompiler.graph.SourceGenerator; import com.jpexs.decompiler.graph.model.BinaryOpItem; +import com.jpexs.decompiler.graph.model.LocalData; import com.jpexs.decompiler.graph.model.UnboundedTypeItem; import java.util.List; @@ -34,7 +36,7 @@ import java.util.List; public class LShiftAVM2Item extends BinaryOpItem { public LShiftAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, "<<"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, "<<", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LeAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LeAVM2Item.java index 49ff06be7..e37dcbf02 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LeAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LeAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class LeAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public LeAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<="); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<=", "", ""); } @Override @@ -76,6 +76,6 @@ public class LeAVM2Item extends BinaryOpItem implements LogicalOpItem, IfConditi @Override public GraphTargetItem returnType() { - return new TypeItem(DottedChain.BOOLEAN); + return TypeItem.BOOLEAN; } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LtAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LtAVM2Item.java index d00159867..a3a182ae2 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LtAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/LtAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class LtAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public LtAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/ModuloAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/ModuloAVM2Item.java index 7a5e31608..829577aa5 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/ModuloAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/ModuloAVM2Item.java @@ -36,7 +36,7 @@ import java.util.List; public class ModuloAVM2Item extends BinaryOpItem { public ModuloAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "%"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "%", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/MultiplyAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/MultiplyAVM2Item.java index 825c414a4..0b23ed239 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/MultiplyAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/MultiplyAVM2Item.java @@ -36,7 +36,7 @@ import java.util.List; public class MultiplyAVM2Item extends BinaryOpItem { public MultiplyAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "*"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "*", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NegAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NegAVM2Item.java index b3e2035e2..147f4df42 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NegAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NegAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class NegAVM2Item extends UnaryOpItem { public NegAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "-"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "-", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NeqAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NeqAVM2Item.java index 9ba677060..a8f3f9241 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NeqAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/NeqAVM2Item.java @@ -37,7 +37,7 @@ import java.util.List; public class NeqAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public NeqAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!=", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreDecrementAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreDecrementAVM2Item.java index b8a1fbdce..245d3ab42 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreDecrementAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreDecrementAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class PreDecrementAVM2Item extends UnaryOpItem implements AssignmentAVM2Item { public PreDecrementAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem object) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "--"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "--", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreIncrementAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreIncrementAVM2Item.java index d43b7990e..5a712e4fe 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreIncrementAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/PreIncrementAVM2Item.java @@ -33,7 +33,7 @@ import java.util.List; public class PreIncrementAVM2Item extends UnaryOpItem { public PreIncrementAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem object) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "++"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "++", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/RShiftAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/RShiftAVM2Item.java index d40836bf8..2a5ec8ac5 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/RShiftAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/RShiftAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class RShiftAVM2Item extends BinaryOpItem { public RShiftAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictEqAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictEqAVM2Item.java index 9282f00d1..e1bca0a55 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictEqAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictEqAVM2Item.java @@ -38,7 +38,7 @@ import java.util.List; public class StrictEqAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition, EqualsTypeItem { public StrictEqAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "==="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "===", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictNeqAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictNeqAVM2Item.java index e5d2c925e..52421e66d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictNeqAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/StrictNeqAVM2Item.java @@ -37,7 +37,7 @@ import java.util.List; public class StrictNeqAVM2Item extends BinaryOpItem implements LogicalOpItem, IfCondition { public StrictNeqAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!=="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!==", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/SubtractAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/SubtractAVM2Item.java index 06f4f8107..270b85b30 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/SubtractAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/SubtractAVM2Item.java @@ -37,7 +37,7 @@ import java.util.List; public class SubtractAVM2Item extends BinaryOpItem { public SubtractAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "-"); + super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "-", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/TypeOfAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/TypeOfAVM2Item.java index 95198c815..845a8ebf4 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/TypeOfAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/TypeOfAVM2Item.java @@ -37,7 +37,7 @@ import java.util.Set; public class TypeOfAVM2Item extends UnaryOpItem { public TypeOfAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "typeof "); + super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "typeof ", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/URShiftAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/URShiftAVM2Item.java index ec3601f37..85c93b916 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/URShiftAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/model/operations/URShiftAVM2Item.java @@ -34,7 +34,7 @@ import java.util.List; public class URShiftAVM2Item extends BinaryOpItem { public URShiftAVM2Item(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>>"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>>", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/parser/script/XMLAVM2Item.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/parser/script/XMLAVM2Item.java index 3b2d80485..acc7bfc12 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/parser/script/XMLAVM2Item.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/abc/avm2/parser/script/XMLAVM2Item.java @@ -44,7 +44,7 @@ public class XMLAVM2Item extends AVM2Item { @Override public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { - return value.appendTo(writer, localData); + return value.appendTry(writer, localData); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallFunctionActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallFunctionActionItem.java index e72e8384c..bc91e046a 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallFunctionActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallFunctionActionItem.java @@ -63,7 +63,7 @@ public class CallFunctionActionItem extends ActionItem { if (functionName instanceof DirectValueActionItem) { writer.append(IdentifiersDeobfuscation.printIdentifier(false, (functionName).toStringNoQuotes(localData))); } else { - functionName.appendTo(writer, localData); + functionName.appendTry(writer, localData); } writer.spaceBeforeCallParenthesies(arguments.size()); writer.append("("); diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallMethodActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallMethodActionItem.java index 78bd762cb..449f04818 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallMethodActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/CallMethodActionItem.java @@ -86,7 +86,7 @@ public class CallMethodActionItem extends ActionItem { } } else { writer.append("this["); - methodName.appendTo(writer, localData); + methodName.appendTry(writer, localData); writer.append("].call"); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/FSCommandActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/FSCommandActionItem.java index b73be3ee9..60aaa51dc 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/FSCommandActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/FSCommandActionItem.java @@ -47,7 +47,7 @@ public class FSCommandActionItem extends ActionItem { writer.append("fscommand"); writer.spaceBeforeCallParenthesies(1); writer.append("("); - command.appendTo(writer, localData); + command.appendTry(writer, localData); return writer.append(")"); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/GetVariableActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/GetVariableActionItem.java index 5d432bd42..c40c5d50c 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/GetVariableActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/GetVariableActionItem.java @@ -76,7 +76,7 @@ public class GetVariableActionItem extends ActionItem { return IdentifiersDeobfuscation.appendObfuscatedIdentifier(((DirectValueActionItem) name).toStringNoQuotes(localData), writer); } else if ((!(name instanceof DirectValueActionItem)) || (!((DirectValueActionItem) name).isString())) { writer.append("eval("); - name.appendTo(writer, localData); + name.appendTry(writer, localData); return writer.append(")"); } HighlightData srcData = getSrcData(); diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AddActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AddActionItem.java index 574ccadcb..5c327d868 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AddActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AddActionItem.java @@ -40,7 +40,7 @@ public class AddActionItem extends BinaryOpItem { boolean version2; public AddActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide, boolean version2) { - super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "+"); + super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "+", "", ""); this.version2 = version2; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AndActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AndActionItem.java index 8c0e54039..3cfcdfb6f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AndActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/AndActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class AndActionItem extends BinaryOpItem { public AndActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_LOGICALAND, leftSide, rightSide, "and"); + super(instruction, lineStartIns, PRECEDENCE_LOGICALAND, leftSide, rightSide, "and", "Boolean", "Boolean"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitAndActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitAndActionItem.java index d6b7a7fde..1affd2bca 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitAndActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitAndActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class BitAndActionItem extends BinaryOpItem { public BitAndActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEAND, leftSide, rightSide, "&"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEAND, leftSide, rightSide, "&", "int", "int"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitOrActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitOrActionItem.java index f55435135..868399990 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitOrActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitOrActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class BitOrActionItem extends BinaryOpItem { public BitOrActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEOR, leftSide, rightSide, "|"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEOR, leftSide, rightSide, "|", "int", "int"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitXorActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitXorActionItem.java index 1976704d9..d95a68703 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitXorActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/BitXorActionItem.java @@ -37,7 +37,7 @@ import java.util.List; public class BitXorActionItem extends BinaryOpItem { public BitXorActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISEXOR, leftSide, rightSide, "^"); + super(instruction, lineStartIns, PRECEDENCE_BITWISEXOR, leftSide, rightSide, "^", "int", "int"); } @Override @@ -56,7 +56,7 @@ public class BitXorActionItem extends BinaryOpItem { if (leftSide.getPrecedence() > PRECEDENCE_UNARY) { writer.append("("); } - leftSide.appendTo(writer, localData); + leftSide.appendTry(writer, localData); if (leftSide.getPrecedence() > PRECEDENCE_UNARY) { writer.append(")"); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/DivideActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/DivideActionItem.java index 9d7798511..a60d678a8 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/DivideActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/DivideActionItem.java @@ -33,7 +33,7 @@ import java.util.List; public class DivideActionItem extends BinaryOpItem { public DivideActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "/"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "/", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/EqActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/EqActionItem.java index 74c85ab09..729f1a391 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/EqActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/EqActionItem.java @@ -39,7 +39,7 @@ public class EqActionItem extends BinaryOpItem implements LogicalOpItem, EqualsT boolean version2; public EqActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide, boolean version2) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "=="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "==", "", ""); this.version2 = version2; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GeActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GeActionItem.java index 64cb3d594..92d06149c 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GeActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GeActionItem.java @@ -42,7 +42,7 @@ public class GeActionItem extends BinaryOpItem implements LogicalOpItem, Inverte boolean version2; public GeActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide, boolean version2) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">="); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">=", "", ""); this.version2 = version2; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GtActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GtActionItem.java index f35fded73..bf6cb197f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GtActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/GtActionItem.java @@ -39,7 +39,7 @@ import java.util.List; public class GtActionItem extends BinaryOpItem implements LogicalOpItem { public GtActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, ">", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InActionItem.java index 5e1abb010..ca6f1d6cf 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InActionItem.java @@ -30,7 +30,7 @@ import java.util.Set; public class InActionItem extends BinaryOpItem { public InActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, ActionItem name, ActionItem object) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, name, object, "in"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, name, object, "in", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InstanceOfActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InstanceOfActionItem.java index 6f8f3e846..e6bc51904 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InstanceOfActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/InstanceOfActionItem.java @@ -34,7 +34,7 @@ import java.util.Set; public class InstanceOfActionItem extends BinaryOpItem { public InstanceOfActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value, GraphTargetItem type) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "instanceof"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, value, type, "instanceof", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LShiftActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LShiftActionItem.java index 75f8a201f..57a25e8fd 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LShiftActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LShiftActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class LShiftActionItem extends BinaryOpItem { public LShiftActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, "<<"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, "<<", "int", "int"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LeActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LeActionItem.java index 6bf562b20..37e6d7b16 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LeActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LeActionItem.java @@ -40,7 +40,7 @@ import java.util.List; public class LeActionItem extends BinaryOpItem implements LogicalOpItem, Inverted { public LeActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<="); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<=", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LtActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LtActionItem.java index 710bcb52d..a55d20bc0 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LtActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/LtActionItem.java @@ -41,7 +41,7 @@ public class LtActionItem extends BinaryOpItem implements LogicalOpItem { boolean version2; public LtActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide, boolean version2) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "<", "", ""); this.version2 = version2; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/ModuloActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/ModuloActionItem.java index 9821a0e5f..12c464b89 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/ModuloActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/ModuloActionItem.java @@ -33,7 +33,7 @@ import java.util.List; public class ModuloActionItem extends BinaryOpItem { public ModuloActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "%"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "%", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/MultiplyActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/MultiplyActionItem.java index bea4fb00b..c45f9b636 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/MultiplyActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/MultiplyActionItem.java @@ -33,7 +33,7 @@ import java.util.List; public class MultiplyActionItem extends BinaryOpItem { public MultiplyActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "*"); + super(instruction, lineStartIns, PRECEDENCE_MULTIPLICATIVE, leftSide, rightSide, "*", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/NeqActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/NeqActionItem.java index 3f46e9d2e..240e6e902 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/NeqActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/NeqActionItem.java @@ -39,7 +39,7 @@ public class NeqActionItem extends BinaryOpItem implements LogicalOpItem, Invert boolean version2; public NeqActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide, boolean version2) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!=", "", ""); this.version2 = version2; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/OrActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/OrActionItem.java index 45ab5fd3d..5304d05c0 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/OrActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/OrActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class OrActionItem extends BinaryOpItem { public OrActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_LOGICALOR, leftSide, rightSide, "or"); + super(instruction, lineStartIns, PRECEDENCE_LOGICALOR, leftSide, rightSide, "or", "Boolean", "Boolean"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreDecrementActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreDecrementActionItem.java index 8ada975a4..6f39b9f13 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreDecrementActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreDecrementActionItem.java @@ -45,7 +45,7 @@ import java.util.List; public class PreDecrementActionItem extends UnaryOpItem { public PreDecrementActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem object) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "--"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "--", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreIncrementActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreIncrementActionItem.java index b66e64215..20192e382 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreIncrementActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/PreIncrementActionItem.java @@ -45,7 +45,7 @@ import java.util.List; public class PreIncrementActionItem extends UnaryOpItem { public PreIncrementActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem object) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "++"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, object, "++", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/RShiftActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/RShiftActionItem.java index cc039c08b..d3fa735e9 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/RShiftActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/RShiftActionItem.java @@ -34,7 +34,7 @@ import java.util.List; public class RShiftActionItem extends BinaryOpItem { public RShiftActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>", "int", "int"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictEqActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictEqActionItem.java index 5f04c540a..fd3ff3df2 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictEqActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictEqActionItem.java @@ -36,7 +36,7 @@ import java.util.List; public class StrictEqActionItem extends BinaryOpItem implements LogicalOpItem, Inverted, EqualsTypeItem { public StrictEqActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "==="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "===", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictNeqActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictNeqActionItem.java index a1c8c741e..21414f30d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictNeqActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StrictNeqActionItem.java @@ -36,7 +36,7 @@ import java.util.List; public class StrictNeqActionItem extends BinaryOpItem implements LogicalOpItem, Inverted { public StrictNeqActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!=="); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "!==", "", ""); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringAddActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringAddActionItem.java index 45a31b486..3d0fb3290 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringAddActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringAddActionItem.java @@ -35,7 +35,7 @@ import java.util.Set; public class StringAddActionItem extends BinaryOpItem { public StringAddActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "add"); + super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "add", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringEqActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringEqActionItem.java index 5d112fab9..e313b6a30 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringEqActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringEqActionItem.java @@ -35,7 +35,7 @@ import java.util.Set; public class StringEqActionItem extends BinaryOpItem implements Inverted { public StringEqActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "eq"); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "eq", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGeActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGeActionItem.java index a4e2ef176..e5ea64484 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGeActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGeActionItem.java @@ -36,7 +36,7 @@ import java.util.Set; public class StringGeActionItem extends BinaryOpItem implements Inverted { public StringGeActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "ge"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "ge", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGtActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGtActionItem.java index bcc31e7a2..10650795a 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGtActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringGtActionItem.java @@ -37,7 +37,7 @@ import java.util.Set; public class StringGtActionItem extends BinaryOpItem implements Inverted { public StringGtActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "gt"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "gt", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLeActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLeActionItem.java index 85b89a77f..7e0d89278 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLeActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLeActionItem.java @@ -38,7 +38,7 @@ import java.util.Set; public class StringLeActionItem extends BinaryOpItem implements Inverted { public StringLeActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "le"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "le", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLtActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLtActionItem.java index 2d3210415..f4ac26941 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLtActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringLtActionItem.java @@ -35,7 +35,7 @@ import java.util.Set; public class StringLtActionItem extends BinaryOpItem implements Inverted { public StringLtActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "lt"); + super(instruction, lineStartIns, PRECEDENCE_RELATIONAL, leftSide, rightSide, "lt", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringNeActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringNeActionItem.java index abe8ded3b..0fe1f1c0d 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringNeActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/StringNeActionItem.java @@ -35,7 +35,7 @@ import java.util.Set; public class StringNeActionItem extends BinaryOpItem implements Inverted { public StringNeActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "ne"); + super(instruction, lineStartIns, PRECEDENCE_EQUALITY, leftSide, rightSide, "ne", "String", "String"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/SubtractActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/SubtractActionItem.java index 267c26e4b..e83773511 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/SubtractActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/SubtractActionItem.java @@ -36,7 +36,7 @@ import java.util.List; public class SubtractActionItem extends BinaryOpItem { public SubtractActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "-"); + super(instruction, lineStartIns, PRECEDENCE_ADDITIVE, leftSide, rightSide, "-", "Number", "Number"); } @Override @@ -56,28 +56,26 @@ public class SubtractActionItem extends BinaryOpItem { || ((((DirectValueActionItem) leftSide).value instanceof Long) && (((Long) ((DirectValueActionItem) leftSide).value) == 0L)))) { writer.append(operator); writer.append(" "); - rightSide.appendTo(writer, localData); + rightSide.appendTry(writer, localData); return writer; - } else { - if (rightSide.getPrecedence() >= precedence) { // >= add or subtract too - - if (leftSide.getPrecedence() > precedence) { - writer.append("("); - leftSide.toString(writer, localData); - writer.append(")"); - } else { - leftSide.toString(writer, localData); - } - writer.append(" "); - writer.append(operator); - writer.append(" "); + } else if (rightSide.getPrecedence() >= precedence) { // >= add or subtract too + if (leftSide.getPrecedence() > precedence) { writer.append("("); - rightSide.toString(writer, localData); - return writer.append(")"); + leftSide.toString(writer, localData); + writer.append(")"); } else { - return super.appendTo(writer, localData); + leftSide.toString(writer, localData); } + writer.append(" "); + writer.append(operator); + writer.append(" "); + + writer.append("("); + rightSide.toString(writer, localData); + return writer.append(")"); + } else { + return super.appendTo(writer, localData); } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/URShiftActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/URShiftActionItem.java index 7eaea85b7..8f66791f2 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/URShiftActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/model/operations/URShiftActionItem.java @@ -33,7 +33,7 @@ import java.util.List; public class URShiftActionItem extends BinaryOpItem { public URShiftActionItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>>"); + super(instruction, lineStartIns, PRECEDENCE_BITWISESHIFT, leftSide, rightSide, ">>>", "Number", "Number"); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/parser/script/VariableActionItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/parser/script/VariableActionItem.java index 2d9c506ce..51d14dea0 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/parser/script/VariableActionItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/action/parser/script/VariableActionItem.java @@ -83,7 +83,7 @@ public class VariableActionItem extends ActionItem { if (it == null) { return writer; } - return it.appendTo(writer, localData); + return it.appendTry(writer, localData); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ArrayType.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ArrayType.java new file mode 100644 index 000000000..16c36775c --- /dev/null +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ArrayType.java @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2010-2016 JPEXS, All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. + */ +package com.jpexs.decompiler.flash.ecma; + +import java.util.ArrayList; +import java.util.List; + +/** + * + * @author JPEXS + */ +public class ArrayType extends ObjectType { + + public static final ObjectType EMPTY_ARRAY = new ArrayType(); + + public List values; + + public ArrayType(List values) { + this.values = values; + } + + private ArrayType() { + this.values = new ArrayList<>(); + } + + @Override + public String toString() { + StringBuilder s = new StringBuilder(); + for (int i = 0; i < values.size(); i++) { + if (i > 0) { + s.append(","); + } + s.append(EcmaScript.toString(values.get(i))); + } + return s.toString(); + } + + @Override + public Object getAttribute(String name) { + if ("length".equals(name)) { + return (Long) (long) values.size(); + } + if (name != null && name.matches("0|[1-9][0-9]*")) { + Long index = Long.parseLong(name); + int iindex = (int) (long) index; + if (iindex >= 0 && iindex < values.size()) { + return values.get(iindex); + } + } + return super.getAttribute(name); + } + +} diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/EcmaScript.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/EcmaScript.java index fffdc2dce..c58556dca 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/EcmaScript.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/EcmaScript.java @@ -17,7 +17,14 @@ package com.jpexs.decompiler.flash.ecma; import com.jpexs.decompiler.flash.action.swf4.ConstantIndex; +import com.jpexs.helpers.utf8.Utf8Helper; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; /** * @@ -60,8 +67,56 @@ public class EcmaScript { } } - // todo: ToPrimitive - return 0.0; + return toNumber(toPrimitive(o, "Number")); + } + + public static Object toPrimitive(Object o, String prefferedType) { + if (o == Undefined.INSTANCE) { + return o; + } + if (o == Null.INSTANCE) { + return o; + } + if (o == Boolean.TRUE || o == Boolean.FALSE) { + return o; + } + if (o instanceof Number) { + return o; + } + if (o instanceof String) { + return o; + } + if (o instanceof ObjectType) { + return object_defaultValue((ObjectType) o, prefferedType); + } + return Undefined.INSTANCE; //?? + } + + public static Object object_defaultValue(ObjectType o) { + return object_defaultValue(o, "Number"); + } + + public static Object object_get(ObjectType o, String p) { + //TODO: isDataDesciptor, etc. ECMA 8.12.3 + return object_getProperty(o, p); + } + + public static Object object_getProperty(ObjectType o, String p) { + //TODO: getownproperty, etc... ECMA 8.12.2 + return o.getAttribute(p); + } + + public static Object object_defaultValue(ObjectType o, String hint) { + switch (hint) { + case "String": + //TODO: logic similar to 8.12.8 + return o.call("toString", new ArrayList<>()); + case "Number": + default: + //TODO: logic similar to 8.12.8 + return o.call("valueOf", new ArrayList<>()); + } + } public static Double toNumberAs2(Object o) { @@ -408,4 +463,189 @@ public class EcmaScript { return o.toString(); } + + public static Double parseFloat(Object string) { + String inputString = toString(string); + int startPos = 0; + String trimmedString = ""; + for (; startPos < inputString.length(); startPos++) { + char c = inputString.charAt(startPos); + if (!Character.isWhitespace(c)) { + trimmedString = inputString.substring(startPos); + break; + } + } + try { + return Double.parseDouble(trimmedString); //Is this the same? + } catch (NumberFormatException nfe) { + return Double.NaN; + } + + } + + public static Boolean isNaN(Object number) { + return Double.isNaN(toNumber(number)); + } + + public static Boolean isFinite(Object number) { + return Double.isFinite(toNumber(number)); + } + + public static Object parseInt(Object string, Object radix) { + String inputString = toString(string); + int startPos = 0; + String s = ""; + for (; startPos < inputString.length(); startPos++) { + char c = inputString.charAt(startPos); + if (!Character.isWhitespace(c)) { + s = inputString.substring(startPos); + break; + } + } + int sign = 1; + if (!s.isEmpty() && s.charAt(0) == '-') { + sign = -1; + } + if (!s.isEmpty() && (s.charAt(0) == '+' || s.charAt(0) == '-')) { + s = s.substring(1); + } + int r = toInt32(radix); + boolean stripPrefix = true; + if (r != 0) { + if (r < 2 || r > 36) { + return Double.NaN; + } + if (r != 16) { + stripPrefix = false; + } + } else { + r = 10; + } + if (stripPrefix) { + if (s.length() >= 2) { + if (s.substring(0, 2).toLowerCase().equals("0x")) { + s = s.substring(2); + r = 16; + } + } + } + + String allDigits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + String allowedDigits = allDigits.substring(0, r); + String z = s; + for (int i = 0; i < s.length(); i++) { + if (("" + s.charAt(i)).matches("[" + allowedDigits + "]")) { + if (i == 0) { + z = ""; + break; + } + z = s.substring(0, i); + break; + } + } + if (z.isEmpty()) { + return Double.NaN; + } + Long number = Long.parseLong(z, r); + return sign * number; + } + + private static char toHex(int ch) { + return (char) (ch < 10 ? '0' + ch : 'A' + ch - 10); + } + + private static String simpleCustomEncode(String input, String additionalValidChars) { + String alphas = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + String num = "0123456789"; + String alphaCases = alphas + alphas.toLowerCase(); + String alphanum = alphaCases + num; + return customEncode(input, alphanum + additionalValidChars); + } + + private static String simpleCustomDecode(String input, String additionalValidChars) { + String alphas = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + String num = "0123456789"; + String alphaCases = alphas + alphas.toLowerCase(); + String alphanum = alphaCases + num; + return customDecode(input, alphanum + additionalValidChars); + } + + private static String customEncode(String input, String validChars) { + StringBuilder resultStr = new StringBuilder(); + for (char ch : input.toCharArray()) { + if (!validChars.contains("" + ch)) { + resultStr.append('%'); + resultStr.append(toHex(ch / 16)); + resultStr.append(toHex(ch % 16)); + } else { + resultStr.append(ch); + } + } + return resultStr.toString(); + } + + private static String customDecode(String input, String reservedSet) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + for (int i = 0; i < input.length(); i++) { + char ch = input.charAt(i); + String s; + if (ch == '%' && i + 2 < input.length()) { + try { + int k = i; + int b = Integer.parseInt(input.substring(k + 1, k + 2 + 1), 16); + int msb = (b >> 15) & 1; + if (msb == 0) { + char c = (char) b; + if (!reservedSet.contains("" + c)) { + baos.write(c); + } else { + baos.write(Utf8Helper.getBytes(input.substring(k, k + 3))); + } + } else { + //here continues some multibyte character + //FIXME: is this working? + for (; msb == 1 && k < input.length() && input.charAt(k) == '%'; k += 3) { + b = Integer.parseInt(input.substring(k + 1, k + 2 + 1), 16); + msb = (b >> 15) & 1; + baos.write(b); + } + //throw error is msb=1 + } + } catch (NumberFormatException nfe) { + //throw URIEx + } catch (IOException ex) { + + } + } + } + try { + return baos.toString("UTF-8"); + } catch (UnsupportedEncodingException ex) { + return null; + } + } + + public static String encodeUriComponent(Object s) { + return simpleCustomEncode(toString(s), "-_.!~*'()"); + } + + public static String encodeUri(Object s) { + return simpleCustomEncode(toString(s), ";/?:@&=+$,#-_.!~*'()"); + } + + public static String escape(Object s) { + return simpleCustomEncode(toString(s), "@-_.*+/"); + } + + public static String decodeUriComponent(Object s) { + return simpleCustomDecode(toString(s), "-_.!~*'()"); + } + + public static String decodeUri(Object s) { + return simpleCustomDecode(toString(s), ";/?:@&=+$,#-_.!~*'()"); + } + + public static String unescape(Object s) { + return simpleCustomDecode(toString(s), "@-_.*+/"); + } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ObjectType.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ObjectType.java new file mode 100644 index 000000000..6b8e53bb2 --- /dev/null +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/flash/ecma/ObjectType.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2010-2016 JPEXS, All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. + */ +package com.jpexs.decompiler.flash.ecma; + +import com.jpexs.decompiler.flash.abc.avm2.model.Callable; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * + * @author JPEXS + */ +public class ObjectType implements Callable { + + public static final ObjectType EMPTY_OBJECT = new ObjectType(); + + protected Map attributes; + + public void setAttribute(String name, Object value) { + attributes.put(name, value); + } + + public Set getAttributeNames() { + return attributes.keySet(); + } + + protected ObjectType() { + this.attributes = new HashMap<>(); + } + + public ObjectType(Map attributes) { + this.attributes = attributes; + } + + public Object getAttribute(String name) { + if (attributes.containsKey(name)) { + return attributes.get(name); + } + return Undefined.INSTANCE; + } + + @Override + public String toString() { + return "[object Object]"; + } + + @Override + public Object call(String methodName, List args) { + switch (methodName) { + case "toString": + return toString(); + case "valueOf": + return valueOf(); + default: + return Undefined.INSTANCE; //? + } + } + + public Object valueOf() { + return EcmaScript.toNumber(toString()); + } + + @Override + public Object call(List args) { + return Undefined.INSTANCE; //? + } + +} diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/GraphTargetItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/GraphTargetItem.java index 245c48193..eb867d9f6 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/GraphTargetItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/GraphTargetItem.java @@ -17,15 +17,30 @@ package com.jpexs.decompiler.graph; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; +import com.jpexs.decompiler.flash.abc.avm2.model.FloatValueAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.IntegerValueAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.NameValuePair; +import com.jpexs.decompiler.flash.abc.avm2.model.NewArrayAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.NewObjectAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.NullAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.StringAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.ThisAVM2Item; +import com.jpexs.decompiler.flash.abc.avm2.model.UndefinedAVM2Item; import com.jpexs.decompiler.flash.action.model.DirectValueActionItem; import com.jpexs.decompiler.flash.configuration.Configuration; +import com.jpexs.decompiler.flash.ecma.ArrayType; import com.jpexs.decompiler.flash.ecma.EcmaScript; +import com.jpexs.decompiler.flash.ecma.Null; +import com.jpexs.decompiler.flash.ecma.ObjectType; +import com.jpexs.decompiler.flash.ecma.Undefined; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.flash.helpers.HighlightedTextWriter; import com.jpexs.decompiler.flash.helpers.hilight.HighlightData; import com.jpexs.decompiler.graph.model.BinaryOp; +import com.jpexs.decompiler.graph.model.FalseItem; import com.jpexs.decompiler.graph.model.LocalData; import com.jpexs.decompiler.graph.model.NotItem; +import com.jpexs.decompiler.graph.model.TrueItem; import java.io.Serializable; import java.util.ArrayList; import java.util.HashSet; @@ -90,6 +105,92 @@ public abstract class GraphTargetItem implements Serializable, Cloneable { return lineStartItem; } + protected static GraphTargetItem valToItem(Object r) { + if (r == null) { + return null; + } + if (r instanceof Boolean) { + if ((Boolean) r) { + return new TrueItem(null, null); + } else { + return new FalseItem(null, null); + } + } + if (r instanceof String) { + return new StringAVM2Item(null, null, (String) r); + } + if (r instanceof Long) { + return new IntegerValueAVM2Item(null, null, (Long) r); + } + if (r instanceof Integer) { + return new IntegerValueAVM2Item(null, null, (long) (int) (Integer) r); + } + + if (r instanceof Double) { + return new FloatValueAVM2Item(null, null, (Double) r); + } + if (r instanceof Null) { + return new NullAVM2Item(null, null); + } + if (r instanceof Undefined) { + return new UndefinedAVM2Item(null, null); + } + if (r instanceof ArrayType) { + List vals = new ArrayList<>(); + ArrayType at = (ArrayType) r; + for (Object v : at.values) { + vals.add(valToItem(v)); + } + return new NewArrayAVM2Item(null, null, vals); + } + if (r instanceof ObjectType) { + List props = new ArrayList<>(); + ObjectType ot = (ObjectType) r; + for (String k : ot.getAttributeNames()) { + props.add(new NameValuePair(valToItem(k), valToItem(ot.getAttribute(k)))); + } + return new NewObjectAVM2Item(null, null, props); + } + return null; + } + + public static GraphTargetItem simplifySomething(GraphTargetItem it, String implicitCoerce) { + if ((it instanceof SimpleValue) && implicitCoerce.isEmpty()) { + if (((SimpleValue) it).isSimpleValue()) { + return it; + } + } + + if (!it.isCompileTime() && !(!implicitCoerce.isEmpty() && it.isConvertedCompileTime(new HashSet<>()))) { + return it; + } + Object r = it.getResult(); + switch (implicitCoerce) { + case "String": + r = EcmaScript.toString(r); + break; + case "Number": + r = EcmaScript.toNumber(r); + break; + case "int": + r = EcmaScript.toInt32(r); + break; + case "Boolean": + r = EcmaScript.toBoolean(r); + break; + } + + GraphTargetItem it2 = valToItem(r); + if (it2 == null) { + return it; + } + return it2; + } + + public GraphTargetItem simplify(String implicitCoerce) { + return simplifySomething(this, implicitCoerce); + } + public int getLine() { if (src != null) { return src.getLine(); @@ -174,7 +275,7 @@ public abstract class GraphTargetItem implements Serializable, Cloneable { } writer.startOffset(src, getLineStartItem(), getPos(), srcData); - appendTo(writer, localData); + appendTry(writer, localData); if (needsSemicolon()) { writer.appendNoHilight(";"); } @@ -191,19 +292,52 @@ public abstract class GraphTargetItem implements Serializable, Cloneable { return getClass().getName(); } - public GraphTextWriter toString(GraphTextWriter writer, LocalData localData) throws InterruptedException { + public GraphTextWriter toStringBoolean(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return toString(writer, localData, "Boolean"); + } + + public GraphTextWriter toStringString(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return toString(writer, localData, "String"); + } + + public GraphTextWriter toStringInt(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return toString(writer, localData, "int"); + } + + public GraphTextWriter toStringNumber(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return toString(writer, localData, "Number"); + } + + public GraphTextWriter toString(GraphTextWriter writer, LocalData localData, String implicitCoerce) throws InterruptedException { if (Thread.currentThread().isInterrupted()) { throw new InterruptedException(); } writer.startOffset(src, getLineStartItem(), getPos(), srcData); - appendTo(writer, localData); + appendTry(writer, localData, implicitCoerce); writer.endOffset(); return writer; } + public GraphTextWriter toString(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return toString(writer, localData, ""); + } + public abstract GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException; + public GraphTextWriter appendTry(GraphTextWriter writer, LocalData localData) throws InterruptedException { + return appendTry(writer, localData, ""); + } + + public GraphTextWriter appendTry(GraphTextWriter writer, LocalData localData, String implicitCoerce) throws InterruptedException { + GraphTargetItem t = this; + if (!implicitCoerce.isEmpty() && Configuration.autoDeobfuscate.get()) { + t = t.simplify(implicitCoerce); + } + return t.appendTo(writer, localData); + + } + public String toString(LocalData localData) throws InterruptedException { HighlightedTextWriter writer = new HighlightedTextWriter(Configuration.getCodeFormatting(), false); toString(writer, localData); @@ -224,6 +358,10 @@ public abstract class GraphTargetItem implements Serializable, Cloneable { return false; } + public boolean isConvertedCompileTime(Set dependencies) { + return isCompileTime(); + } + public boolean hasSideEffect() { return false; } @@ -274,7 +412,7 @@ public abstract class GraphTargetItem implements Serializable, Cloneable { public GraphTextWriter toStringNL(GraphTextWriter writer, LocalData localData) throws InterruptedException { writer.startOffset(src, getLineStartItem(), getPos(), srcData); - appendTo(writer, localData); + appendTry(writer, localData); if (needsNewLine()) { writer.newLine(); } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/TranslateStack.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/TranslateStack.java index 0571a5cea..6607342ff 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/TranslateStack.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/TranslateStack.java @@ -31,6 +31,12 @@ public class TranslateStack extends Stack { private final String path; + public void simplify() { + for (int i = 0; i < size(); i++) { + set(i, get(i).simplify("")); + } + } + public TranslateStack(String path) { this.path = path; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/AndItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/AndItem.java index 6012bd6e7..c291bf1fa 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/AndItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/AndItem.java @@ -40,7 +40,7 @@ public class AndItem extends BinaryOpItem { } public AndItem(GraphSourceItem src, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(src, lineStartIns, PRECEDENCE_LOGICALAND, leftSide, rightSide, "&&"); + super(src, lineStartIns, PRECEDENCE_LOGICALAND, leftSide, rightSide, "&&", "Boolean", "Boolean"); this.leftSide = leftSide; this.rightSide = rightSide; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/BinaryOpItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/BinaryOpItem.java index 40e0adce6..c28e1573c 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/BinaryOpItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/BinaryOpItem.java @@ -38,6 +38,9 @@ public abstract class BinaryOpItem extends GraphTargetItem implements BinaryOp { protected final String operator; + protected String coerceLeft; + protected String coerceRight; + @Override public GraphPart getFirstPart() { GraphPart fp = leftSide.getFirstPart(); @@ -47,11 +50,21 @@ public abstract class BinaryOpItem extends GraphTargetItem implements BinaryOp { return fp; } - public BinaryOpItem(GraphSourceItem instruction, GraphSourceItem lineStartItem, int precedence, GraphTargetItem leftSide, GraphTargetItem rightSide, String operator) { + public BinaryOpItem(GraphSourceItem instruction, GraphSourceItem lineStartItem, int precedence, GraphTargetItem leftSide, GraphTargetItem rightSide, String operator, String coerceLeft, String coerceRight) { super(instruction, lineStartItem, precedence); this.leftSide = leftSide; this.rightSide = rightSide; this.operator = operator; + this.coerceLeft = coerceLeft; + this.coerceRight = coerceRight; + } + + @Override + public GraphTargetItem simplify(String implicitCoerce) { + BinaryOpItem r = (BinaryOpItem) clone(); + r.leftSide = r.leftSide.simplify(coerceLeft); + r.rightSide = r.rightSide.simplify(coerceRight); + return simplifySomething(r, implicitCoerce); } @Override @@ -98,7 +111,7 @@ public abstract class BinaryOpItem extends GraphTargetItem implements BinaryOp { return false; } dependencies.add(rightSide); - return leftSide.isCompileTime(dependencies) && rightSide.isCompileTime(dependencies); + return leftSide.isConvertedCompileTime(dependencies) && rightSide.isConvertedCompileTime(dependencies); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DoWhileItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DoWhileItem.java index 1e7ba4416..6c2c73097 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DoWhileItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DoWhileItem.java @@ -86,7 +86,12 @@ public class DoWhileItem extends LoopItem implements Block { if (i != 0) { writer.append(", "); } - expression.get(i).toString(writer, localData); + if (i == expression.size() - 1) { + expression.get(i).toStringBoolean(writer, localData); + } else { + expression.get(i).toString(writer, localData); + } + } writer.append(");").newLine(); diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DuplicateItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DuplicateItem.java index fbb1b5d84..746016024 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DuplicateItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/DuplicateItem.java @@ -51,10 +51,10 @@ public class DuplicateItem extends GraphTargetItem implements SimpleValue { @Override public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { if (((value instanceof SimpleValue) && (((SimpleValue) value).isSimpleValue())) || !Configuration.displayDupInstructions.get()) { - return value.appendTo(writer, localData); + return value.appendTry(writer, localData); } writer.append("§§dup("); - value.appendTo(writer, localData); + value.appendTry(writer, localData); return writer.append(")"); } @@ -102,9 +102,14 @@ public class DuplicateItem extends GraphTargetItem implements SimpleValue { return true; } + @Override + public GraphTargetItem simplify(String implicitCoerce) { + return this; + } + @Override public GraphTargetItem returnType() { - return TypeItem.UNBOUNDED; + return value.returnType(); } /*@Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/ForItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/ForItem.java index 800b4ec0e..0fd6220e8 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/ForItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/ForItem.java @@ -95,7 +95,7 @@ public class ForItem extends LoopItem implements Block { p++; } writer.append("; "); - expression.toString(writer, localData); + expression.toStringBoolean(writer, localData); writer.append("; "); p = 0; for (int i = 0; i < finalCommands.size(); i++) { diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/IfItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/IfItem.java index 6f6b50d8c..910b17b27 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/IfItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/IfItem.java @@ -89,7 +89,7 @@ public class IfItem extends GraphTargetItem implements Block { writer.append(" "); } writer.append("("); - expr.toString(writer, localData); + expr.toStringBoolean(writer, localData); writer.append(")"); appendBlock(expr, writer, localData, ifBranch); if (elseBranch.size() > 0) { diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/NotItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/NotItem.java index e9cc1245e..afe55a55f 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/NotItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/NotItem.java @@ -19,6 +19,7 @@ package com.jpexs.decompiler.graph.model; import com.jpexs.decompiler.flash.SourceGeneratorLocalData; import com.jpexs.decompiler.flash.action.model.operations.Inverted; import com.jpexs.decompiler.flash.ecma.EcmaScript; +import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.CompilationException; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphTargetItem; @@ -34,7 +35,7 @@ import java.util.Set; public class NotItem extends UnaryOpItem implements LogicalOpItem, Inverted { public NotItem(GraphSourceItem instruction, GraphSourceItem lineStartIns, GraphTargetItem value) { - super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "!"); + super(instruction, lineStartIns, PRECEDENCE_UNARY, value, "!", "Boolean"); } @Override @@ -79,8 +80,30 @@ public class NotItem extends UnaryOpItem implements LogicalOpItem, Inverted { return TypeItem.BOOLEAN; } + @Override + public GraphTextWriter toStringBoolean(GraphTextWriter writer, LocalData localData) throws InterruptedException { + //Skip explicit conversion to boolean, it is not needed, it is done implicitly + if (value instanceof NotItem) { + return value.value.toStringBoolean(writer, localData); + } + return super.toStringBoolean(writer, localData); + } + @Override public GraphTargetItem invert(GraphSourceItem src) { + if (true) { + return value; + } + //if this is already !!val, convert to !val + if (value instanceof NotItem) { + return value; + } + //If it is not a boolean, put !! there for toBoolean conversion + if (!TypeItem.BOOLEAN.equals(value.returnType()) && !(value instanceof DuplicateItem)) { + return new NotItem(null, null, this); + } + + //can be inverted return value; } } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/OrItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/OrItem.java index b35d2920b..ac05c46c3 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/OrItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/OrItem.java @@ -32,7 +32,7 @@ import java.util.List; public class OrItem extends BinaryOpItem { public OrItem(GraphSourceItem src, GraphSourceItem lineStartIns, GraphTargetItem leftSide, GraphTargetItem rightSide) { - super(src, lineStartIns, PRECEDENCE_LOGICALOR, leftSide, rightSide, "||"); + super(src, lineStartIns, PRECEDENCE_LOGICALOR, leftSide, rightSide, "||", "Boolean", "Boolean"); this.leftSide = leftSide; this.rightSide = rightSide; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/PushItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/PushItem.java index bf18ea8e4..f78c62e15 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/PushItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/PushItem.java @@ -39,7 +39,7 @@ public class PushItem extends GraphTargetItem { public GraphTextWriter appendTo(GraphTextWriter writer, LocalData localData) throws InterruptedException { //Logger.getLogger(PushItem.class.getName()).log(Level.WARNING, "Push item left in the source code"); writer.append("§§push("); - value.appendTo(writer, localData); + value.appendTry(writer, localData); writer.append(")"); return writer; } diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/UnaryOpItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/UnaryOpItem.java index 1d74c5f56..7dfb51907 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/UnaryOpItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/UnaryOpItem.java @@ -16,6 +16,7 @@ */ package com.jpexs.decompiler.graph.model; +import com.jpexs.decompiler.flash.abc.avm2.model.ThisAVM2Item; import com.jpexs.decompiler.flash.helpers.GraphTextWriter; import com.jpexs.decompiler.graph.GraphSourceItem; import com.jpexs.decompiler.graph.GraphSourceItemPos; @@ -30,10 +31,19 @@ import java.util.Set; public abstract class UnaryOpItem extends GraphTargetItem implements UnaryOp { public String operator; + protected String coerce; - public UnaryOpItem(GraphSourceItem instruction, GraphSourceItem lineStartItem, int precedence, GraphTargetItem value, String operator) { + public UnaryOpItem(GraphSourceItem instruction, GraphSourceItem lineStartItem, int precedence, GraphTargetItem value, String operator, String coerce) { super(instruction, lineStartItem, precedence, value); this.operator = operator; + this.coerce = coerce; + } + + @Override + public GraphTargetItem simplify(String implicitCoerce) { + GraphTargetItem r = clone(); + r.value = r.value.simplify(coerce); + return simplifySomething(r, implicitCoerce); } @Override @@ -59,7 +69,7 @@ public abstract class UnaryOpItem extends GraphTargetItem implements UnaryOp { return false; } dependencies.add(value); - return value.isCompileTime(dependencies); + return value.isConvertedCompileTime(dependencies); } @Override diff --git a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/WhileItem.java b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/WhileItem.java index e34c1eaf0..b5783ece7 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/WhileItem.java +++ b/libsrc/ffdec_lib/src/com/jpexs/decompiler/graph/model/WhileItem.java @@ -77,7 +77,12 @@ public class WhileItem extends LoopItem implements Block { if (i != 0) { writer.append(", "); } - expression.get(i).toString(writer, localData); + if (i == expression.size() - 1) { + expression.get(i).toStringBoolean(writer, localData); + } else { + expression.get(i).toString(writer, localData); + } + } writer.append(")"); appendBlock(expression.get(expression.size() - 1), writer, localData, commands); diff --git a/libsrc/ffdec_lib/src/com/jpexs/helpers/utf8/Utf8Helper.java b/libsrc/ffdec_lib/src/com/jpexs/helpers/utf8/Utf8Helper.java index ce46e2251..063d61459 100644 --- a/libsrc/ffdec_lib/src/com/jpexs/helpers/utf8/Utf8Helper.java +++ b/libsrc/ffdec_lib/src/com/jpexs/helpers/utf8/Utf8Helper.java @@ -18,6 +18,7 @@ package com.jpexs.helpers.utf8; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; +import java.net.URLEncoder; import java.nio.charset.Charset; /** @@ -36,6 +37,14 @@ public class Utf8Helper { } } + public static String urlEncode(String s) { + try { + return URLEncoder.encode(s, "UTF-8"); + } catch (UnsupportedEncodingException ex) { + throw new Error(ex); + } + } + public static byte[] getBytes(String string) { return string.getBytes(charset); }