moparisthebest/fernflower
1
0
Fork 0
mirror of https://github.com/moparisthebest/fernflower synced 2024-11-23 09:42:18 -05:00
Code Issues Releases Wiki Activity

java-decompiler: post-import cleanup (code style issues)

Browse Source
This commit is contained in:
Roman Shevchenko 2014-08-29 14:31:45 +04:00
parent 076e4393f2
commit 84ea54eb1e
72 changed files with 567 additions and 600 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

584
src/org/jetbrains/java/decompiler/code/CodeConstants.java
View File

@ -21,350 +21,350 @@ public interface CodeConstants {
// BYTECODE VERSIONS // BYTECODE VERSIONS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int BYTECODE_JAVA_LE_4 = 1; int BYTECODE_JAVA_LE_4 = 1;
public final static int BYTECODE_JAVA_5 = 2; int BYTECODE_JAVA_5 = 2;
public final static int BYTECODE_JAVA_6 = 3; int BYTECODE_JAVA_6 = 3;
public final static int BYTECODE_JAVA_7 = 4; int BYTECODE_JAVA_7 = 4;
public final static int BYTECODE_JAVA_8 = 5; int BYTECODE_JAVA_8 = 5;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// VARIABLE TYPES // VARIABLE TYPES
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int TYPE_BYTE = 0; int TYPE_BYTE = 0;
public final static int TYPE_CHAR = 1; int TYPE_CHAR = 1;
public final static int TYPE_DOUBLE = 2; int TYPE_DOUBLE = 2;
public final static int TYPE_FLOAT = 3; int TYPE_FLOAT = 3;
public final static int TYPE_INT = 4; int TYPE_INT = 4;
public final static int TYPE_LONG = 5; int TYPE_LONG = 5;
public final static int TYPE_SHORT = 6; int TYPE_SHORT = 6;
public final static int TYPE_BOOLEAN = 7; int TYPE_BOOLEAN = 7;
public final static int TYPE_OBJECT = 8; int TYPE_OBJECT = 8;
public final static int TYPE_ADDRESS = 9; int TYPE_ADDRESS = 9;
public final static int TYPE_VOID = 10; int TYPE_VOID = 10;
public final static int TYPE_ANY = 11; int TYPE_ANY = 11;
public final static int TYPE_GROUP2EMPTY = 12; int TYPE_GROUP2EMPTY = 12;
public final static int TYPE_NULL = 13; int TYPE_NULL = 13;
public final static int TYPE_NOTINITIALIZED = 14; int TYPE_NOTINITIALIZED = 14;
public final static int TYPE_BYTECHAR = 15; int TYPE_BYTECHAR = 15;
public final static int TYPE_SHORTCHAR = 16; int TYPE_SHORTCHAR = 16;
public final static int TYPE_UNKNOWN = 17; int TYPE_UNKNOWN = 17;
public final static int TYPE_GENVAR = 18; int TYPE_GENVAR = 18;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// VARIABLE TYPE FAMILIES // VARIABLE TYPE FAMILIES
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int TYPE_FAMILY_UNKNOWN = 0; int TYPE_FAMILY_UNKNOWN = 0;
public final static int TYPE_FAMILY_BOOLEAN = 1; int TYPE_FAMILY_BOOLEAN = 1;
public final static int TYPE_FAMILY_INTEGER = 2; int TYPE_FAMILY_INTEGER = 2;
public final static int TYPE_FAMILY_FLOAT = 3; int TYPE_FAMILY_FLOAT = 3;
public final static int TYPE_FAMILY_LONG = 4; int TYPE_FAMILY_LONG = 4;
public final static int TYPE_FAMILY_DOUBLE = 5; int TYPE_FAMILY_DOUBLE = 5;
public final static int TYPE_FAMILY_OBJECT = 6; int TYPE_FAMILY_OBJECT = 6;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// MODULE CONSTANTS // MODULE CONSTANTS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int STACKSIZE_SIMPLE = 1; int STACKSIZE_SIMPLE = 1;
public final static int STACKSIZE_DOUBLE = 2; int STACKSIZE_DOUBLE = 2;
public final static int VAR_LOCAL = 0; int VAR_LOCAL = 0;
public final static int VAR_STACK = 1; int VAR_STACK = 1;
public final static int VAR_WRITE = 0; int VAR_WRITE = 0;
public final static int VAR_READ = 1; int VAR_READ = 1;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// ACCESS FLAGS // ACCESS FLAGS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int ACC_PUBLIC = 0x0001; int ACC_PUBLIC = 0x0001;
public final static int ACC_PRIVATE = 0x0002; int ACC_PRIVATE = 0x0002;
public final static int ACC_PROTECTED = 0x0004; int ACC_PROTECTED = 0x0004;
public final static int ACC_STATIC = 0x0008; int ACC_STATIC = 0x0008;
public final static int ACC_FINAL = 0x0010; int ACC_FINAL = 0x0010;
public final static int ACC_SYNCHRONIZED = 0x0020; int ACC_SYNCHRONIZED = 0x0020;
public final static int ACC_NATIVE = 0x0100; int ACC_NATIVE = 0x0100;
public final static int ACC_ABSTRACT = 0x0400; int ACC_ABSTRACT = 0x0400;
public final static int ACC_STRICT = 0x0800; int ACC_STRICT = 0x0800;
public final static int ACC_VOLATILE = 0x0040; int ACC_VOLATILE = 0x0040;
public final static int ACC_BRIDGE = 0x0040; int ACC_BRIDGE = 0x0040;
public final static int ACC_TRANSIENT = 0x0080; int ACC_TRANSIENT = 0x0080;
public final static int ACC_VARARGS = 0x0080; int ACC_VARARGS = 0x0080;
public final static int ACC_SYNTHETIC = 0x1000; int ACC_SYNTHETIC = 0x1000;
public final static int ACC_ANNOTATION = 0x2000; int ACC_ANNOTATION = 0x2000;
public final static int ACC_ENUM = 0x4000; int ACC_ENUM = 0x4000;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// CLASS FLAGS // CLASS FLAGS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int ACC_SUPER = 0x0020; int ACC_SUPER = 0x0020;
public final static int ACC_INTERFACE = 0x0200; int ACC_INTERFACE = 0x0200;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// DEPENDENCY CONSTANTS // DEPENDENCY CONSTANTS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int DEP_CONSTANT = 0; int DEP_CONSTANT = 0;
public final static int DEP_UNKNOWN = 1; int DEP_UNKNOWN = 1;
public final static int DEP_GENERAL = 2; int DEP_GENERAL = 2;
public final static int DEP_PARAMS = 4; int DEP_PARAMS = 4;
public final static int DEP_STATIC = 8; int DEP_STATIC = 8;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// INSTRUCTION GROUPS // INSTRUCTION GROUPS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int GROUP_GENERAL = 1; int GROUP_GENERAL = 1;
public final static int GROUP_JUMP = 2; int GROUP_JUMP = 2;
public final static int GROUP_SWITCH = 3; int GROUP_SWITCH = 3;
public final static int GROUP_INVOCATION = 4; int GROUP_INVOCATION = 4;
public final static int GROUP_FIELDACCESS = 5; int GROUP_FIELDACCESS = 5;
public final static int GROUP_RETURN = 6; int GROUP_RETURN = 6;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// POOL CONSTANTS // POOL CONSTANTS
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int CONSTANT_Utf8 = 1; int CONSTANT_Utf8 = 1;
public final static int CONSTANT_Integer = 3; int CONSTANT_Integer = 3;
public final static int CONSTANT_Float = 4; int CONSTANT_Float = 4;
public final static int CONSTANT_Long = 5; int CONSTANT_Long = 5;
public final static int CONSTANT_Double = 6; int CONSTANT_Double = 6;
public final static int CONSTANT_Class = 7; int CONSTANT_Class = 7;
public final static int CONSTANT_String = 8; int CONSTANT_String = 8;
public final static int CONSTANT_Fieldref = 9; int CONSTANT_Fieldref = 9;
public final static int CONSTANT_Methodref = 10; int CONSTANT_Methodref = 10;
public final static int CONSTANT_InterfaceMethodref = 11; int CONSTANT_InterfaceMethodref = 11;
public final static int CONSTANT_NameAndType = 12; int CONSTANT_NameAndType = 12;
public final static int CONSTANT_MethodHandle = 15; int CONSTANT_MethodHandle = 15;
public final static int CONSTANT_MethodType = 16; int CONSTANT_MethodType = 16;
public final static int CONSTANT_InvokeDynamic = 18; int CONSTANT_InvokeDynamic = 18;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// MethodHandle reference_kind values // MethodHandle reference_kind values
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int CONSTANT_MethodHandle_REF_getField = 1; int CONSTANT_MethodHandle_REF_getField = 1;
public final static int CONSTANT_MethodHandle_REF_getStatic = 2; int CONSTANT_MethodHandle_REF_getStatic = 2;
public final static int CONSTANT_MethodHandle_REF_putField = 3; int CONSTANT_MethodHandle_REF_putField = 3;
public final static int CONSTANT_MethodHandle_REF_putStatic = 4; int CONSTANT_MethodHandle_REF_putStatic = 4;
public final static int CONSTANT_MethodHandle_REF_invokeVirtual = 5; int CONSTANT_MethodHandle_REF_invokeVirtual = 5;
public final static int CONSTANT_MethodHandle_REF_invokeStatic = 6; int CONSTANT_MethodHandle_REF_invokeStatic = 6;
public final static int CONSTANT_MethodHandle_REF_invokeSpecial = 7; int CONSTANT_MethodHandle_REF_invokeSpecial = 7;
public final static int CONSTANT_MethodHandle_REF_newInvokeSpecial = 8; int CONSTANT_MethodHandle_REF_newInvokeSpecial = 8;
public final static int CONSTANT_MethodHandle_REF_invokeInterface = 9; int CONSTANT_MethodHandle_REF_invokeInterface = 9;
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
// VM OPCODES // VM OPCODES
// ---------------------------------------------------------------------- // ----------------------------------------------------------------------
public final static int opc_nop = 0; int opc_nop = 0;
public final static int opc_aconst_null = 1; int opc_aconst_null = 1;
public final static int opc_iconst_m1 = 2; int opc_iconst_m1 = 2;
public final static int opc_iconst_0 = 3; int opc_iconst_0 = 3;
public final static int opc_iconst_1 = 4; int opc_iconst_1 = 4;
public final static int opc_iconst_2 = 5; int opc_iconst_2 = 5;
public final static int opc_iconst_3 = 6; int opc_iconst_3 = 6;
public final static int opc_iconst_4 = 7; int opc_iconst_4 = 7;
public final static int opc_iconst_5 = 8; int opc_iconst_5 = 8;
public final static int opc_lconst_0 = 9; int opc_lconst_0 = 9;
public final static int opc_lconst_1 = 10; int opc_lconst_1 = 10;
public final static int opc_fconst_0 = 11; int opc_fconst_0 = 11;
public final static int opc_fconst_1 = 12; int opc_fconst_1 = 12;
public final static int opc_fconst_2 = 13; int opc_fconst_2 = 13;
public final static int opc_dconst_0 = 14; int opc_dconst_0 = 14;
public final static int opc_dconst_1 = 15; int opc_dconst_1 = 15;
public final static int opc_bipush = 16; int opc_bipush = 16;
public final static int opc_sipush = 17; int opc_sipush = 17;
public final static int opc_ldc = 18; int opc_ldc = 18;
public final static int opc_ldc_w = 19; int opc_ldc_w = 19;
public final static int opc_ldc2_w = 20; int opc_ldc2_w = 20;
public final static int opc_iload = 21; int opc_iload = 21;
public final static int opc_lload = 22; int opc_lload = 22;
public final static int opc_fload = 23; int opc_fload = 23;
public final static int opc_dload = 24; int opc_dload = 24;
public final static int opc_aload = 25; int opc_aload = 25;
public final static int opc_iload_0 = 26; int opc_iload_0 = 26;
public final static int opc_iload_1 = 27; int opc_iload_1 = 27;
public final static int opc_iload_2 = 28; int opc_iload_2 = 28;
public final static int opc_iload_3 = 29; int opc_iload_3 = 29;
public final static int opc_lload_0 = 30; int opc_lload_0 = 30;
public final static int opc_lload_1 = 31; int opc_lload_1 = 31;
public final static int opc_lload_2 = 32; int opc_lload_2 = 32;
public final static int opc_lload_3 = 33; int opc_lload_3 = 33;
public final static int opc_fload_0 = 34; int opc_fload_0 = 34;
public final static int opc_fload_1 = 35; int opc_fload_1 = 35;
public final static int opc_fload_2 = 36; int opc_fload_2 = 36;
public final static int opc_fload_3 = 37; int opc_fload_3 = 37;
public final static int opc_dload_0 = 38; int opc_dload_0 = 38;
public final static int opc_dload_1 = 39; int opc_dload_1 = 39;
public final static int opc_dload_2 = 40; int opc_dload_2 = 40;
public final static int opc_dload_3 = 41; int opc_dload_3 = 41;
public final static int opc_aload_0 = 42; int opc_aload_0 = 42;
public final static int opc_aload_1 = 43; int opc_aload_1 = 43;
public final static int opc_aload_2 = 44; int opc_aload_2 = 44;
public final static int opc_aload_3 = 45; int opc_aload_3 = 45;
public final static int opc_iaload = 46; int opc_iaload = 46;
public final static int opc_laload = 47; int opc_laload = 47;
public final static int opc_faload = 48; int opc_faload = 48;
public final static int opc_daload = 49; int opc_daload = 49;
public final static int opc_aaload = 50; int opc_aaload = 50;
public final static int opc_baload = 51; int opc_baload = 51;
public final static int opc_caload = 52; int opc_caload = 52;
public final static int opc_saload = 53; int opc_saload = 53;
public final static int opc_istore = 54; int opc_istore = 54;
public final static int opc_lstore = 55; int opc_lstore = 55;
public final static int opc_fstore = 56; int opc_fstore = 56;
public final static int opc_dstore = 57; int opc_dstore = 57;
public final static int opc_astore = 58; int opc_astore = 58;
public final static int opc_istore_0 = 59; int opc_istore_0 = 59;
public final static int opc_istore_1 = 60; int opc_istore_1 = 60;
public final static int opc_istore_2 = 61; int opc_istore_2 = 61;
public final static int opc_istore_3 = 62; int opc_istore_3 = 62;
public final static int opc_lstore_0 = 63; int opc_lstore_0 = 63;
public final static int opc_lstore_1 = 64; int opc_lstore_1 = 64;
public final static int opc_lstore_2 = 65; int opc_lstore_2 = 65;
public final static int opc_lstore_3 = 66; int opc_lstore_3 = 66;
public final static int opc_fstore_0 = 67; int opc_fstore_0 = 67;
public final static int opc_fstore_1 = 68; int opc_fstore_1 = 68;
public final static int opc_fstore_2 = 69; int opc_fstore_2 = 69;
public final static int opc_fstore_3 = 70; int opc_fstore_3 = 70;
public final static int opc_dstore_0 = 71; int opc_dstore_0 = 71;
public final static int opc_dstore_1 = 72; int opc_dstore_1 = 72;
public final static int opc_dstore_2 = 73; int opc_dstore_2 = 73;
public final static int opc_dstore_3 = 74; int opc_dstore_3 = 74;
public final static int opc_astore_0 = 75; int opc_astore_0 = 75;
public final static int opc_astore_1 = 76; int opc_astore_1 = 76;
public final static int opc_astore_2 = 77; int opc_astore_2 = 77;
public final static int opc_astore_3 = 78; int opc_astore_3 = 78;
public final static int opc_iastore = 79; int opc_iastore = 79;
public final static int opc_lastore = 80; int opc_lastore = 80;
public final static int opc_fastore = 81; int opc_fastore = 81;
public final static int opc_dastore = 82; int opc_dastore = 82;
public final static int opc_aastore = 83; int opc_aastore = 83;
public final static int opc_bastore = 84; int opc_bastore = 84;
public final static int opc_castore = 85; int opc_castore = 85;
public final static int opc_sastore = 86; int opc_sastore = 86;
public final static int opc_pop = 87; int opc_pop = 87;
public final static int opc_pop2 = 88; int opc_pop2 = 88;
public final static int opc_dup = 89; int opc_dup = 89;
public final static int opc_dup_x1 = 90; int opc_dup_x1 = 90;
public final static int opc_dup_x2 = 91; int opc_dup_x2 = 91;
public final static int opc_dup2 = 92; int opc_dup2 = 92;
public final static int opc_dup2_x1 = 93; int opc_dup2_x1 = 93;
public final static int opc_dup2_x2 = 94; int opc_dup2_x2 = 94;
public final static int opc_swap = 95; int opc_swap = 95;
public final static int opc_iadd = 96; int opc_iadd = 96;
public final static int opc_ladd = 97; int opc_ladd = 97;
public final static int opc_fadd = 98; int opc_fadd = 98;
public final static int opc_dadd = 99; int opc_dadd = 99;
public final static int opc_isub = 100; int opc_isub = 100;
public final static int opc_lsub = 101; int opc_lsub = 101;
public final static int opc_fsub = 102; int opc_fsub = 102;
public final static int opc_dsub = 103; int opc_dsub = 103;
public final static int opc_imul = 104; int opc_imul = 104;
public final static int opc_lmul = 105; int opc_lmul = 105;
public final static int opc_fmul = 106; int opc_fmul = 106;
public final static int opc_dmul = 107; int opc_dmul = 107;
public final static int opc_idiv = 108; int opc_idiv = 108;
public final static int opc_ldiv = 109; int opc_ldiv = 109;
public final static int opc_fdiv = 110; int opc_fdiv = 110;
public final static int opc_ddiv = 111; int opc_ddiv = 111;
public final static int opc_irem = 112; int opc_irem = 112;
public final static int opc_lrem = 113; int opc_lrem = 113;
public final static int opc_frem = 114; int opc_frem = 114;
public final static int opc_drem = 115; int opc_drem = 115;
public final static int opc_ineg = 116; int opc_ineg = 116;
public final static int opc_lneg = 117; int opc_lneg = 117;
public final static int opc_fneg = 118; int opc_fneg = 118;
public final static int opc_dneg = 119; int opc_dneg = 119;
public final static int opc_ishl = 120; int opc_ishl = 120;
public final static int opc_lshl = 121; int opc_lshl = 121;
public final static int opc_ishr = 122; int opc_ishr = 122;
public final static int opc_lshr = 123; int opc_lshr = 123;
public final static int opc_iushr = 124; int opc_iushr = 124;
public final static int opc_lushr = 125; int opc_lushr = 125;
public final static int opc_iand = 126; int opc_iand = 126;
public final static int opc_land = 127; int opc_land = 127;
public final static int opc_ior = 128; int opc_ior = 128;
public final static int opc_lor = 129; int opc_lor = 129;
public final static int opc_ixor = 130; int opc_ixor = 130;
public final static int opc_lxor = 131; int opc_lxor = 131;
public final static int opc_iinc = 132; int opc_iinc = 132;
public final static int opc_i2l = 133; int opc_i2l = 133;
public final static int opc_i2f = 134; int opc_i2f = 134;
public final static int opc_i2d = 135; int opc_i2d = 135;
public final static int opc_l2i = 136; int opc_l2i = 136;
public final static int opc_l2f = 137; int opc_l2f = 137;
public final static int opc_l2d = 138; int opc_l2d = 138;
public final static int opc_f2i = 139; int opc_f2i = 139;
public final static int opc_f2l = 140; int opc_f2l = 140;
public final static int opc_f2d = 141; int opc_f2d = 141;
public final static int opc_d2i = 142; int opc_d2i = 142;
public final static int opc_d2l = 143; int opc_d2l = 143;
public final static int opc_d2f = 144; int opc_d2f = 144;
public final static int opc_i2b = 145; int opc_i2b = 145;
public final static int opc_i2c = 146; int opc_i2c = 146;
public final static int opc_i2s = 147; int opc_i2s = 147;
public final static int opc_lcmp = 148; int opc_lcmp = 148;
public final static int opc_fcmpl = 149; int opc_fcmpl = 149;
public final static int opc_fcmpg = 150; int opc_fcmpg = 150;
public final static int opc_dcmpl = 151; int opc_dcmpl = 151;
public final static int opc_dcmpg = 152; int opc_dcmpg = 152;
public final static int opc_ifeq = 153; int opc_ifeq = 153;
public final static int opc_ifne = 154; int opc_ifne = 154;
public final static int opc_iflt = 155; int opc_iflt = 155;
public final static int opc_ifge = 156; int opc_ifge = 156;
public final static int opc_ifgt = 157; int opc_ifgt = 157;
public final static int opc_ifle = 158; int opc_ifle = 158;
public final static int opc_if_icmpeq = 159; int opc_if_icmpeq = 159;
public final static int opc_if_icmpne = 160; int opc_if_icmpne = 160;
public final static int opc_if_icmplt = 161; int opc_if_icmplt = 161;
public final static int opc_if_icmpge = 162; int opc_if_icmpge = 162;
public final static int opc_if_icmpgt = 163; int opc_if_icmpgt = 163;
public final static int opc_if_icmple = 164; int opc_if_icmple = 164;
public final static int opc_if_acmpeq = 165; int opc_if_acmpeq = 165;
public final static int opc_if_acmpne = 166; int opc_if_acmpne = 166;
public final static int opc_goto = 167; int opc_goto = 167;
public final static int opc_jsr = 168; int opc_jsr = 168;
public final static int opc_ret = 169; int opc_ret = 169;
public final static int opc_tableswitch = 170; int opc_tableswitch = 170;
public final static int opc_lookupswitch = 171; int opc_lookupswitch = 171;
public final static int opc_ireturn = 172; int opc_ireturn = 172;
public final static int opc_lreturn = 173; int opc_lreturn = 173;
public final static int opc_freturn = 174; int opc_freturn = 174;
public final static int opc_dreturn = 175; int opc_dreturn = 175;
public final static int opc_areturn = 176; int opc_areturn = 176;
public final static int opc_return = 177; int opc_return = 177;
public final static int opc_getstatic = 178; int opc_getstatic = 178;
public final static int opc_putstatic = 179; int opc_putstatic = 179;
public final static int opc_getfield = 180; int opc_getfield = 180;
public final static int opc_putfield = 181; int opc_putfield = 181;
public final static int opc_invokevirtual = 182; int opc_invokevirtual = 182;
public final static int opc_invokespecial = 183; int opc_invokespecial = 183;
public final static int opc_invokestatic = 184; int opc_invokestatic = 184;
public final static int opc_invokeinterface = 185; int opc_invokeinterface = 185;
public final static int opc_invokedynamic = 186; int opc_invokedynamic = 186;
public final static int opc_xxxunusedxxx = 186; int opc_xxxunusedxxx = 186;
public final static int opc_new = 187; int opc_new = 187;
public final static int opc_newarray = 188; int opc_newarray = 188;
public final static int opc_anewarray = 189; int opc_anewarray = 189;
public final static int opc_arraylength = 190; int opc_arraylength = 190;
public final static int opc_athrow = 191; int opc_athrow = 191;
public final static int opc_checkcast = 192; int opc_checkcast = 192;
public final static int opc_instanceof = 193; int opc_instanceof = 193;
public final static int opc_monitorenter = 194; int opc_monitorenter = 194;
public final static int opc_monitorexit = 195; int opc_monitorexit = 195;
public final static int opc_wide = 196; int opc_wide = 196;
public final static int opc_multianewarray = 197; int opc_multianewarray = 197;
public final static int opc_ifnull = 198; int opc_ifnull = 198;
public final static int opc_ifnonnull = 199; int opc_ifnonnull = 199;
public final static int opc_goto_w = 200; int opc_goto_w = 200;
public final static int opc_jsr_w = 201; int opc_jsr_w = 201;
} }

2
src/org/jetbrains/java/decompiler/code/Instruction.java
View File

@ -58,7 +58,7 @@ public class Instruction implements CodeConstants {
} }
public Instruction clone() { public Instruction clone() {
return ConstantsUtil.getInstructionInstance(opcode, wide, group, bytecode_version, operands == null ? null : (int[])operands.clone()); return ConstantsUtil.getInstructionInstance(opcode, wide, group, bytecode_version, operands == null ? null : operands.clone());
} }
public String toString() { public String toString() {

22
src/org/jetbrains/java/decompiler/code/InstructionSequence.java
View File

@ -74,23 +74,23 @@ public abstract class InstructionSequence {
} }
public Instruction getCurrentInstr() { public Instruction getCurrentInstr() {
return (Instruction)collinstr.get(pointer); return collinstr.get(pointer);
} }
public Instruction getInstr(int index) { public Instruction getInstr(int index) {
return (Instruction)collinstr.get(index); return collinstr.get(index);
} }
public Instruction getLastInstr() { public Instruction getLastInstr() {
return (Instruction)collinstr.getLast(); return collinstr.getLast();
} }
public int getCurrentOffset() { public int getCurrentOffset() {
return ((Integer)collinstr.getKey(pointer)).intValue(); return collinstr.getKey(pointer).intValue();
} }
public int getOffset(int index) { public int getOffset(int index) {
return ((Integer)collinstr.getKey(index)).intValue(); return collinstr.getKey(index).intValue();
} }
public int getPointerByAbsOffset(int offset) { public int getPointerByAbsOffset(int offset) {
@ -104,7 +104,7 @@ public abstract class InstructionSequence {
} }
public int getPointerByRelOffset(int offset) { public int getPointerByRelOffset(int offset) {
Integer absoffset = new Integer(((Integer)collinstr.getKey(pointer)).intValue() + offset); Integer absoffset = new Integer(collinstr.getKey(pointer).intValue() + offset);
if (collinstr.containsKey(absoffset)) { if (collinstr.containsKey(absoffset)) {
return collinstr.getIndexByKey(absoffset); return collinstr.getIndexByKey(absoffset);
} }
@ -114,7 +114,7 @@ public abstract class InstructionSequence {
} }
public void setPointerByAbsOffset(int offset) { public void setPointerByAbsOffset(int offset) {
Integer absoffset = new Integer(((Integer)collinstr.getKey(pointer)).intValue() + offset); Integer absoffset = new Integer(collinstr.getKey(pointer).intValue() + offset);
if (collinstr.containsKey(absoffset)) { if (collinstr.containsKey(absoffset)) {
pointer = collinstr.getIndexByKey(absoffset); pointer = collinstr.getIndexByKey(absoffset);
} }
@ -144,9 +144,9 @@ public abstract class InstructionSequence {
for (int i = 0; i < collinstr.size(); i++) { for (int i = 0; i < collinstr.size(); i++) {
buf.append(InterpreterUtil.getIndentString(indent)); buf.append(InterpreterUtil.getIndentString(indent));
buf.append(((Integer)collinstr.getKey(i)).intValue()); buf.append(collinstr.getKey(i).intValue());
buf.append(": "); buf.append(": ");
buf.append(((Instruction)collinstr.get(i)).toString()); buf.append(collinstr.get(i).toString());
buf.append(new_line_separator); buf.append(new_line_separator);
} }
@ -156,7 +156,7 @@ public abstract class InstructionSequence {
public void writeCodeToStream(DataOutputStream out) throws IOException { public void writeCodeToStream(DataOutputStream out) throws IOException {
for (int i = 0; i < collinstr.size(); i++) { for (int i = 0; i < collinstr.size(); i++) {
((Instruction)collinstr.get(i)).writeToStream(out, ((Integer)collinstr.getKey(i)).intValue()); collinstr.get(i).writeToStream(out, collinstr.getKey(i).intValue());
} }
} }
@ -166,7 +166,7 @@ public abstract class InstructionSequence {
out.writeShort(handlers.size()); out.writeShort(handlers.size());
for (int i = 0; i < handlers.size(); i++) { for (int i = 0; i < handlers.size(); i++) {
((ExceptionHandler)handlers.get(i)).writeToStream(out); handlers.get(i).writeToStream(out);
} }
} }

36
src/org/jetbrains/java/decompiler/code/cfg/ControlFlowGraph.java
View File

@ -94,11 +94,11 @@ public class ControlFlowGraph implements CodeConstants {
List<BasicBlock> suc = block.getSuccs(); List<BasicBlock> suc = block.getSuccs();
for (int j = 0; j < suc.size(); j++) { for (int j = 0; j < suc.size(); j++) {
buf.append(">>>>>>>>(regular) Block " + ((BasicBlock)suc.get(j)).id + new_line_separator); buf.append(">>>>>>>>(regular) Block " + suc.get(j).id + new_line_separator);
} }
suc = block.getSuccExceptions(); suc = block.getSuccExceptions();
for (int j = 0; j < suc.size(); j++) { for (int j = 0; j < suc.size(); j++) {
BasicBlock handler = (BasicBlock)suc.get(j); BasicBlock handler = suc.get(j);
ExceptionRangeCFG range = getExceptionRange(handler, block); ExceptionRangeCFG range = getExceptionRange(handler, block);
if (range == null) { if (range == null) {
@ -134,19 +134,19 @@ public class ControlFlowGraph implements CodeConstants {
public void removeBlock(BasicBlock block) { public void removeBlock(BasicBlock block) {
while (block.getSuccs().size() > 0) { while (block.getSuccs().size() > 0) {
block.removeSuccessor((BasicBlock)block.getSuccs().get(0)); block.removeSuccessor(block.getSuccs().get(0));
} }
while (block.getSuccExceptions().size() > 0) { while (block.getSuccExceptions().size() > 0) {
block.removeSuccessorException((BasicBlock)block.getSuccExceptions().get(0)); block.removeSuccessorException(block.getSuccExceptions().get(0));
} }
while (block.getPreds().size() > 0) { while (block.getPreds().size() > 0) {
((BasicBlock)block.getPreds().get(0)).removeSuccessor(block); block.getPreds().get(0).removeSuccessor(block);
} }
while (block.getPredExceptions().size() > 0) { while (block.getPredExceptions().size() > 0) {
((BasicBlock)block.getPredExceptions().get(0)).removeSuccessorException(block); block.getPredExceptions().get(0).removeSuccessorException(block);
} }
last.removePredecessor(block); last.removePredecessor(block);
@ -154,7 +154,7 @@ public class ControlFlowGraph implements CodeConstants {
blocks.removeWithKey(block.id); blocks.removeWithKey(block.id);
for (int i = exceptions.size() - 1; i >= 0; i--) { for (int i = exceptions.size() - 1; i >= 0; i--) {
ExceptionRangeCFG range = (ExceptionRangeCFG)exceptions.get(i); ExceptionRangeCFG range = exceptions.get(i);
if (range.getHandler() == block) { if (range.getHandler() == block) {
exceptions.remove(i); exceptions.remove(i);
} }
@ -394,7 +394,7 @@ public class ControlFlowGraph implements CodeConstants {
ExceptionRangeCFG range = new ExceptionRangeCFG(protectedRange, handle, handler.exceptionClass == null ExceptionRangeCFG range = new ExceptionRangeCFG(protectedRange, handle, handler.exceptionClass == null
? null ? null
: Arrays.asList(new String[]{handler.exceptionClass})); : Arrays.asList(handler.exceptionClass));
mapRanges.put(key, range); mapRanges.put(key, range);
exceptions.add(range); exceptions.add(range);
@ -495,11 +495,11 @@ public class ControlFlowGraph implements CodeConstants {
// find the first intersection // find the first intersection
for (int i = 0; i < lstJsr.size(); i++) { for (int i = 0; i < lstJsr.size(); i++) {
Object[] arr = (Object[])lstJsr.get(i); Object[] arr = lstJsr.get(i);
HashSet<BasicBlock> set = (HashSet<BasicBlock>)arr[1]; HashSet<BasicBlock> set = (HashSet<BasicBlock>)arr[1];
for (int j = i + 1; j < lstJsr.size(); j++) { for (int j = i + 1; j < lstJsr.size(); j++) {
Object[] arr1 = (Object[])lstJsr.get(j); Object[] arr1 = lstJsr.get(j);
HashSet<BasicBlock> set1 = (HashSet<BasicBlock>)arr1[1]; HashSet<BasicBlock> set1 = (HashSet<BasicBlock>)arr1[1];
if (!set.contains(arr1[0]) && !set1.contains(arr[0])) { // rang 0 doesn't contain entry 1 and vice versa if (!set.contains(arr1[0]) && !set1.contains(arr[0])) { // rang 0 doesn't contain entry 1 and vice versa
@ -613,11 +613,11 @@ public class ControlFlowGraph implements CodeConstants {
for (int i = lst.size() - 1; i >= 0; i--) { for (int i = lst.size() - 1; i >= 0; i--) {
BasicBlock child = (BasicBlock)lst.get(i); BasicBlock child = lst.get(i);
Integer childid = child.id; Integer childid = child.id;
if (mapNewNodes.containsKey(childid)) { if (mapNewNodes.containsKey(childid)) {
node.replaceSuccessor(child, (BasicBlock)mapNewNodes.get(childid)); node.replaceSuccessor(child, mapNewNodes.get(childid));
} }
else if (common_blocks.contains(child)) { else if (common_blocks.contains(child)) {
@ -632,11 +632,11 @@ public class ControlFlowGraph implements CodeConstants {
} }
else { else {
for (int k = 0; k < child.getSuccs().size(); k++) { for (int k = 0; k < child.getSuccs().size(); k++) {
copy.addSuccessor((BasicBlock)child.getSuccs().get(k)); copy.addSuccessor(child.getSuccs().get(k));
} }
} }
for (int k = 0; k < child.getSuccExceptions().size(); k++) { for (int k = 0; k < child.getSuccExceptions().size(); k++) {
copy.addSuccessorException((BasicBlock)child.getSuccExceptions().get(k)); copy.addSuccessorException(child.getSuccExceptions().get(k));
} }
lstNodes.add(copy); lstNodes.add(copy);
@ -666,7 +666,7 @@ public class ControlFlowGraph implements CodeConstants {
for (int i = exceptions.size() - 1; i >= 0; i--) { for (int i = exceptions.size() - 1; i >= 0; i--) {
ExceptionRangeCFG range = (ExceptionRangeCFG)exceptions.get(i); ExceptionRangeCFG range = exceptions.get(i);
List<BasicBlock> lstRange = range.getProtectedRange(); List<BasicBlock> lstRange = range.getProtectedRange();
HashSet<BasicBlock> setBoth = new HashSet<BasicBlock>(common_blocks); HashSet<BasicBlock> setBoth = new HashSet<BasicBlock>(common_blocks);
@ -678,7 +678,7 @@ public class ControlFlowGraph implements CodeConstants {
if (setBoth.size() == lstRange.size()) { if (setBoth.size() == lstRange.size()) {
lstNewRange = new ArrayList<BasicBlock>(); lstNewRange = new ArrayList<BasicBlock>();
ExceptionRangeCFG newRange = new ExceptionRangeCFG(lstNewRange, ExceptionRangeCFG newRange = new ExceptionRangeCFG(lstNewRange,
(BasicBlock)mapNewNodes.get(range.getHandler().id), range.getExceptionTypes()); mapNewNodes.get(range.getHandler().id), range.getExceptionTypes());
exceptions.add(newRange); exceptions.add(newRange);
} }
else { else {
@ -729,14 +729,14 @@ public class ControlFlowGraph implements CodeConstants {
block.mark = 1; block.mark = 1;
for (int i = 0; i < block.getSuccs().size(); i++) { for (int i = 0; i < block.getSuccs().size(); i++) {
BasicBlock suc = (BasicBlock)block.getSuccs().get(i); BasicBlock suc = block.getSuccs().get(i);
if (suc.mark != 1) { if (suc.mark != 1) {
removeJsrInstructions(pool, suc, data.copy()); removeJsrInstructions(pool, suc, data.copy());
} }
} }
for (int i = 0; i < block.getSuccExceptions().size(); i++) { for (int i = 0; i < block.getSuccExceptions().size(); i++) {
BasicBlock suc = (BasicBlock)block.getSuccExceptions().get(i); BasicBlock suc = block.getSuccExceptions().get(i);
if (suc.mark != 1) { if (suc.mark != 1) {
DataPoint point = new DataPoint(); DataPoint point = new DataPoint();

2
src/org/jetbrains/java/decompiler/code/interpreter/InstructionImpact.java
View File

@ -432,7 +432,7 @@ public class InstructionImpact {
stack.push(new VarType(var1.type, var1.arraydim - 1, var1.value)); stack.push(new VarType(var1.type, var1.arraydim - 1, var1.value));
break; break;
case CodeConstants.opc_astore: case CodeConstants.opc_astore:
data.setVariable(instr.getOperand(0), (VarType)stack.pop()); data.setVariable(instr.getOperand(0), stack.pop());
break; break;
case CodeConstants.opc_dup: case CodeConstants.opc_dup:
case CodeConstants.opc_dup_x1: case CodeConstants.opc_dup_x1:

2
src/org/jetbrains/java/decompiler/main/ClassReference14Processor.java
View File

@ -225,7 +225,7 @@ public class ClassReference14Processor {
boolean res = false; boolean res = false;
for (; ; ) { while (true) {
boolean found = false; boolean found = false;

2
src/org/jetbrains/java/decompiler/main/ClassWriter.java
View File

@ -159,7 +159,6 @@ public class ClassWriter {
boolean firstpar = true; boolean firstpar = true;
int index = node.lambda_information.is_content_method_static ? 0 : 1; int index = node.lambda_information.is_content_method_static ? 0 : 1;
;
int start_index = md_content.params.length - md_lambda.params.length; int start_index = md_content.params.length - md_lambda.params.length;
@ -625,7 +624,6 @@ public class ClassWriter {
boolean firstpar = true; boolean firstpar = true;
int index = node_lambda.lambda_information.is_content_method_static ? 0 : 1; int index = node_lambda.lambda_information.is_content_method_static ? 0 : 1;
;
int start_index = md_content.params.length - md_lambda.params.length; int start_index = md_content.params.length - md_lambda.params.length;

7
src/org/jetbrains/java/decompiler/main/Fernflower.java
View File

@ -39,12 +39,9 @@ public class Fernflower implements IDecompiledData {
private ClassesProcessor clprocessor; private ClassesProcessor clprocessor;
public Fernflower(IBytecodeProvider provider, IDecompilatSaver saver, public Fernflower(IBytecodeProvider provider, IDecompilatSaver saver, HashMap<String, Object> propertiesCustom) {
HashMap<String, Object> propertiesCustom) {
StructContext context = new StructContext(saver, this, new LazyLoader(provider)); structcontext = new StructContext(saver, this, new LazyLoader(provider));
structcontext = context;
DecompilerContext.initContext(propertiesCustom); DecompilerContext.initContext(propertiesCustom);
DecompilerContext.setCountercontainer(new CounterContainer()); DecompilerContext.setCountercontainer(new CounterContainer());

2
src/org/jetbrains/java/decompiler/main/InitializerProcessor.java
View File

@ -191,7 +191,7 @@ public class InitializerProcessor {
return; return;
} }
for (; ; ) { while (true) {
String fieldWithDescr = null; String fieldWithDescr = null;
Exprent value = null; Exprent value = null;

2
src/org/jetbrains/java/decompiler/main/decompiler/ConsoleDecompiler.java
View File

@ -31,7 +31,7 @@ import java.util.zip.ZipEntry;
import java.util.zip.ZipFile; import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream; import java.util.zip.ZipOutputStream;
@SuppressWarnings({"UseOfSystemOutOrSystemErr", "CallToPrintStackTrace"})
public class ConsoleDecompiler implements IBytecodeProvider, IDecompilatSaver { public class ConsoleDecompiler implements IBytecodeProvider, IDecompilatSaver {
private File root; private File root;

2
src/org/jetbrains/java/decompiler/main/extern/IBytecodeProvider.java vendored
View File

@ -19,5 +19,5 @@ import java.io.InputStream;
public interface IBytecodeProvider { public interface IBytecodeProvider {
public InputStream getBytecodeStream(String externPath, String internPath); InputStream getBytecodeStream(String externPath, String internPath);
} }

18
src/org/jetbrains/java/decompiler/main/extern/IDecompilatSaver.java vendored
View File

@ -19,21 +19,21 @@ import java.util.jar.Manifest;
public interface IDecompilatSaver { public interface IDecompilatSaver {
public void copyFile(String source, String destpath, String destfilename); void copyFile(String source, String destpath, String destfilename);
public void saveFolder(String path); void saveFolder(String path);
public void saveClassFile(String path, String qualifiedName, String entryName, String content); void saveClassFile(String path, String qualifiedName, String entryName, String content);
public void saveFile(String path, String filename, String content); void saveFile(String path, String filename, String content);
public void createArchive(String path, String archivename, Manifest manifest); void createArchive(String path, String archivename, Manifest manifest);
public void saveClassEntry(String path, String archivename, String qualifiedName, String entryName, String content); void saveClassEntry(String path, String archivename, String qualifiedName, String entryName, String content);
public void saveEntry(String path, String archivename, String entryName, String content); void saveEntry(String path, String archivename, String entryName, String content);
public void copyEntry(String source, String destpath, String archivename, String entry); void copyEntry(String source, String destpath, String archivename, String entry);
public void closeArchive(String path, String archivename); void closeArchive(String path, String archivename);
} }

34
src/org/jetbrains/java/decompiler/main/extern/IFernflowerLogger.java vendored
View File

@ -19,13 +19,13 @@ import java.util.HashMap;
public interface IFernflowerLogger { public interface IFernflowerLogger {
public static final int TRACE = 1; int TRACE = 1;
public static final int INFO = 2; int INFO = 2;
public static final int WARNING = 3; int WARNING = 3;
public static final int ERROR = 4; int ERROR = 4;
public static final int IMMEDIATE = 5; int IMMEDIATE = 5;
public static final HashMap<String, Integer> mapLogLevel = new HashMap<String, Integer>() {{ HashMap<String, Integer> mapLogLevel = new HashMap<String, Integer>() {{
put("TRACE", 1); put("TRACE", 1);
put("INFO", 2); put("INFO", 2);
put("WARN", 3); put("WARN", 3);
@ -33,25 +33,25 @@ public interface IFernflowerLogger {
put("IMME", 5); put("IMME", 5);
}}; }};
public static final String[] names = new String[]{""/*DUMMY ENTRY*/, "TRACE", "INFO", "WARNING", "ERROR", ""/*IMMEDIATE*/}; String[] names = new String[]{""/*DUMMY ENTRY*/, "TRACE", "INFO", "WARNING", "ERROR", ""/*IMMEDIATE*/};
public void writeMessage(String message, int severity); void writeMessage(String message, int severity);
public void writeMessage(String message, Throwable t); void writeMessage(String message, Throwable t);
public void startClass(String classname); void startClass(String classname);
public void endClass(); void endClass();
public void startWriteClass(String classname); void startWriteClass(String classname);
public void endWriteClass(); void endWriteClass();
public void startMethod(String method); void startMethod(String method);
public void endMethod(); void endMethod();
public int getSeverity(); int getSeverity();
public void setSeverity(int severity); void setSeverity(int severity);
} }

64
src/org/jetbrains/java/decompiler/main/extern/IFernflowerPreferences.java vendored
View File

@ -17,42 +17,42 @@ package org.jetbrains.java.decompiler.main.extern;
public interface IFernflowerPreferences { public interface IFernflowerPreferences {
public static final String REMOVE_BRIDGE = "rbr"; String REMOVE_BRIDGE = "rbr";
public static final String REMOVE_SYNTHETIC = "rsy"; String REMOVE_SYNTHETIC = "rsy";
public static final String DECOMPILE_INNER = "din"; String DECOMPILE_INNER = "din";
public static final String DECOMPILE_CLASS_1_4 = "dc4"; String DECOMPILE_CLASS_1_4 = "dc4";
public static final String DECOMPILE_ASSERTIONS = "das"; String DECOMPILE_ASSERTIONS = "das";
public static final String HIDE_EMPTY_SUPER = "hes"; String HIDE_EMPTY_SUPER = "hes";
public static final String HIDE_DEFAULT_CONSTRUCTOR = "hdc"; String HIDE_DEFAULT_CONSTRUCTOR = "hdc";
public static final String DECOMPILE_GENERIC_SIGNATURES = "dgs"; String DECOMPILE_GENERIC_SIGNATURES = "dgs";
public static final String OUTPUT_COPYRIGHT_COMMENT = "occ"; String OUTPUT_COPYRIGHT_COMMENT = "occ";
public static final String NO_EXCEPTIONS_RETURN = "ner"; String NO_EXCEPTIONS_RETURN = "ner";
public static final String DECOMPILE_ENUM = "den"; String DECOMPILE_ENUM = "den";
public static final String REMOVE_GETCLASS_NEW = "rgn"; String REMOVE_GETCLASS_NEW = "rgn";
public static final String LITERALS_AS_IS = "lit"; String LITERALS_AS_IS = "lit";
public static final String BOOLEAN_TRUE_ONE = "bto"; String BOOLEAN_TRUE_ONE = "bto";
public static final String SYNTHETIC_NOT_SET = "nns"; String SYNTHETIC_NOT_SET = "nns";
public static final String UNDEFINED_PARAM_TYPE_OBJECT = "uto"; String UNDEFINED_PARAM_TYPE_OBJECT = "uto";
public static final String USE_DEBUG_VARNAMES = "udv"; String USE_DEBUG_VARNAMES = "udv";
public static final String MAX_PROCESSING_METHOD = "mpm"; String MAX_PROCESSING_METHOD = "mpm";
public static final String REMOVE_EMPTY_RANGES = "rer"; String REMOVE_EMPTY_RANGES = "rer";
public static final String ASCII_STRING_CHARACTERS = "asc"; String ASCII_STRING_CHARACTERS = "asc";
public static final String FINALLY_DEINLINE = "fdi"; String FINALLY_DEINLINE = "fdi";
public static final String FINALLY_CATCHALL = "FINALLY_CATCHALL"; String FINALLY_CATCHALL = "FINALLY_CATCHALL";
public static final String FINALLY_SEMAPHOR = "FINALLY_SEMAPHOR"; String FINALLY_SEMAPHOR = "FINALLY_SEMAPHOR";
public static final String RENAME_ENTITIES = "ren"; String RENAME_ENTITIES = "ren";
public static final String USER_RENAMER_CLASS = "urc"; String USER_RENAMER_CLASS = "urc";
public static final String LOG_LEVEL = "log"; String LOG_LEVEL = "log";
public static final String NEW_LINE_SEPARATOR = "nls"; String NEW_LINE_SEPARATOR = "nls";
public static final String IDEA_NOT_NULL_ANNOTATION = "inn"; String IDEA_NOT_NULL_ANNOTATION = "inn";
public static final String LAMBDA_TO_ANONYMOUS_CLASS = "lac"; String LAMBDA_TO_ANONYMOUS_CLASS = "lac";
public static final String INDENT_STRING = "ind"; String INDENT_STRING = "ind";
public static final String LINE_SEPARATOR_WIN = "\r\n"; String LINE_SEPARATOR_WIN = "\r\n";
public static final String LINE_SEPARATOR_LIN = "\n"; String LINE_SEPARATOR_LIN = "\n";
} }

14
src/org/jetbrains/java/decompiler/main/extern/IIdentifierRenamer.java vendored
View File

@ -18,18 +18,18 @@ package org.jetbrains.java.decompiler.main.extern;
public interface IIdentifierRenamer { public interface IIdentifierRenamer {
public static final int ELEMENT_CLASS = 1; int ELEMENT_CLASS = 1;
public static final int ELEMENT_FIELD = 2; int ELEMENT_FIELD = 2;
public static final int ELEMENT_METHOD = 3; int ELEMENT_METHOD = 3;
public boolean toBeRenamed(int element_type, String classname, String element, String descriptor); boolean toBeRenamed(int element_type, String classname, String element, String descriptor);
public String getNextClassname(String fullname, String shortname); String getNextClassname(String fullname, String shortname);
public String getNextFieldname(String classname, String field, String descriptor); String getNextFieldname(String classname, String field, String descriptor);
public String getNextMethodname(String classname, String method, String descriptor); String getNextMethodname(String classname, String method, String descriptor);
} }

10
src/org/jetbrains/java/decompiler/main/rels/MethodProcessorThread.java
View File

@ -62,9 +62,7 @@ public class MethodProcessorThread implements Runnable {
this.notify(); this.notify();
} }
} }
catch (ThreadDeath ex) { catch (ThreadDeath ignored) { }
;
}
catch (Throwable ex) { catch (Throwable ex) {
error = ex; error = ex;
} }
@ -169,7 +167,7 @@ public class MethodProcessorThread implements Runnable {
//System.out.println("~~~~~~~~~~~~~~~~~~~~~~ \r\n"+root.toJava()); //System.out.println("~~~~~~~~~~~~~~~~~~~~~~ \r\n"+root.toJava());
for (; ; ) { while (true) {
StackVarsProcessor stackproc = new StackVarsProcessor(); StackVarsProcessor stackproc = new StackVarsProcessor();
stackproc.simplifyStackVars(root, mt, cl); stackproc.simplifyStackVars(root, mt, cl);
@ -184,11 +182,11 @@ public class MethodProcessorThread implements Runnable {
} }
} }
for (; ; ) { while (true) {
LabelHelper.cleanUpEdges(root); LabelHelper.cleanUpEdges(root);
for (; ; ) { while (true) {
MergeHelper.enhanceLoops(root); MergeHelper.enhanceLoops(root);

3
src/org/jetbrains/java/decompiler/main/rels/NestedClassProcessor.java
View File

@ -151,7 +151,6 @@ public class NestedClassProcessor {
InvocationExprent inv_dynamic = new_expr.getConstructor(); InvocationExprent inv_dynamic = new_expr.getConstructor();
int param_index = is_static_lambda_content ? 0 : 1; int param_index = is_static_lambda_content ? 0 : 1;
;
int varindex = is_static_lambda_content ? 0 : 1; int varindex = is_static_lambda_content ? 0 : 1;
for (int i = 0; i < vars_count; ++i) { for (int i = 0; i < vars_count; ++i) {
@ -713,7 +712,7 @@ public class NestedClassProcessor {
private void mergeListSignatures(List<VarFieldPair> first, List<VarFieldPair> second, boolean both) { private void mergeListSignatures(List<VarFieldPair> first, List<VarFieldPair> second, boolean both) {
int i = 1; int i = 1;
for (; ; ) { while (true) {
if (first.size() <= i || second.size() <= i) { if (first.size() <= i || second.size() <= i) {
break; break;
} }

6
src/org/jetbrains/java/decompiler/main/rels/NestedMemberAccess.java
View File

@ -286,7 +286,7 @@ public class NestedMemberAccess {
res |= replaceInvocations(caller, meth, expr); res |= replaceInvocations(caller, meth, expr);
} }
for (; ; ) { while (true) {
boolean found = false; boolean found = false;
@ -397,10 +397,10 @@ public class NestedMemberAccess {
AssignmentExprent ret; AssignmentExprent ret;
if (source.type == Exprent.EXPRENT_EXIT) { if (source.type == Exprent.EXPRENT_EXIT) {
ExitExprent extex = (ExitExprent)source; ExitExprent extex = (ExitExprent)source;
ret = (AssignmentExprent)((AssignmentExprent)extex.getValue()).copy(); ret = (AssignmentExprent)extex.getValue().copy();
} }
else { else {
ret = (AssignmentExprent)((AssignmentExprent)source).copy(); ret = (AssignmentExprent)source.copy();
} }
FieldExprent fexpr = (FieldExprent)ret.getLeft(); FieldExprent fexpr = (FieldExprent)ret.getLeft();

14
src/org/jetbrains/java/decompiler/modules/code/DeadCodeHelper.java
View File

@ -70,7 +70,7 @@ public class DeadCodeHelper {
cont = false; cont = false;
for (int i = blocks.size() - 1; i >= 0; i--) { for (int i = blocks.size() - 1; i >= 0; i--) {
BasicBlock block = (BasicBlock)blocks.get(i); BasicBlock block = blocks.get(i);
if (removeEmptyBlock(graph, block, false)) { if (removeEmptyBlock(graph, block, false)) {
cont = true; cont = true;
@ -197,7 +197,7 @@ public class DeadCodeHelper {
graph.removeBlock(block); graph.removeBlock(block);
if (deletedRanges) { if (deletedRanges) {
DeadCodeHelper.removeDeadBlocks(graph); removeDeadBlocks(graph);
} }
} }
} }
@ -219,7 +219,7 @@ public class DeadCodeHelper {
while (!lstNodes.isEmpty()) { while (!lstNodes.isEmpty()) {
BasicBlock node = (BasicBlock)lstNodes.remove(0); BasicBlock node = lstNodes.remove(0);
if (marked.contains(node)) { if (marked.contains(node)) {
continue; continue;
} }
@ -232,14 +232,14 @@ public class DeadCodeHelper {
} }
for (int i = 0; i < node.getPreds().size(); i++) { for (int i = 0; i < node.getPreds().size(); i++) {
BasicBlock pred = (BasicBlock)node.getPreds().get(i); BasicBlock pred = node.getPreds().get(i);
if (!marked.contains(pred) && pred != dom) { if (!marked.contains(pred) && pred != dom) {
lstNodes.add(pred); lstNodes.add(pred);
} }
} }
for (int i = 0; i < node.getPredExceptions().size(); i++) { for (int i = 0; i < node.getPredExceptions().size(); i++) {
BasicBlock pred = (BasicBlock)node.getPredExceptions().get(i); BasicBlock pred = node.getPredExceptions().get(i);
if (!marked.contains(pred) && pred != dom) { if (!marked.contains(pred) && pred != dom) {
lstNodes.add(pred); lstNodes.add(pred);
} }
@ -259,7 +259,7 @@ public class DeadCodeHelper {
} }
} }
DeadCodeHelper.removeEmptyBlocks(graph); removeEmptyBlocks(graph);
} }
public static void connectDummyExitBlock(ControlFlowGraph graph) { public static void connectDummyExitBlock(ControlFlowGraph graph) {
@ -392,7 +392,7 @@ public class DeadCodeHelper {
public static void mergeBasicBlocks(ControlFlowGraph graph) { public static void mergeBasicBlocks(ControlFlowGraph graph) {
for (; ; ) { while (true) {
boolean merged = false; boolean merged = false;

2
src/org/jetbrains/java/decompiler/modules/decompiler/ConcatenationHelper.java
View File

@ -62,7 +62,7 @@ public class ConcatenationHelper {
// iterate in depth, collecting possible operands // iterate in depth, collecting possible operands
List<Exprent> lstOperands = new ArrayList<Exprent>(); List<Exprent> lstOperands = new ArrayList<Exprent>();
for (; ; ) { while (true) {
int found = 0; int found = 0;

2
src/org/jetbrains/java/decompiler/modules/decompiler/DecHelper.java
View File

@ -76,7 +76,7 @@ public class DecHelper {
return false; return false;
} }
for (; ; ) { while (true) {
lst.clear(); lst.clear();

6
src/org/jetbrains/java/decompiler/modules/decompiler/DomHelper.java
View File

@ -254,7 +254,7 @@ public class DomHelper {
if (stat.type == Statement.TYPE_SEQUENCE) { if (stat.type == Statement.TYPE_SEQUENCE) {
for (; ; ) { while (true) {
boolean found = false; boolean found = false;
@ -371,7 +371,7 @@ public class DomHelper {
boolean forceall = i != 0; boolean forceall = i != 0;
for (; ; ) { while (true) {
if (findSimpleStatements(general, mapExtPost)) { if (findSimpleStatements(general, mapExtPost)) {
reducibility = 0; reducibility = 0;
@ -494,7 +494,7 @@ public class DomHelper {
// collect statement nodes // collect statement nodes
HashSet<Statement> setHandlers = new HashSet<Statement>(); HashSet<Statement> setHandlers = new HashSet<Statement>();
setHandlers.add(head); setHandlers.add(head);
for (; ; ) { while (true) {
boolean hdfound = false; boolean hdfound = false;
Iterator<Statement> itHandlers = setHandlers.iterator(); Iterator<Statement> itHandlers = setHandlers.iterator();

6
src/org/jetbrains/java/decompiler/modules/decompiler/ExitHelper.java
View File

@ -91,7 +91,7 @@ public class ExitHelper {
if (stat.getExprents() == null) { if (stat.getExprents() == null) {
for (; ; ) { while (true) {
int changed = 0; int changed = 0;
@ -160,7 +160,7 @@ public class ExitHelper {
bstat.addSuccessor(newexitedge); bstat.addSuccessor(newexitedge);
oldexitedge.closure.addLabeledEdge(newexitedge); oldexitedge.closure.addLabeledEdge(newexitedge);
SequenceStatement block = new SequenceStatement(Arrays.asList(new Statement[]{stat, bstat})); SequenceStatement block = new SequenceStatement(Arrays.asList(stat, bstat));
block.setAllParent(); block.setAllParent();
parent.replaceStatement(stat, block); parent.replaceStatement(stat, block);
@ -324,7 +324,7 @@ public class ExitHelper {
bstat.setExprents(new ArrayList<Exprent>(Arrays.asList(new Exprent[]{retexpr}))); bstat.setExprents(new ArrayList<Exprent>(Arrays.asList(new Exprent[]{retexpr})));
// build sequence to replace the former top statement // build sequence to replace the former top statement
SequenceStatement seq = new SequenceStatement(Arrays.asList(new Statement[]{top, bstat})); SequenceStatement seq = new SequenceStatement(Arrays.asList(top, bstat));
top.setParent(seq); top.setParent(seq);
bstat.setParent(seq); bstat.setParent(seq);
seq.setParent(root); seq.setParent(root);

8
src/org/jetbrains/java/decompiler/modules/decompiler/ExprProcessor.java
View File

@ -706,7 +706,7 @@ public class ExprProcessor implements CodeConstants {
return "void"; return "void";
} }
else if (tp == CodeConstants.TYPE_OBJECT) { else if (tp == CodeConstants.TYPE_OBJECT) {
String ret = ExprProcessor.buildJavaClassName(type.value); String ret = buildJavaClassName(type.value);
if (getShort) { if (getShort) {
ret = DecompilerContext.getImpcollector().getShortName(ret); ret = DecompilerContext.getImpcollector().getShortName(ret);
} }
@ -761,7 +761,7 @@ public class ExprProcessor implements CodeConstants {
List<StatEdge> lstSuccs = stat.getSuccessorEdges(Statement.STATEDGE_DIRECT_ALL); List<StatEdge> lstSuccs = stat.getSuccessorEdges(Statement.STATEDGE_DIRECT_ALL);
if (lstSuccs.size() == 1) { if (lstSuccs.size() == 1) {
StatEdge edge = lstSuccs.get(0); StatEdge edge = lstSuccs.get(0);
if (edge.getType() != StatEdge.TYPE_REGULAR && edge.explicit == true && edge.getDestination().type != Statement.TYPE_DUMMYEXIT) { if (edge.getType() != StatEdge.TYPE_REGULAR && edge.explicit && edge.getDestination().type != Statement.TYPE_DUMMYEXIT) {
buf.append(InterpreterUtil.getIndentString(indent)); buf.append(InterpreterUtil.getIndentString(indent));
switch (edge.getType()) { switch (edge.getType()) {
@ -820,7 +820,7 @@ public class ExprProcessor implements CodeConstants {
if (expr.type == Exprent.EXPRENT_MONITOR && ((MonitorExprent)expr).getMontype() == MonitorExprent.MONITOR_ENTER) { if (expr.type == Exprent.EXPRENT_MONITOR && ((MonitorExprent)expr).getMontype() == MonitorExprent.MONITOR_ENTER) {
buf.append("{}"); // empty synchronized block buf.append("{}"); // empty synchronized block
} }
if (ExprProcessor.endsWithSemikolon(expr)) { if (endsWithSemikolon(expr)) {
buf.append(";"); buf.append(";");
} }
buf.append(new_line_separator); buf.append(new_line_separator);
@ -885,7 +885,7 @@ public class ExprProcessor implements CodeConstants {
res = "(" + res + ")"; res = "(" + res + ")";
} }
res = "(" + ExprProcessor.getCastTypeName(leftType) + ")" + res; res = "(" + getCastTypeName(leftType) + ")" + res;
ret = true; ret = true;
} }

4
src/org/jetbrains/java/decompiler/modules/decompiler/ExprentStack.java
View File

@ -36,9 +36,7 @@ public class ExprentStack extends ListStack<Exprent> {
public Exprent pop() { public Exprent pop() {
Exprent o = this.remove(--pointer); return this.remove(--pointer);
return o;
} }
public ExprentStack clone() { public ExprentStack clone() {

6
src/org/jetbrains/java/decompiler/modules/decompiler/FinallyProcessor.java
View File

@ -81,7 +81,7 @@ public class FinallyProcessor {
BasicBlock handler = fin.getHandler().getBasichead().getBlock(); BasicBlock handler = fin.getHandler().getBasichead().getBlock();
if (catchallBlockIDs.containsKey(handler.id)) { if (catchallBlockIDs.containsKey(handler.id)) {
; // do nothing // do nothing
} }
else if (finallyBlockIDs.containsKey(handler.id)) { else if (finallyBlockIDs.containsKey(handler.id)) {
@ -465,8 +465,6 @@ public class FinallyProcessor {
range.getProtectedRange().remove(newheadinit); range.getProtectedRange().remove(newheadinit);
} }
} }
return;
} }
@ -677,7 +675,7 @@ public class FinallyProcessor {
// exception successors // exception successors
if (isLastBlock && blockSample.getSeq().isEmpty()) { if (isLastBlock && blockSample.getSeq().isEmpty()) {
; // do nothing, blockSample will be removed anyway // do nothing, blockSample will be removed anyway
} }
else { else {
if (blockCatch.getSuccExceptions().size() == blockSample.getSuccExceptions().size()) { if (blockCatch.getSuccExceptions().size() == blockSample.getSuccExceptions().size()) {

6
src/org/jetbrains/java/decompiler/modules/decompiler/IdeaNotNullHelper.java
View File

@ -78,7 +78,7 @@ public class IdeaNotNullHelper {
Exprent second_param = func.getLstOperands().get(1); Exprent second_param = func.getLstOperands().get(1);
if (second_param.type == Exprent.EXPRENT_CONST && if (second_param.type == Exprent.EXPRENT_CONST &&
((ConstExprent)second_param).getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order second_param.getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order
if (first_param.type == Exprent.EXPRENT_VAR) { if (first_param.type == Exprent.EXPRENT_VAR) {
VarExprent var = (VarExprent)first_param; VarExprent var = (VarExprent)first_param;
@ -227,7 +227,7 @@ public class IdeaNotNullHelper {
Statement elsebranch = ifparent.getElsestat(); Statement elsebranch = ifparent.getElsestat();
if (second_param.type == Exprent.EXPRENT_CONST && if (second_param.type == Exprent.EXPRENT_CONST &&
((ConstExprent)second_param).getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order second_param.getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order
//if(first_param.type == Exprent.EXPRENT_VAR && ((VarExprent)first_param).getIndex() == var_value.getIndex()) { //if(first_param.type == Exprent.EXPRENT_VAR && ((VarExprent)first_param).getIndex() == var_value.getIndex()) {
if (first_param.equals(exprent_value)) { // TODO: check for absence of side effects like method invocations etc. if (first_param.equals(exprent_value)) { // TODO: check for absence of side effects like method invocations etc.
if (ifbranch.type == Statement.TYPE_BASICBLOCK && if (ifbranch.type == Statement.TYPE_BASICBLOCK &&
@ -291,7 +291,7 @@ public class IdeaNotNullHelper {
Statement ifbranch = ifstat.getIfstat(); Statement ifbranch = ifstat.getIfstat();
if (second_param.type == Exprent.EXPRENT_CONST && if (second_param.type == Exprent.EXPRENT_CONST &&
((ConstExprent)second_param).getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order second_param.getExprType().type == CodeConstants.TYPE_NULL) { // TODO: reversed parameter order
if (first_param.equals(exprent_value)) { // TODO: check for absence of side effects like method invocations etc. if (first_param.equals(exprent_value)) { // TODO: check for absence of side effects like method invocations etc.
if (ifbranch.type == Statement.TYPE_BASICBLOCK && if (ifbranch.type == Statement.TYPE_BASICBLOCK &&
ifbranch.getExprents().size() == 1 && ifbranch.getExprents().size() == 1 &&

11
src/org/jetbrains/java/decompiler/modules/decompiler/IfHelper.java
View File

@ -50,7 +50,7 @@ public class IfHelper {
if (stat.getExprents() == null) { if (stat.getExprents() == null) {
for (; ; ) { while (true) {
boolean changed = false; boolean changed = false;
@ -59,7 +59,7 @@ public class IfHelper {
res |= mergeAllIfsRec(st, setReorderedIfs); res |= mergeAllIfsRec(st, setReorderedIfs);
// collapse composed if's // collapse composed if's
if (changed = IfHelper.mergeIfs(st, setReorderedIfs)) { if (changed = mergeIfs(st, setReorderedIfs)) {
break; break;
} }
} }
@ -84,7 +84,7 @@ public class IfHelper {
boolean res = false; boolean res = false;
for (; ; ) { while (true) {
boolean updated = false; boolean updated = false;
@ -442,7 +442,6 @@ public class IfHelper {
} }
boolean ifdirect = false, elsedirect = false; boolean ifdirect = false, elsedirect = false;
;
boolean noifstat = false, noelsestat = false; boolean noifstat = false, noelsestat = false;
boolean ifdirectpath = false, elsedirectpath = false; boolean ifdirectpath = false, elsedirectpath = false;
@ -471,7 +470,7 @@ public class IfHelper {
} }
} }
Statement last = parent.type == Statement.TYPE_SEQUENCE ? ((SequenceStatement)parent).getStats().getLast() : ifstat; Statement last = parent.type == Statement.TYPE_SEQUENCE ? parent.getStats().getLast() : ifstat;
noelsestat = (last == ifstat); noelsestat = (last == ifstat);
if (!last.getAllSuccessorEdges().isEmpty() && last.getAllSuccessorEdges().get(0).getType() == StatEdge.TYPE_FINALLYEXIT) { if (!last.getAllSuccessorEdges().isEmpty() && last.getAllSuccessorEdges().get(0).getType() == StatEdge.TYPE_FINALLYEXIT) {
@ -575,7 +574,7 @@ public class IfHelper {
} }
else { else {
Statement ifbranch = ifstat.getIfstat(); Statement ifbranch = ifstat.getIfstat();
SequenceStatement newseq = new SequenceStatement(Arrays.asList(new Statement[]{ifstat, ifbranch})); SequenceStatement newseq = new SequenceStatement(Arrays.asList(ifstat, ifbranch));
ifstat.getFirst().removeSuccessor(ifedge); ifstat.getFirst().removeSuccessor(ifedge);
ifstat.getStats().removeWithKey(ifbranch.id); ifstat.getStats().removeWithKey(ifbranch.id);

2
src/org/jetbrains/java/decompiler/modules/decompiler/InlineSingleBlockHelper.java
View File

@ -155,7 +155,7 @@ public class InlineSingleBlockHelper {
Statement from = edge.getSource(); Statement from = edge.getSource();
Statement to = edge.getDestination(); Statement to = edge.getDestination();
for (; ; ) { while (true) {
Statement parent = from.getParent(); Statement parent = from.getParent();
if (parent.containsStatementStrict(to)) { if (parent.containsStatementStrict(to)) {

4
src/org/jetbrains/java/decompiler/modules/decompiler/LabelHelper.java
View File

@ -65,7 +65,7 @@ public class LabelHelper {
List<Statement> lst = new ArrayList<Statement>(); List<Statement> lst = new ArrayList<Statement>();
if (parent.type == Statement.TYPE_SEQUENCE) { if (parent.type == Statement.TYPE_SEQUENCE) {
lst.addAll(((SequenceStatement)parent).getStats()); lst.addAll(parent.getStats());
} }
else if (parent.type == Statement.TYPE_SWITCH) { else if (parent.type == Statement.TYPE_SWITCH) {
lst.addAll(((SwitchStatement)parent).getCaseStatements()); lst.addAll(((SwitchStatement)parent).getCaseStatements());
@ -489,7 +489,7 @@ public class LabelHelper {
private static Statement getMinContinueClosure(StatEdge edge) { private static Statement getMinContinueClosure(StatEdge edge) {
Statement closure = edge.closure; Statement closure = edge.closure;
for (; ; ) { while (true) {
boolean found = false; boolean found = false;

4
src/org/jetbrains/java/decompiler/modules/decompiler/LoopExtractHelper.java
View File

@ -44,7 +44,7 @@ public class LoopExtractHelper {
boolean res = false; boolean res = false;
for (; ; ) { while (true) {
boolean updated = false; boolean updated = false;
@ -183,7 +183,7 @@ public class LoopExtractHelper {
loop.addLabeledEdge(ifedge); loop.addLabeledEdge(ifedge);
SequenceStatement block = new SequenceStatement(Arrays.asList(new Statement[]{loop, target})); SequenceStatement block = new SequenceStatement(Arrays.asList(loop, target));
loop.getParent().replaceStatement(loop, block); loop.getParent().replaceStatement(loop, block);
block.setAllParent(); block.setAllParent();

6
src/org/jetbrains/java/decompiler/modules/decompiler/LowBreakHelper.java
View File

@ -32,7 +32,7 @@ public class LowBreakHelper {
private static void lowBreakLabelsRec(Statement stat) { private static void lowBreakLabelsRec(Statement stat) {
for (; ; ) { while (true) {
boolean found = false; boolean found = false;
@ -79,7 +79,7 @@ public class LowBreakHelper {
public static Statement getMinClosure(Statement closure, Statement source) { public static Statement getMinClosure(Statement closure, Statement source) {
for (; ; ) { while (true) {
Statement newclosure = null; Statement newclosure = null;
@ -152,7 +152,7 @@ public class LowBreakHelper {
} }
for (; ; ) { while (true) {
boolean found = false; boolean found = false;

2
src/org/jetbrains/java/decompiler/modules/decompiler/MergeHelper.java
View File

@ -323,7 +323,7 @@ public class MergeHelper {
// search for an initializing exprent // search for an initializing exprent
Statement current = stat; Statement current = stat;
for (; ; ) { while (true) {
Statement parent = current.getParent(); Statement parent = current.getParent();
if (parent == null) { if (parent == null) {
break; break;

6
src/org/jetbrains/java/decompiler/modules/decompiler/SequenceHelper.java
View File

@ -142,7 +142,7 @@ public class SequenceHelper {
// replace flat statements with synthetic basic blocks // replace flat statements with synthetic basic blocks
outer: outer:
for (; ; ) { while (true) {
for (Statement st : stat.getStats()) { for (Statement st : stat.getStats()) {
if ((st.getStats().isEmpty() || st.getExprents() != null) && st.type != Statement.TYPE_BASICBLOCK) { if ((st.getStats().isEmpty() || st.getExprents() != null) && st.type != Statement.TYPE_BASICBLOCK) {
destroyAndFlattenStatement(st); destroyAndFlattenStatement(st);
@ -185,7 +185,7 @@ public class SequenceHelper {
mergeFlatStatements(sequence); mergeFlatStatements(sequence);
for (; ; ) { while (true) {
boolean found = false; boolean found = false;
@ -242,7 +242,7 @@ public class SequenceHelper {
private static void mergeFlatStatements(SequenceStatement sequence) { private static void mergeFlatStatements(SequenceStatement sequence) {
for (; ; ) { while (true) {
Statement next = null; Statement next = null;
Statement current = null; Statement current = null;

8
src/org/jetbrains/java/decompiler/modules/decompiler/SimplifyExprentsHelper.java
View File

@ -45,7 +45,7 @@ public class SimplifyExprentsHelper {
if (stat.getExprents() == null) { if (stat.getExprents() == null) {
for (; ; ) { while (true) {
boolean changed = false; boolean changed = false;
@ -402,7 +402,7 @@ public class SimplifyExprentsHelper {
AssignmentExprent asf = (AssignmentExprent)first; AssignmentExprent asf = (AssignmentExprent)first;
AssignmentExprent ass = (AssignmentExprent)second; AssignmentExprent ass = (AssignmentExprent)second;
for (; ; ) { while (true) {
if (asf.getRight().equals(ass.getRight())) { if (asf.getRight().equals(ass.getRight())) {
if ((asf.getLeft().type == Exprent.EXPRENT_VAR && ((VarExprent)asf.getLeft()).isStack()) && if ((asf.getLeft().type == Exprent.EXPRENT_VAR && ((VarExprent)asf.getLeft()).isStack()) &&
(ass.getLeft().type != Exprent.EXPRENT_VAR || !((VarExprent)ass.getLeft()).isStack())) { (ass.getLeft().type != Exprent.EXPRENT_VAR || !((VarExprent)ass.getLeft()).isStack())) {
@ -789,7 +789,7 @@ public class SimplifyExprentsHelper {
data.add(new AssignmentExprent(ifvar, new FunctionExprent(FunctionExprent.FUNCTION_IIF, data.add(new AssignmentExprent(ifvar, new FunctionExprent(FunctionExprent.FUNCTION_IIF,
Arrays.asList(new Exprent[]{ Arrays.asList(new Exprent[]{
((IfExprent)stif.getHeadexprent()).getCondition(), stif.getHeadexprent().getCondition(),
ifas.getRight(), ifas.getRight(),
elseas.getRight()})))); elseas.getRight()}))));
stif.setExprents(data); stif.setExprents(data);
@ -830,7 +830,7 @@ public class SimplifyExprentsHelper {
data.add(new ExitExprent(ifex.getExittype(), new FunctionExprent(FunctionExprent.FUNCTION_IIF, data.add(new ExitExprent(ifex.getExittype(), new FunctionExprent(FunctionExprent.FUNCTION_IIF,
Arrays.asList(new Exprent[]{ Arrays.asList(new Exprent[]{
((IfExprent)stif.getHeadexprent()).getCondition(), stif.getHeadexprent().getCondition(),
ifex.getValue(), ifex.getValue(),
elseex.getValue()})), ifex.getRettype())); elseex.getValue()})), ifex.getRettype()));
stif.setExprents(data); stif.setExprents(data);

6
src/org/jetbrains/java/decompiler/modules/decompiler/StackVarsProcessor.java
View File

@ -43,7 +43,7 @@ public class StackVarsProcessor {
SSAUConstructorSparseEx ssau = null; SSAUConstructorSparseEx ssau = null;
for (; ; ) { while (true) {
boolean found = false; boolean found = false;
@ -287,7 +287,7 @@ public class StackVarsProcessor {
int changed = 0; int changed = 0;
for (Exprent expr : exprent.getAllExprents()) { for (Exprent expr : exprent.getAllExprents()) {
for (; ; ) { while (true) {
Object[] arr = iterateChildExprent(expr, exprent, next, mapVarValues, ssau); Object[] arr = iterateChildExprent(expr, exprent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0]; Exprent retexpr = (Exprent)arr[0];
changed |= (Boolean)arr[1] ? 1 : 0; changed |= (Boolean)arr[1] ? 1 : 0;
@ -464,7 +464,7 @@ public class StackVarsProcessor {
boolean changed = false; boolean changed = false;
for (Exprent expr : exprent.getAllExprents()) { for (Exprent expr : exprent.getAllExprents()) {
for (; ; ) { while (true) {
Object[] arr = iterateChildExprent(expr, parent, next, mapVarValues, ssau); Object[] arr = iterateChildExprent(expr, parent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0]; Exprent retexpr = (Exprent)arr[0];
changed |= (Boolean)arr[1]; changed |= (Boolean)arr[1];

2
src/org/jetbrains/java/decompiler/modules/decompiler/decompose/DominatorEngine.java
View File

@ -78,7 +78,7 @@ public class DominatorEngine {
// exclude first statement // exclude first statement
List<Integer> lstIds = colOrderedIDoms.getLstKeys().subList(1, colOrderedIDoms.getLstKeys().size()); List<Integer> lstIds = colOrderedIDoms.getLstKeys().subList(1, colOrderedIDoms.getLstKeys().size());
for (; ; ) { while (true) {
boolean changed = false; boolean changed = false;

4
src/org/jetbrains/java/decompiler/modules/decompiler/decompose/FastExtendedPostdominanceHelper.java
View File

@ -286,7 +286,7 @@ public class FastExtendedPostdominanceHelper {
private void iterateReachability(IReachabilityAction action, int edgetype) { private void iterateReachability(IReachabilityAction action, int edgetype) {
for (; ; ) { while (true) {
boolean iterate = false; boolean iterate = false;
@ -350,6 +350,6 @@ public class FastExtendedPostdominanceHelper {
private interface IReachabilityAction { private interface IReachabilityAction {
public boolean action(Statement node, HashMap<Integer, FastFixedSet<Integer>> mapSets); boolean action(Statement node, HashMap<Integer, FastFixedSet<Integer>> mapSets);
} }
} }

2
src/org/jetbrains/java/decompiler/modules/decompiler/decompose/GenericDominatorEngine.java
View File

@ -91,7 +91,7 @@ public class GenericDominatorEngine {
List<IGraphNode> lstNodes = colOrderedIDoms.getLstKeys(); List<IGraphNode> lstNodes = colOrderedIDoms.getLstKeys();
for (; ; ) { while (true) {
boolean changed = false; boolean changed = false;

4
src/org/jetbrains/java/decompiler/modules/decompiler/decompose/IGraph.java
View File

@ -20,7 +20,7 @@ import java.util.Set;
public interface IGraph { public interface IGraph {
public List<? extends IGraphNode> getReversePostOrderList(); List<? extends IGraphNode> getReversePostOrderList();
public Set<? extends IGraphNode> getRoots(); Set<? extends IGraphNode> getRoots();
} }

2
src/org/jetbrains/java/decompiler/modules/decompiler/decompose/IGraphNode.java
View File

@ -19,5 +19,5 @@ import java.util.List;
public interface IGraphNode { public interface IGraphNode {
public List<? extends IGraphNode> getPredecessors(); List<? extends IGraphNode> getPredecessors();
} }

2
src/org/jetbrains/java/decompiler/modules/decompiler/deobfuscator/IrreducibleCFGDeobfuscator.java
View File

@ -63,7 +63,7 @@ public class IrreducibleCFGDeobfuscator {
} }
// transforming and reducing the graph // transforming and reducing the graph
for (; ; ) { while (true) {
int ttype = 0; int ttype = 0;
Node node = null; Node node = null;

2
src/org/jetbrains/java/decompiler/modules/decompiler/exps/Exprent.java
View File

@ -108,7 +108,7 @@ public class Exprent {
lstAllExprents.add(this); lstAllExprents.add(this);
for (Exprent expr : lstAllExprents) { for (Exprent expr : lstAllExprents) {
if (expr.type == Exprent.EXPRENT_VAR) { if (expr.type == EXPRENT_VAR) {
set.add(new VarVersionPaar((VarExprent)expr)); set.add(new VarVersionPaar((VarExprent)expr));
} }
} }

5
src/org/jetbrains/java/decompiler/modules/decompiler/exps/FunctionExprent.java
View File

@ -292,10 +292,7 @@ public class FunctionExprent extends Exprent {
else if (functype == FUNCTION_STRCONCAT) { else if (functype == FUNCTION_STRCONCAT) {
exprType = VarType.VARTYPE_STRING; exprType = VarType.VARTYPE_STRING;
} }
else if (functype >= FUNCTION_EQ) { else if (functype >= FUNCTION_EQ || functype == FUNCTION_INSTANCEOF) {
exprType = VarType.VARTYPE_BOOLEAN;
}
else if (functype == FUNCTION_INSTANCEOF) {
exprType = VarType.VARTYPE_BOOLEAN; exprType = VarType.VARTYPE_BOOLEAN;
} }
else if (functype >= FUNCTION_ARRAYLENGTH) { else if (functype >= FUNCTION_ARRAYLENGTH) {

2
src/org/jetbrains/java/decompiler/modules/decompiler/exps/VarExprent.java
View File

@ -43,7 +43,6 @@ public class VarExprent extends Exprent {
private VarType vartype; private VarType vartype;
private boolean definition = false; private boolean definition = false;
;
private VarProcessor processor; private VarProcessor processor;
@ -52,7 +51,6 @@ public class VarExprent extends Exprent {
private boolean classdef = false; private boolean classdef = false;
private boolean stack = false; private boolean stack = false;
;
{ {
this.type = EXPRENT_VAR; this.type = EXPRENT_VAR;

2
src/org/jetbrains/java/decompiler/modules/decompiler/sforms/DirectGraph.java
View File

@ -131,6 +131,6 @@ public class DirectGraph {
// 0 - success, do nothing // 0 - success, do nothing
// 1 - cancel iteration // 1 - cancel iteration
// 2 - success, delete exprent // 2 - success, delete exprent
public int processExprent(Exprent exprent); int processExprent(Exprent exprent);
} }
} }

2
src/org/jetbrains/java/decompiler/modules/decompiler/sforms/FlattenStatementsHelper.java
View File

@ -321,7 +321,7 @@ public class FlattenStatementsHelper {
boolean isFinallyExit = false; boolean isFinallyExit = false;
for (; ; ) { while (true) {
StackEntry entry = null; StackEntry entry = null;
if (!stack.isEmpty()) { if (!stack.isEmpty()) {

2
src/org/jetbrains/java/decompiler/modules/decompiler/sforms/SSAUConstructorSparseEx.java
View File

@ -791,7 +791,7 @@ public class SSAUConstructorSparseEx {
private Integer getFirstProtectedRange(Statement stat) { private Integer getFirstProtectedRange(Statement stat) {
for (; ; ) { while (true) {
Statement parent = stat.getParent(); Statement parent = stat.getParent();
if (parent == null) { if (parent == null) {

4
src/org/jetbrains/java/decompiler/modules/decompiler/stats/CatchAllStatement.java
View File

@ -49,8 +49,6 @@ public class CatchAllStatement extends Statement {
type = Statement.TYPE_CATCHALL; type = Statement.TYPE_CATCHALL;
} }
;
private CatchAllStatement(Statement head, Statement handler) { private CatchAllStatement(Statement head, Statement handler) {
this(); this();
@ -102,7 +100,7 @@ public class CatchAllStatement extends Statement {
return null; return null;
} }
if (DecHelper.checkStatementExceptions(Arrays.asList(new Statement[]{head, exc}))) { if (DecHelper.checkStatementExceptions(Arrays.asList(head, exc))) {
return new CatchAllStatement(head, exc); return new CatchAllStatement(head, exc);
} }
} }

4
src/org/jetbrains/java/decompiler/modules/decompiler/stats/SequenceStatement.java
View File

@ -51,7 +51,7 @@ public class SequenceStatement extends Statement {
private SequenceStatement(Statement head, Statement tail) { private SequenceStatement(Statement head, Statement tail) {
this(Arrays.asList(new Statement[]{head, tail})); this(Arrays.asList(head, tail));
List<StatEdge> lstSuccs = tail.getSuccessorEdges(STATEDGE_DIRECT_ALL); List<StatEdge> lstSuccs = tail.getSuccessorEdges(STATEDGE_DIRECT_ALL);
if (!lstSuccs.isEmpty()) { if (!lstSuccs.isEmpty()) {
@ -88,7 +88,7 @@ public class SequenceStatement extends Statement {
&& !stat.isMonitorEnter()) { && !stat.isMonitorEnter()) {
if (stat.getLastBasicType() == Statement.LASTBASICTYPE_GENERAL) { if (stat.getLastBasicType() == Statement.LASTBASICTYPE_GENERAL) {
if (DecHelper.checkStatementExceptions(Arrays.asList(new Statement[]{head, stat}))) { if (DecHelper.checkStatementExceptions(Arrays.asList(head, stat))) {
return new SequenceStatement(head, stat); return new SequenceStatement(head, stat);
} }
} }

18
src/org/jetbrains/java/decompiler/modules/decompiler/stats/Statement.java
View File

@ -124,7 +124,6 @@ public class Statement {
// FIXME: used in FlattenStatementsHelper.flattenStatement()! check and remove // FIXME: used in FlattenStatementsHelper.flattenStatement()! check and remove
//lastBasicType = LASTBASICTYPE_GENERAL; //lastBasicType = LASTBASICTYPE_GENERAL;
isMonitorEnter = false; isMonitorEnter = false;
;
containsMonitorExit = false; containsMonitorExit = false;
for (Map<Integer, List<StatEdge>> map : new Map[]{mapSuccEdges, mapPredEdges}) { for (Map<Integer, List<StatEdge>> map : new Map[]{mapSuccEdges, mapPredEdges}) {
@ -234,7 +233,7 @@ public class Statement {
// monitorenter and monitorexit // monitorenter and monitorexit
stat.buildMonitorFlags(); stat.buildMonitorFlags();
if (stat.type == Statement.TYPE_SWITCH) { if (stat.type == TYPE_SWITCH) {
// special case switch, sorting leaf nodes // special case switch, sorting leaf nodes
((SwitchStatement)stat).sortEdgesAndNodes(); ((SwitchStatement)stat).sortEdgesAndNodes();
} }
@ -390,7 +389,7 @@ public class Statement {
continueSet.add(edge.getDestination().getBasichead()); continueSet.add(edge.getDestination().getBasichead());
} }
if (type == Statement.TYPE_DO) { if (type == TYPE_DO) {
continueSet.remove(first.getBasichead()); continueSet.remove(first.getBasichead());
} }
@ -513,11 +512,11 @@ public class Statement {
} }
public void initExprents() { public void initExprents() {
; // do nothing // do nothing
} }
public void replaceExprent(Exprent oldexpr, Exprent newexpr) { public void replaceExprent(Exprent oldexpr, Exprent newexpr) {
; // do nothing // do nothing
} }
public Statement getSimpleCopy() { public Statement getSimpleCopy() {
@ -804,7 +803,7 @@ public class Statement {
} }
public BasicBlockStatement getBasichead() { public BasicBlockStatement getBasichead() {
if (type == Statement.TYPE_BASICBLOCK) { if (type == TYPE_BASICBLOCK) {
return (BasicBlockStatement)this; return (BasicBlockStatement)this;
} }
else { else {
@ -823,13 +822,12 @@ public class Statement {
} }
public boolean hasBasicSuccEdge() { public boolean hasBasicSuccEdge() {
boolean res = type == Statement.TYPE_BASICBLOCK || (type == Statement.TYPE_IF &&
((IfStatement)this).iftype == IfStatement.IFTYPE_IF) ||
(type == Statement.TYPE_DO && ((DoStatement)this).getLooptype() != DoStatement.LOOP_DO);
// FIXME: default switch // FIXME: default switch
return res; return type == TYPE_BASICBLOCK || (type == TYPE_IF &&
((IfStatement)this).iftype == IfStatement.IFTYPE_IF) ||
(type == TYPE_DO && ((DoStatement)this).getLooptype() != DoStatement.LOOP_DO);
} }

2
src/org/jetbrains/java/decompiler/modules/decompiler/vars/VarDefinitionHelper.java
View File

@ -148,7 +148,7 @@ public class VarDefinitionHelper {
continue; continue;
} }
else { else {
List<Exprent> lstSpecial = Arrays.asList(new Exprent[]{dstat.getConditionExprent(), dstat.getIncExprent()}); List<Exprent> lstSpecial = Arrays.asList(dstat.getConditionExprent(), dstat.getIncExprent());
for (VarExprent var : getAllVars(lstSpecial)) { for (VarExprent var : getAllVars(lstSpecial)) {
if (var.getIndex() == index.intValue()) { if (var.getIndex() == index.intValue()) {
stat = stat.getParent(); stat = stat.getParent();

2
src/org/jetbrains/java/decompiler/modules/renamer/IdentifierConverter.java
View File

@ -56,7 +56,7 @@ public class IdentifierConverter {
helper = (IIdentifierRenamer)IdentifierConverter.class.getClassLoader().loadClass(user_class).newInstance(); helper = (IIdentifierRenamer)IdentifierConverter.class.getClassLoader().loadClass(user_class).newInstance();
} }
catch (Exception ex) { catch (Exception ex) {
; // ignore errors // ignore errors
} }
} }

4
src/org/jetbrains/java/decompiler/struct/IDecompiledData.java
View File

@ -17,7 +17,7 @@ package org.jetbrains.java.decompiler.struct;
public interface IDecompiledData { public interface IDecompiledData {
public String getClassEntryName(StructClass cl, String entryname); String getClassEntryName(StructClass cl, String entryname);
public String getClassContent(StructClass cl); String getClassContent(StructClass cl);
} }

6
src/org/jetbrains/java/decompiler/struct/ISaveClass.java
View File

@ -22,9 +22,9 @@ import java.io.IOException;
public interface ISaveClass { public interface ISaveClass {
public String getClassEntryName(StructClass cl, String entryname); String getClassEntryName(StructClass cl, String entryname);
public void saveClassToFile(StructClass cl, File file) throws FileNotFoundException, IOException; void saveClassToFile(StructClass cl, File file) throws FileNotFoundException, IOException;
public void saveClassToStream(StructClass cl, DataOutputStream out); void saveClassToStream(StructClass cl, DataOutputStream out);
} }

4
src/org/jetbrains/java/decompiler/struct/StructContext.java
View File

@ -41,8 +41,6 @@ public class StructContext {
private HashMap<String, ContextUnit> units = new HashMap<String, ContextUnit>(); private HashMap<String, ContextUnit> units = new HashMap<String, ContextUnit>();
private ContextUnit defaultUnit;
private IDecompilatSaver saver; private IDecompilatSaver saver;
private IDecompiledData decdata; private IDecompiledData decdata;
@ -53,7 +51,7 @@ public class StructContext {
this.decdata = decdata; this.decdata = decdata;
this.loader = loader; this.loader = loader;
defaultUnit = new ContextUnit(ContextUnit.TYPE_FOLDER, null, "", true, saver, decdata); ContextUnit defaultUnit = new ContextUnit(ContextUnit.TYPE_FOLDER, null, "", true, saver, decdata);
units.put("", defaultUnit); units.put("", defaultUnit);
} }

7
src/org/jetbrains/java/decompiler/struct/StructMethod.java
View File

@ -78,8 +78,6 @@ public class StructMethod implements CodeConstants {
private boolean containsCode = false; private boolean containsCode = false;
private boolean own;
private StructClass classStruct; private StructClass classStruct;
@ -104,7 +102,6 @@ public class StructMethod implements CodeConstants {
public StructMethod(DataInputFullStream in, boolean lazy, boolean own, StructClass clstruct) throws IOException { public StructMethod(DataInputFullStream in, boolean lazy, boolean own, StructClass clstruct) throws IOException {
this.own = own;
this.lazy = lazy; this.lazy = lazy;
this.expanded = !lazy; this.expanded = !lazy;
this.classStruct = clstruct; this.classStruct = clstruct;
@ -125,7 +122,7 @@ public class StructMethod implements CodeConstants {
String attrname = pool.getPrimitiveConstant(attr_nameindex).getString(); String attrname = pool.getPrimitiveConstant(attr_nameindex).getString();
if (StructGeneralAttribute.ATTRIBUTE_CODE.equals(attrname)) { if (StructGeneralAttribute.ATTRIBUTE_CODE.equals(attrname)) {
if (!this.own) { if (!own) {
// skip code in foreign classes // skip code in foreign classes
in.skip(8); in.skip(8);
in.skip(in.readInt()); in.skip(in.readInt());
@ -478,7 +475,7 @@ public class StructMethod implements CodeConstants {
int[] ops = new int[operands.size()]; int[] ops = new int[operands.size()];
for (int j = 0; j < operands.size(); j++) { for (int j = 0; j < operands.size(); j++) {
ops[j] = ((Integer)operands.get(j)).intValue(); ops[j] = operands.get(j).intValue();
} }
Instruction instr = ConstantsUtil.getInstructionInstance(opcode, wide, group, bytecode_version, ops); Instruction instr = ConstantsUtil.getInstructionInstance(opcode, wide, group, bytecode_version, ops);

4
src/org/jetbrains/java/decompiler/struct/attr/StructExceptionsAttribute.java
View File

@ -51,7 +51,7 @@ public class StructExceptionsAttribute extends StructGeneralAttribute {
if (len > 0) { if (len > 0) {
info = new byte[len * 2]; info = new byte[len * 2];
for (int i = 0, j = 0; i < len; i++, j += 2) { for (int i = 0, j = 0; i < len; i++, j += 2) {
int index = ((Integer)throwsExceptions.get(i)).intValue(); int index = throwsExceptions.get(i).intValue();
info[j] = (byte)(index >> 8); info[j] = (byte)(index >> 8);
info[j + 1] = (byte)(index & 0xFF); info[j + 1] = (byte)(index & 0xFF);
} }
@ -63,7 +63,7 @@ public class StructExceptionsAttribute extends StructGeneralAttribute {
} }
public String getExcClassname(int index, ConstantPool pool) { public String getExcClassname(int index, ConstantPool pool) {
return pool.getPrimitiveConstant(((Integer)throwsExceptions.get(index)).intValue()).getString(); return pool.getPrimitiveConstant(throwsExceptions.get(index).intValue()).getString();
} }
public List<Integer> getThrowsExceptions() { public List<Integer> getThrowsExceptions() {

2
src/org/jetbrains/java/decompiler/struct/consts/ConstantPool.java
View File

@ -129,7 +129,7 @@ public class ConstantPool {
out.writeShort(pool.size()); out.writeShort(pool.size());
for (int i = 1; i < pool.size(); i++) { for (int i = 1; i < pool.size(); i++) {
PooledConstant cnst = (PooledConstant)pool.get(i); PooledConstant cnst = pool.get(i);
if (cnst != null) { if (cnst != null) {
cnst.writeToStream(out); cnst.writeToStream(out);
} }

1
src/org/jetbrains/java/decompiler/struct/consts/LinkConstant.java
View File

@ -40,7 +40,6 @@ public class LinkConstant extends PooledConstant {
public int paramCount = 0; public int paramCount = 0;
public boolean isVoid = false; public boolean isVoid = false;
;
public boolean returnCategory2 = false; public boolean returnCategory2 = false;

52
src/org/jetbrains/java/decompiler/struct/consts/VariableTypeEnum.java
View File

@ -17,31 +17,31 @@ package org.jetbrains.java.decompiler.struct.consts;
public interface VariableTypeEnum { public interface VariableTypeEnum {
public final static int BOOLEAN = 1; int BOOLEAN = 1;
public final static int BYTE = 2; int BYTE = 2;
public final static int CHAR = 3; int CHAR = 3;
public final static int SHORT = 4; int SHORT = 4;
public final static int INT = 5; int INT = 5;
public final static int FLOAT = 6; int FLOAT = 6;
public final static int LONG = 7; int LONG = 7;
public final static int DOUBLE = 8; int DOUBLE = 8;
public final static int RETURN_ADDRESS = 9; int RETURN_ADDRESS = 9;
public final static int REFERENCE = 10; int REFERENCE = 10;
public final static int INSTANCE_UNINITIALIZED = 11; int INSTANCE_UNINITIALIZED = 11;
public final static int VALUE_UNKNOWN = 12; int VALUE_UNKNOWN = 12;
public final static int VOID = 13; int VOID = 13;
public final static Integer BOOLEAN_OBJ = new Integer(BOOLEAN); Integer BOOLEAN_OBJ = new Integer(BOOLEAN);
public final static Integer BYTE_OBJ = new Integer(BYTE); Integer BYTE_OBJ = new Integer(BYTE);
public final static Integer CHAR_OBJ = new Integer(CHAR); Integer CHAR_OBJ = new Integer(CHAR);
public final static Integer SHORT_OBJ = new Integer(SHORT); Integer SHORT_OBJ = new Integer(SHORT);
public final static Integer INT_OBJ = new Integer(INT); Integer INT_OBJ = new Integer(INT);
public final static Integer FLOAT_OBJ = new Integer(FLOAT); Integer FLOAT_OBJ = new Integer(FLOAT);
public final static Integer LONG_OBJ = new Integer(LONG); Integer LONG_OBJ = new Integer(LONG);
public final static Integer DOUBLE_OBJ = new Integer(DOUBLE); Integer DOUBLE_OBJ = new Integer(DOUBLE);
public final static Integer RETURN_ADDRESS_OBJ = new Integer(RETURN_ADDRESS); Integer RETURN_ADDRESS_OBJ = new Integer(RETURN_ADDRESS);
public final static Integer REFERENCE_OBJ = new Integer(REFERENCE); Integer REFERENCE_OBJ = new Integer(REFERENCE);
public final static Integer INSTANCE_UNINITIALIZED_OBJ = new Integer(INSTANCE_UNINITIALIZED); Integer INSTANCE_UNINITIALIZED_OBJ = new Integer(INSTANCE_UNINITIALIZED);
public final static Integer VALUE_UNKNOWN_OBJ = new Integer(VALUE_UNKNOWN); Integer VALUE_UNKNOWN_OBJ = new Integer(VALUE_UNKNOWN);
public final static Integer VOID_OBJ = new Integer(VOID); Integer VOID_OBJ = new Integer(VOID);
} }

8
src/org/jetbrains/java/decompiler/struct/gen/FieldDescriptor.java
View File

@ -17,10 +17,10 @@ package org.jetbrains.java.decompiler.struct.gen;
public class FieldDescriptor { public class FieldDescriptor {
public static final FieldDescriptor INTEGER_DESCRIPTOR = FieldDescriptor.parseDescriptor("Ljava/lang/Integer;"); public static final FieldDescriptor INTEGER_DESCRIPTOR = parseDescriptor("Ljava/lang/Integer;");
public static final FieldDescriptor LONG_DESCRIPTOR = FieldDescriptor.parseDescriptor("Ljava/lang/Long;"); public static final FieldDescriptor LONG_DESCRIPTOR = parseDescriptor("Ljava/lang/Long;");
public static final FieldDescriptor FLOAT_DESCRIPTOR = FieldDescriptor.parseDescriptor("Ljava/lang/Float;"); public static final FieldDescriptor FLOAT_DESCRIPTOR = parseDescriptor("Ljava/lang/Float;");
public static final FieldDescriptor DOUBLE_DESCRIPTOR = FieldDescriptor.parseDescriptor("Ljava/lang/Double;"); public static final FieldDescriptor DOUBLE_DESCRIPTOR = parseDescriptor("Ljava/lang/Double;");
public VarType type; public VarType type;

28
src/org/jetbrains/java/decompiler/struct/gen/VarType.java
View File

@ -119,7 +119,7 @@ public class VarType { // TODO: optimize switch
} }
public boolean isFalseBoolean() { public boolean isFalseBoolean() {
return (convinfo & VarType.FALSEBOOLEAN) != 0; return (convinfo & FALSEBOOLEAN) != 0;
} }
public boolean isSuperset(VarType val) { public boolean isSuperset(VarType val) {
@ -189,13 +189,13 @@ public class VarType { // TODO: optimize switch
case CodeConstants.TYPE_FAMILY_INTEGER: case CodeConstants.TYPE_FAMILY_INTEGER:
if ((type1.type == CodeConstants.TYPE_CHAR && type2.type == CodeConstants.TYPE_SHORT) if ((type1.type == CodeConstants.TYPE_CHAR && type2.type == CodeConstants.TYPE_SHORT)
|| (type1.type == CodeConstants.TYPE_SHORT && type2.type == CodeConstants.TYPE_CHAR)) { || (type1.type == CodeConstants.TYPE_SHORT && type2.type == CodeConstants.TYPE_CHAR)) {
return VarType.VARTYPE_SHORTCHAR; return VARTYPE_SHORTCHAR;
} }
else { else {
return VarType.VARTYPE_BYTECHAR; return VARTYPE_BYTECHAR;
} }
case CodeConstants.TYPE_FAMILY_OBJECT: case CodeConstants.TYPE_FAMILY_OBJECT:
return VarType.VARTYPE_NULL; return VARTYPE_NULL;
} }
} }
@ -220,13 +220,13 @@ public class VarType { // TODO: optimize switch
case CodeConstants.TYPE_FAMILY_INTEGER: case CodeConstants.TYPE_FAMILY_INTEGER:
if ((type1.type == CodeConstants.TYPE_SHORTCHAR && type2.type == CodeConstants.TYPE_BYTE) if ((type1.type == CodeConstants.TYPE_SHORTCHAR && type2.type == CodeConstants.TYPE_BYTE)
|| (type1.type == CodeConstants.TYPE_BYTE && type2.type == CodeConstants.TYPE_SHORTCHAR)) { || (type1.type == CodeConstants.TYPE_BYTE && type2.type == CodeConstants.TYPE_SHORTCHAR)) {
return VarType.VARTYPE_SHORT; return VARTYPE_SHORT;
} }
else { else {
return VarType.VARTYPE_INT; return VARTYPE_INT;
} }
case CodeConstants.TYPE_FAMILY_OBJECT: case CodeConstants.TYPE_FAMILY_OBJECT:
return VarType.VARTYPE_OBJECT; return VARTYPE_OBJECT;
} }
} }
@ -236,19 +236,19 @@ public class VarType { // TODO: optimize switch
public static VarType getMinTypeInFamily(int family) { public static VarType getMinTypeInFamily(int family) {
switch (family) { switch (family) {
case CodeConstants.TYPE_FAMILY_BOOLEAN: case CodeConstants.TYPE_FAMILY_BOOLEAN:
return VarType.VARTYPE_BOOLEAN; return VARTYPE_BOOLEAN;
case CodeConstants.TYPE_FAMILY_INTEGER: case CodeConstants.TYPE_FAMILY_INTEGER:
return VarType.VARTYPE_BYTECHAR; return VARTYPE_BYTECHAR;
case CodeConstants.TYPE_FAMILY_OBJECT: case CodeConstants.TYPE_FAMILY_OBJECT:
return VarType.VARTYPE_NULL; return VARTYPE_NULL;
case CodeConstants.TYPE_FAMILY_FLOAT: case CodeConstants.TYPE_FAMILY_FLOAT:
return VarType.VARTYPE_FLOAT; return VARTYPE_FLOAT;
case CodeConstants.TYPE_FAMILY_LONG: case CodeConstants.TYPE_FAMILY_LONG:
return VarType.VARTYPE_LONG; return VARTYPE_LONG;
case CodeConstants.TYPE_FAMILY_DOUBLE: case CodeConstants.TYPE_FAMILY_DOUBLE:
return VarType.VARTYPE_DOUBLE; return VARTYPE_DOUBLE;
case CodeConstants.TYPE_FAMILY_UNKNOWN: case CodeConstants.TYPE_FAMILY_UNKNOWN:
return VarType.VARTYPE_UNKNOWN; return VARTYPE_UNKNOWN;
default: default:
throw new RuntimeException("invalid type family!"); throw new RuntimeException("invalid type family!");
} }

4
src/org/jetbrains/java/decompiler/struct/gen/generics/GenericMain.java
View File

@ -127,7 +127,7 @@ public class GenericMain {
List<GenericType> lstBounds = new ArrayList<GenericType>(); List<GenericType> lstBounds = new ArrayList<GenericType>();
for (; ; ) { while (true) {
if (value.charAt(0) == ':') { if (value.charAt(0) == ':') {
// empty superclass, skip // empty superclass, skip
value = value.substring(1); value = value.substring(1);
@ -199,7 +199,7 @@ public class GenericMain {
GenericType genpar = type.getArguments().get(i); GenericType genpar = type.getArguments().get(i);
if (genpar != null) { if (genpar != null) {
buffer.append(GenericMain.getGenericCastTypeName(genpar)); buffer.append(getGenericCastTypeName(genpar));
} }
} }
buffer.append(">"); buffer.append(">");

2
src/org/jetbrains/java/decompiler/struct/gen/generics/GenericType.java
View File

@ -70,7 +70,7 @@ public class GenericType {
type = CodeConstants.TYPE_OBJECT; type = CodeConstants.TYPE_OBJECT;
sig = sig.substring(index + 1, sig.length() - 1); sig = sig.substring(index + 1, sig.length() - 1);
for (; ; ) { while (true) {
String cl = getNextClassSignature(sig); String cl = getNextClassSignature(sig);
String name = cl; String name = cl;

2
src/org/jetbrains/java/decompiler/struct/lazy/LazyLoader.java
View File

@ -109,7 +109,7 @@ public class LazyLoader {
int name_index = in.readUnsignedShort(); int name_index = in.readUnsignedShort();
int descriptor_index = in.readUnsignedShort(); int descriptor_index = in.readUnsignedShort();
String elem_arr[] = pool.getClassElement(ConstantPool.METHOD, this_class, name_index, descriptor_index); String[] elem_arr = pool.getClassElement(ConstantPool.METHOD, this_class, name_index, descriptor_index);
String name = elem_arr[0]; String name = elem_arr[0];
if (mt.getName().equals(name)) { if (mt.getName().equals(name)) {

4
src/org/jetbrains/java/decompiler/util/DataInputFullStream.java
View File

@ -25,14 +25,14 @@ public class DataInputFullStream extends DataInputStream {
super(in); super(in);
} }
public final int readFull(byte b[]) throws IOException { public final int readFull(byte[] b) throws IOException {
int length = b.length; int length = b.length;
byte[] btemp = new byte[length]; byte[] btemp = new byte[length];
int pos = 0; int pos = 0;
int bytes_read = -1; int bytes_read = -1;
for (; ; ) { while (true) {
bytes_read = read(btemp, 0, length - pos); bytes_read = read(btemp, 0, length - pos);
if (bytes_read == -1) { if (bytes_read == -1) {
return -1; return -1;

4
src/org/jetbrains/java/decompiler/util/FastSparseSetFactory.java
View File

@ -122,9 +122,7 @@ public class FastSparseSetFactory<E> {
System.arraycopy(data, 0, cpdata, 0, arrlength); System.arraycopy(data, 0, cpdata, 0, arrlength);
System.arraycopy(next, 0, cpnext, 0, arrlength); System.arraycopy(next, 0, cpnext, 0, arrlength);
FastSparseSet<E> copy = new FastSparseSet<E>(factory, cpdata, cpnext); return new FastSparseSet<E>(factory, cpdata, cpnext);
return copy;
} }
private int[] ensureCapacity(int index) { private int[] ensureCapacity(int index) {

25
src/org/jetbrains/java/decompiler/util/InterpreterUtil.java
View File

@ -27,9 +27,12 @@ import java.util.List;
public class InterpreterUtil { public class InterpreterUtil {
public static void copyFile(File in, File out) throws IOException { public static void copyFile(File in, File out) throws IOException {
FileChannel inChannel = new FileInputStream(in).getChannel(); FileInputStream inStream = new FileInputStream(in);
FileChannel outChannel = new FileOutputStream(out).getChannel();
try { try {
FileOutputStream outStream = new FileOutputStream(out);
try {
FileChannel inChannel = inStream.getChannel();
FileChannel outChannel = outStream.getChannel();
// magic number for Windows, 64Mb - 32Kb) // magic number for Windows, 64Mb - 32Kb)
int maxCount = (64 * 1024 * 1024) - (32 * 1024); int maxCount = (64 * 1024 * 1024) - (32 * 1024);
long size = inChannel.size(); long size = inChannel.size();
@ -38,16 +41,12 @@ public class InterpreterUtil {
position += inChannel.transferTo(position, maxCount, outChannel); position += inChannel.transferTo(position, maxCount, outChannel);
} }
} }
catch (IOException e) { finally {
throw e; outStream.close();
}
} }
finally { finally {
if (inChannel != null) { inStream.close();
inChannel.close();
}
if (outChannel != null) {
outChannel.close();
}
} }
} }
@ -74,13 +73,11 @@ public class InterpreterUtil {
public static boolean equalSets(Collection<?> c1, Collection<?> c2) { public static boolean equalSets(Collection<?> c1, Collection<?> c2) {
if (c1 == null) { if (c1 == null) {
return c2 == null ? true : false; return c2 == null;
} }
else { else if (c2 == null) {
if (c2 == null) {
return false; return false;
} }
}
if (c1.size() != c2.size()) { if (c1.size() != c2.size()) {
return false; return false;

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

@ -243,9 +243,9 @@ public class SFormsFastMap<E> {
return arrnew; return arrnew;
} }
public static interface IElementsUnion<E> { public interface IElementsUnion<E> {
public E union(E first, E second); E union(E first, E second);
public E copy(E element); E copy(E element);
} }
} }

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

@ -217,10 +217,10 @@ public class SFormsFastMapOld<E> {
} }
} }
public static interface IElementsUnion<E> { public interface IElementsUnion<E> {
public E union(E first, E second); E union(E first, E second);
public E copy(E element); E copy(E element);
} }
// public class SFormsFastMapIterator implements Iterator<Entry<Integer, E>> { // public class SFormsFastMapIterator implements Iterator<Entry<Integer, E>> {

2
src/org/jetbrains/java/decompiler/util/VBStyleCollection.java
View File

@ -106,7 +106,7 @@ public class VBStyleCollection<E, K> extends ArrayList<E> {
} }
public void removeWithKey(K key) { public void removeWithKey(K key) {
int index = ((Integer)map.get(key)).intValue(); int index = map.get(key).intValue();
addToListIndex(index + 1, -1); addToListIndex(index + 1, -1);
super.remove(index); super.remove(index);
lstKeys.remove(index); lstKeys.remove(index);