com.googlecode.d2j.visitors.DexCodeVisitor java code examples

    .visitMethod(DexConstants.ACC_PUBLIC, new Method(typeNameDesc, methodName, new String[0], "Ljava/lang/String;"));
DexCodeVisitor code = dmv.visitCode();
code.visitRegister(3);
code.visitFieldStmt(Op.IGET, 0, 2, new Field(typeNameDesc, "idx", "I"));
code.visitPackedSwitchStmt(Op.PACKED_SWITCH, 0, 0, labels);
code.visitTypeStmt(Op.NEW_INSTANCE, 0, 0, "Ljava/lang/RuntimeException;");
code.visitConstStmt(Op.CONST_STRING, 1, "invalid idx");
code.visitMethodStmt(Op.INVOKE_DIRECT, new int[]{0,
    1}, new Method("Ljava/lang/RuntimeException;", "<init>", new String[]{"Ljava/lang/String;"}, "V"));
code.visitStmt1R(Op.THROW, 0);
  code.visitLabel(e.getValue());
  code.visitConstStmt(Op.CONST_STRING, 0, e.getKey());
  code.visitStmt1R(Op.RETURN_OBJECT, 0);
code.visitEnd();
dmv.visitEnd();

/**
 * 
 * {@link Op#RETURN_VOID} {@link Op#NOP} {@link Op#BAD_OP}
 * 
 * @param op
 */
public void visitStmt0R(Op op) {
  if (visitor != null) {
    visitor.visitStmt0R(op);
  }
}

case 'L':
case '[':
  dcv.visitStmt2R(Op.MOVE_OBJECT, from, to);
  break;
case 'Z':
  dcv.visitMethodStmt(Op.INVOKE_STATIC_RANGE, new int[]{
      from}, new Method("Ljava/lang/Boolean;", "valueOf", new String[]{"Z"}, "Ljava/lang/Boolean;"));
  dcv.visitStmt1R(Op.MOVE_RESULT_OBJECT, to);
  break;
case 'B':
  dcv.visitMethodStmt(Op.INVOKE_STATIC_RANGE, new int[]{
      from}, new Method("Ljava/lang/Byte;", "valueOf", new String[]{"B"}, "Ljava/lang/Byte;"));
  dcv.visitStmt1R(Op.MOVE_RESULT_OBJECT, to);
  break;
case 'S':
  dcv.visitMethodStmt(Op.INVOKE_STATIC_RANGE, new int[]{
      from}, new Method("Ljava/lang/Short;", "valueOf", new String[]{"S"}, "Ljava/lang/Short;"));
  dcv.visitStmt1R(Op.MOVE_RESULT_OBJECT, to);
  break;
case 'C':
  dcv.visitMethodStmt(Op.INVOKE_STATIC_RANGE, new int[]{
      from}, new Method("Ljava/lang/Character;", "valueOf", new String[]{
      "C"}, "Ljava/lang/Character;"));
  dcv.visitStmt1R(Op.MOVE_RESULT_OBJECT, to);
  break;
case 'I':
  dcv.visitMethodStmt(Op.INVOKE_STATIC_RANGE, new int[]{
      from}, new Method("Ljava/lang/Integer;", "valueOf", new String[]{"I"}, "Ljava/lang/Integer;"));
  dcv.visitStmt1R(Op.MOVE_RESULT_OBJECT, to);

case '[':
case 'L':
  dcv.visitTypeStmt(Op.CHECK_CAST, i, i, argType);
  break;
case 'Z':
  dcv.visitTypeStmt(Op.CHECK_CAST, i, i, "Ljava/lang/Boolean;");
  dcv.visitMethodStmt(Op.INVOKE_VIRTUAL_RANGE, new int[]{
      i}, new Method("Ljava/lang/Boolean;", "booleanValue", new String[]{}, "Z"));
  dcv.visitStmt1R(Op.MOVE_RESULT, i);
  break;
case 'B':
  dcv.visitTypeStmt(Op.CHECK_CAST, i, i, "Ljava/lang/Byte;");
  dcv.visitMethodStmt(Op.INVOKE_VIRTUAL_RANGE, new int[]{
      i}, new Method("Ljava/lang/Byte;", "byteValue", new String[]{}, "B"));
  dcv.visitStmt1R(Op.MOVE_RESULT, i);
  break;
case 'S':
  dcv.visitTypeStmt(Op.CHECK_CAST, i, i, "Ljava/lang/Short;");
  dcv.visitMethodStmt(Op.INVOKE_VIRTUAL_RANGE, new int[]{
      i}, new Method("Ljava/lang/Short;", "shortValue", new String[]{}, "S"));
  dcv.visitStmt1R(Op.MOVE_RESULT, i);
  break;
case 'C':
  dcv.visitTypeStmt(Op.CHECK_CAST, i, i, "Ljava/lang/Character;");
  dcv.visitMethodStmt(Op.INVOKE_VIRTUAL_RANGE, new int[]{
      i}, new Method("Ljava/lang/Character;", "charValue", new String[]{}, "C"));
  dcv.visitStmt1R(Op.MOVE_RESULT, i);
  break;
case 'I':

    dcv.visitLabel(labelsMap.get(nextLabelOffset));
    nextLabelOffset = labelOffsetIterator.hasNext() ? labelOffsetIterator.next() : null;
  } else {
  dcv.visitStmt0R(Op.BAD_OP);
  continue;
  dcv.visitStmt0R(op);
  break;
  dcv.visitStmt1R(op, 0xFF & insns[u1offset + 1]);
  break;
case kFmt12x:
  a = ubyte(insns, u1offset + 1);
  dcv.visitStmt2R(op, a & 0xF, a >> 4);
  break;
  dcv.visitJumpStmt(op, -1, -1, labelsMap.get(target));
  break;
case kFmt20t:
  target = offset + sshort(insns, u1offset + 2);
  dcv.visitJumpStmt(op, -1, -1, labelsMap.get(target));
  break;
case kFmt21t:
  target = offset + sshort(insns, u1offset + 2);
  dcv.visitJumpStmt(op, ubyte(insns, u1offset + 1), -1, labelsMap.get(target));
  break;
case kFmt22t:

code.visitRegister(11);
DexLabel L0 = new DexLabel();
DexLabel L1 = new DexLabel();
DexLabel L2 = new DexLabel();
code.visitTryCatch(L0, L1, new DexLabel[] { L2 }, new String[] { "Ljava/lang/NumberFormatException;" });
code.visitConstStmt(CONST, 7, Integer.valueOf(46)); // int: 0x0000002e float:0.000000
code.visitConstStmt(CONST_STRING, 8, "Could not parse passive host information.\nServer Reply: ");
code.visitFieldStmt(SGET_OBJECT, 5,-1, new Field("Lorg/apache/commons/net/ftp/FTPClient;", "__parms_pat",
    "Ljava/util/regex/Pattern;"));
code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 5, 10 }, new Method("Ljava/util/regex/Pattern;",
    "matcher", new String[] { "Ljava/lang/CharSequence;" }, "Ljava/util/regex/Matcher;"));
code.visitStmt1R(MOVE_RESULT_OBJECT, 1);
code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 1 }, new Method("Ljava/util/regex/Matcher;",
    "find", new String[] {}, "Z"));
code.visitStmt1R(MOVE_RESULT, 5);
DexLabel L13 = new DexLabel();
code.visitJumpStmt(IF_NEZ, 5, -1,L13);
code.visitTypeStmt(NEW_INSTANCE, 5,-1, "Lorg/apache/commons/net/MalformedServerReplyException;");
code.visitTypeStmt(NEW_INSTANCE, 6,-1, "Ljava/lang/StringBuilder;");
code.visitMethodStmt(INVOKE_DIRECT, new int[] { 6 }, new Method("Ljava/lang/StringBuilder;",
    "<init>", new String[] {}, "V"));
code.visitConstStmt(CONST_STRING, 7, "Could not parse passive host information.\nServer Reply: ");
code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 6, 8 }, new Method("Ljava/lang/StringBuilder;",
    "append", new String[] { "Ljava/lang/String;" }, "Ljava/lang/StringBuilder;"));
code.visitStmt1R(MOVE_RESULT_OBJECT, 6);

code.visitTryCatch(try_start_2, try_end_9, new DexLabel[] { catch_a },
    new String[] { "Ljava/io/UnsupportedEncodingException;" });
code.visitRegister(4);
code.visitJumpStmt(IF_EQZ, p1, -1, cond_7);
code.visitLabel(goto_2);
code.visitLabel(try_start_2);
code.visitMethodStmt(INVOKE_STATIC, new int[] { p0, p1 }, new Method("Ljava/net/URLEncoder;", "encode",
    new String[] { "Ljava/lang/String;", "Ljava/lang/String;" }, "Ljava/lang/String;"));
code.visitStmt1R(MOVE_RESULT_OBJECT, v0);
code.visitStmt1R(RETURN_OBJECT, v0);
code.visitLabel(cond_7);
code.visitConstStmt(CONST_STRING, p1, "ISO-8859-1");
code.visitLabel(try_end_9);
code.visitJumpStmt(GOTO, -1, -1, goto_2);
code.visitLabel(catch_a);
code.visitStmt1R(MOVE_EXCEPTION, v0);
code.visitTypeStmt(NEW_INSTANCE, v1, -1, "Ljava/lang/IllegalArgumentException;");
code.visitMethodStmt(INVOKE_DIRECT, new int[] { v1, v0 }, new Method("Ljava/lang/IllegalArgumentException;",
    "<init>", new String[] { "Ljava/lang/Throwable;" }, "V"));
code.visitStmt1R(THROW, v1);
code.visitEnd();
mv.visitEnd();

public static void a(DexClassVisitor cv) {
  DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La;", "b", new String[] {}, "V"));
  DexCodeVisitor code = mv.visitCode();
  code.visitRegister(2);
  DexLabel L0 = new DexLabel();
  DexLabel L1 = new DexLabel();
  DexLabel L2 = new DexLabel();
  code.visitTryCatch(L0, L1, new DexLabel[] { L2 }, new String[] { "Lsome/Exception;" });
  code.visitLabel(L0);
  code.visitConstStmt(CONST_STRING, 0, "abc");
  code.visitLabel(L1);
  code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 0 }, new Method("Ljava/lang/String;", "toString",
      new String[] {}, "Ljava/lang/String;"));
  code.visitStmt0R(RETURN_VOID);
  code.visitLabel(L2);
  code.visitStmt1R(MOVE_EXCEPTION, 1);
  code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 1 }, new Method("Ljava/lang/String;", "toString",
      new String[] {}, "Ljava/lang/String;"));
  code.visitStmt0R(RETURN_VOID);
  code.visitEnd();
  mv.visitEnd();
}

  @Test
  public static void merge1(DexClassVisitor cv) {// obj = array
    DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La;", "b", new String[] {}, "V"));
    DexCodeVisitor code = mv.visitCode();
    DexLabel L0 = new DexLabel();
    DexLabel L1 = new DexLabel();
    code.visitRegister(3);
    code.visitConstStmt(CONST, 0, 0);
    code.visitJumpStmt(GOTO, -1, -1, L1);
    code.visitLabel(L0);
    code.visitStmt2R(ARRAY_LENGTH, 1, 0);
    code.visitConstStmt(CONST, 1, 0);
    code.visitStmt3R(AGET, 2, 0, 1);
    code.visitStmt0R(RETURN_VOID);
    code.visitLabel(L1);
    code.visitConstStmt(CONST, 1, 1);
    code.visitTypeStmt(NEW_ARRAY, 0, 1, "[Ljava/security/cert/X509Certificate;");
    code.visitJumpStmt(GOTO, -1, -1, L0);
    code.visitEnd();
    mv.visitEnd();
  }
}

dcv.visitRegister(registers);
int argStart = 4;
if (haveThis) {
  dcv.visitStmt2R(Op.MOVE_OBJECT, 0, argStart);
  argStart++;
} else {
  dcv.visitConstStmt(Op.CONST_4, 0, 0);
  dcv.visitConstStmt(Op.CONST_4, 1, 0);
} else {
  dcv.visitConstStmt(Op.CONST, 1, t.getParameterTypes().length);
  dcv.visitTypeStmt(Op.NEW_ARRAY, 1, 1, "[Ljava/lang/Object;");
  for (int i = 0; i < t.getParameterTypes().length; i++) {
    char type = t.getParameterTypes()[i].charAt(0);
    dcv.visitConstStmt(Op.CONST, 2, i);
    box(type, argStart, 3, dcv);
    dcv.visitStmt3R(Op.APUT_OBJECT, 3, 1, 2);
    if (type == 'J' || type == 'D') {
      argStart += 2;
dcv.visitConstStmt(Op.CONST, 2, nextIdx);
String miTypeDesc = "L" + getCurrentInvocationName() + ";";
dcv.visitTypeStmt(Op.NEW_INSTANCE, 3, 0, miTypeDesc);
dcv.visitMethodStmt(Op.INVOKE_DIRECT, new int[]{3, 0, 1,
    2}, new Method(miTypeDesc, "<init>", new String[]{
    "Ljava/lang/Object;", "[Ljava/lang/Object;", "I"
}, "V"));
Method call = build(mapTo);
dcv.visitMethodStmt(Op.INVOKE_STATIC, new int[]{3}, call);

@Test
public static void a123(DexClassVisitor cv) {
  DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La;", "b", new String[] {}, "V"));
  DexCodeVisitor code = mv.visitCode();
  code.visitRegister(3);
  code.visitConstStmt(CONST, 0, 0);
  code.visitConstStmt(CONST, 1, 1);
  code.visitConstStmt(CONST, 2, 0x63);
  code.visitStmt3R(APUT, 2, 0, 1);
  code.visitStmt0R(RETURN_VOID);
  code.visitEnd();
  mv.visitEnd();
}

DexCodeVisitor code = mv.visitCode();
if (code != null) {
  code.visitRegister(3);
  code.visitMethodStmt(INVOKE_SUPER, new int[] { 2 }, new Method("Ljava/lang/Object;", "<init>",
      new String[] {}, "V"));
  code.visitFieldStmt(SGET_BOOLEAN, 0, -1, f);
  code.visitConstStmt(CONST, 1, 0xffFFffFF);
  code.visitStmt3R(ADD_INT, 0, 0, 1);
  code.visitFieldStmt(SPUT_SHORT, 0, -1, f);
  code.visitStmt0R(RETURN_VOID);
  code.visitEnd();

if (code != null) {
  int v0 = 0;
  code.visitRegister(1);
  DexLabel L1 = new DexLabel();
  DexLabel L2 = new DexLabel();
  DexLabel L3 = new DexLabel();
  code.visitConstStmt(CONST, v0, 0);
  code.visitJumpStmt(IF_EQ, v0, v0, L2);
  code.visitLabel(L1);
  code.visitStmt1R(RETURN_OBJECT, v0);
  code.visitLabel(L2);
  code.visitJumpStmt(IF_EQ, v0, v0, L3);
  code.visitMethodStmt(INVOKE_STATIC, new int[0], new Method("La;", "getBytes", new String[0], "[B"));
  code.visitStmt1R(MOVE_RESULT_OBJECT, v0);
  code.visitLabel(L3);
  code.visitMethodStmt(INVOKE_STATIC, new int[] { v0 }, new Method("La;", "useBytes",
      new String[] { "[B" }, "V"));
  code.visitMethodStmt(INVOKE_STATIC, new int[0], new Method("La;", "getObjects", new String[0],
      "[Ljava/lang/Object;"));
  code.visitStmt1R(MOVE_RESULT, v0);
  code.visitJumpStmt(GOTO, -1, -1, L1);
  code.visitEnd();

@Test
public static void a120(DexClassVisitor cv) {
  DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La;", "b", new String[] {}, "V"));
  DexCodeVisitor code = mv.visitCode();
  code.visitRegister(3);
  code.visitConstStmt(CONST, 0, Integer.valueOf(0));
  code.visitMethodStmt(INVOKE_VIRTUAL, new int[] { 0 }, new Method("Ljava/lang/String;", "toString",
      new String[] {}, "Ljava/lang/String;"));
  code.visitConstStmt(CONST, 1, Integer.valueOf(0));
  code.visitStmt2R(ARRAY_LENGTH, 2, 1);
  code.visitStmt0R(RETURN_VOID);
  code.visitEnd();
  mv.visitEnd();
}

  @Test
  public static void i63(DexClassVisitor cv) {
    DexMethodVisitor mv = cv.visitMethod(ACC_STATIC, new Method("La;", "b", new String[] {}, "V"));
    if (mv != null) {
      DexCodeVisitor code = mv.visitCode();
      if (code != null) {
        code.visitRegister(1);
        DexLabel L1 = new DexLabel();
        DexLabel L2 = new DexLabel();
        code.visitLabel(L1);
        code.visitFieldStmt(Op.SGET, 0, -1, new Field("La;", "f", "J"));
        code.visitLabel(L2);
        code.visitStmt0R(Op.RETURN_VOID);
        code.visitEnd();
        code.visitTryCatch(L1, L2, new DexLabel[] { L2 }, new String[] { "La;" });
      }
      mv.visitEnd();
    }
  }
}

  @Test
  public static void i168(DexClassVisitor cv) {
    DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La;", "a", new String[] {}, "I"));
    DexCodeVisitor code = mv.visitCode();
    code.visitRegister(2000); // 2000 locals
    for (int i = 0; i < 2000; i++) {// 2000 insns
      code.visitConstStmt(Op.CONST, i, i);
    }
    for (int i = 0; i < 18000; i++) {// 18000 insns
      code.visitConstStmt(Op.CONST, 25, i);
    }
    code.visitStmt1R(Op.RETURN, 25);
    code.visitEnd();
    mv.visitEnd();
  }
}

dcv.visitRegister(registers_size);
BitSet nextInsn = new BitSet();
Map<Integer, DexLabel> labelsMap = new TreeMap<Integer, DexLabel>();
  DexDebugVisitor ddv = dcv.visitDebug();
  if (ddv != null) {
    read_debug_info(debug_info_off, registers_size, isStatic, method, labelsMap, ddv);
findLabels(insnsArray, nextInsn, badOps, labelsMap, handlers, method);
acceptInsn(insnsArray, dcv, nextInsn, badOps, labelsMap);
dcv.visitEnd();

  @Test
  public void test() {
    ASMifierFileV fv = new ASMifierFileV(new File("target/asmftest").toPath(), "a.b");
    DexClassVisitor cv = fv.visit(ACC_PUBLIC, "La/f;", "Ljava/lang/Object;", null);
    DexFieldVisitor f2v = cv.visitField(ACC_PUBLIC, new Field("La/f;", "abc", "I"), null);
    f2v.visitEnd();
    DexMethodVisitor mv = cv.visitMethod(ACC_PUBLIC | ACC_STATIC, new Method("La/f;", "zz", new String[0], "I"));

    DexAnnotationAble pv = mv.visitParameterAnnotation(2);
    DexAnnotationVisitor dav = pv.visitAnnotation("Leeeff;", Visibility.BUILD);
    dav.visitEnd();
    DexCodeVisitor dcv = mv.visitCode();
    dcv.visitConstStmt(Op.FILL_ARRAY_DATA, 0, new int[] { 1, 2, 3 });
    dcv.visitStmt0R(Op.RETURN_VOID);
    dcv.visitEnd();
    mv.visitEnd();
    cv.visitEnd();
    fv.visitEnd();
  }
}

@Test
public void test3() {
  DexFileWriter w = new DexFileWriter();
  DexClassVisitor cv = w.visit(0x1, "La/c;", null, new String[]{"Ljava/lang/Comparable;"});
  cv.visitSource("c.java");
  cv.visitAnnotation("LAnn;", Visibility.SYSTEM).visitEnd();
  DexFieldVisitor fv = cv.visitField(ACC_PUBLIC | ACC_STATIC, new Field("La/c;", "a", "I"), 55);
  fv.visitAnnotation("LE;", Visibility.RUNTIME).visitEnd();
  fv.visitEnd();
  DexMethodVisitor mv = cv.visitMethod(ACC_STATIC, new Method("La/c;", "bb", new String[]{"I"}, "V"));
  mv.visitAnnotation("Laaa;", Visibility.RUNTIME).visitEnd();
  DexAnnotationVisitor dav = mv.visitParameterAnnotation(0).visitAnnotation("Laaa;", Visibility.RUNTIME);
  dav.visit("abc", true);
  DexAnnotationVisitor dav2 = dav.visitArray("efg");
  dav2.visit("", "123");
  dav2.visit("", "456");
  dav2.visitEnd();
  dav.visitEnd();
  DexCodeVisitor code = mv.visitCode();
  code.visitRegister(2);
  code.visitStmt0R(Op.RETURN_VOID);
  code.visitEnd();
  mv.visitEnd();
  cv.visitEnd();
  w.visitEnd();
  w.toByteArray();
}

public void accept(DexCodeVisitor v) {
  if (tryStmts != null) {
    for (TryCatchNode n : tryStmts) {
      n.accept(v);
    }
  }
  if (debugNode != null) {
    DexDebugVisitor ddv = v.visitDebug();
    if (ddv != null) {
      debugNode.accept(ddv);
      ddv.visitEnd();
    }
  }
  if (totalRegister >= 0) {
    v.visitRegister(this.totalRegister);
  }
  for (DexStmtNode n : stmts) {
    n.accept(v);
  }
}

Most used methods

visitEnd
visitConstStmt
CONST * CONST_WIDE * CONST_STRING * CONST_CLASS
visitRegister
visitStmt0R
Op#RETURN_VOID Op#NOP Op#BAD_OP
visitFieldStmt
OP_IGETX a,b field OP_IPUTX a,b field OP_SGETX a field OP_SPUTX a field
visitLabel
visitMethodStmt
OP_INVOKE_CUSTOM
visitPackedSwitchStmt
visitStmt1R
OP_RETURN_X OP_THROW_X OP_MONITOR_ENTER OP_MONITOR_EXIT OP_MOVE_RESULT_X OP_MOVE_EXCEPTION_X
visitStmt2R
OP_MOVE a = a X b OP_ARRAY_LENGTH a=Xb X_TO_Y
visitStmt3R
OP_ADD OP_SUB OP_MUL OP_DIV OP_REM OP_AND OP_OR OP_XOR OP_SHL OP_SHR OP_USHR OP_CMPL O
visitTypeStmt
OP_INSTANCE_OF OP_NEW_ARRAY OP_CHECK_CAST OP_NEW_INSTANCE

Popular in Java

Creating JSON documents from java classes using gson
findViewById (Activity)
getSharedPreferences (Context)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
SQLException (java.sql)
An exception that indicates a failed JDBC operation. It provides the following information about pro
DecimalFormat (java.text)
A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features desig
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
Pattern (java.util.regex)
Patterns are compiled regular expressions. In many cases, convenience methods such as String#matches
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin
Top Sublime Text plugins

How to useDexCodeVisitor in com.googlecode.d2j.visitors

Best Java code snippets using com.googlecode.d2j.visitors.DexCodeVisitor (Showing top 20 results out of 315)

How to use
DexCodeVisitor
in
com.googlecode.d2j.visitors