How to use

IndentingWriter

in

org.jf.util

  private static String baksmali(DexBackedClassDef def) throws IOException {
    baksmaliOptions opts = new baksmaliOptions();
    opts.outputDebugInfo = false;
    opts.syntheticAccessorResolver = new SyntheticAccessorResolver(Collections.EMPTY_LIST);
    ClassDefinition classDefinition = new ClassDefinition(opts, def);
    StringWriter bufWriter = new StringWriter();
    IndentingWriter writer = new IndentingWriter(bufWriter);
    classDefinition.writeTo((IndentingWriter) writer);
    writer.flush();
    return bufWriter.toString();
  }
}

public static void writeEmptyMethodTo(IndentingWriter writer, Method method,
                   BaksmaliOptions options) throws IOException {
  writer.write(".method ");
  writeAccessFlags(writer, method.getAccessFlags());
  writer.write(method.getName());
  writer.write("(");
  ImmutableList<MethodParameter> methodParameters = ImmutableList.copyOf(method.getParameters());
  for (MethodParameter parameter: methodParameters) {
    writer.write(parameter.getType());
  }
  writer.write(")");
  writer.write(method.getReturnType());
  writer.write('\n');
  writer.indent(4);
  writeParameters(writer, method, methodParameters, options);
  String containingClass = null;
  if (options.implicitReferences) {
    containingClass = method.getDefiningClass();
  }
  AnnotationFormatter.writeTo(writer, method.getAnnotations(), containingClass);
  writer.deindent(4);
  writer.write(".end method\n");
}

  protected void writeVtableIndex(IndentingWriter writer) throws IOException {
    writer.write("vtable@");
    writer.printSignedIntAsDec(((VtableIndexInstruction)instruction).getVtableIndex());
  }
}

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write("#@");
    writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL);
    return true;
  }
});

Collection<? extends Annotation> annotations = parameter.getAnnotations();
if ((options.debugInfo && parameterName != null) || annotations.size() != 0) {
  writer.write(".param p");
  writer.printSignedIntAsDec(registerNumber);
    writer.write(", ");
    ReferenceFormatter.writeStringReference(writer, parameterName);
  writer.write("    # ");
  writer.write(parameterType);
  writer.write("\n");
  if (annotations.size() > 0) {
    writer.indent(4);
    writer.deindent(4);
    writer.write(".end param\n");

public void printSignedIntAsDec(int value) throws IOException {
  int bufferIndex = 15;
  if (value < 0) {
    value *= -1;
    write('-');
  }
  do {
    int digit = value % 10;
    buffer[bufferIndex--] = (char)(digit + '0');
    value = value / 10;
  } while (value != 0);
  bufferIndex++;
  writeLine(buffer, bufferIndex, 16-bufferIndex);
}

@Override
public void write(char[] chars) throws IOException {
  //synchronized(lock) {
    for (char chr: chars) {
      write(chr);
    }
  //}
}

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write(".line ");
    writer.printUnsignedIntAsDec(lineNumber);
    return true;
  }
}

verificationErrorName = VerificationError.getVerificationErrorName(verificationError);
if (verificationErrorName == null) {
  writer.write("#was invalid verification error type: ");
  writer.printSignedIntAsDec(verificationError);
  writer.write("\n");
  verificationErrorName = "generic-error";
  } else {
    referenceWritable = indentingWriter -> {
      indentingWriter.write(ReferenceUtil.getReferenceString(reference, classContext));
    };
  String referenceString = writeInvalidItemIndex(ex, referenceInstruction.getReferenceType(),
      writer);
  referenceWritable = indentingWriter -> writer.write(referenceString);
} catch (ReferenceType.InvalidReferenceTypeException ex) {
  writer.write("#invalid reference type: ");
  writer.printSignedIntAsDec(ex.getReferenceType());
  commentOutInstruction = true;
  referenceWritable = indentingWriter -> writer.write("invalid_reference");
    Reference reference2 = dualReferenceInstruction.getReference2();
    referenceWritable2 = indentingWriter -> {
      indentingWriter.write(ReferenceUtil.getReferenceString(reference2, classContext));
    };
  } catch (InvalidItemIndex ex) {
    String referenceString = writeInvalidItemIndex(ex,
        dualReferenceInstruction.getReferenceType2(), writer);

IndentingWriter writer = new IndentingWriter(stringWriter);
MethodDefinition methodDefinition = new MethodDefinition(toClassDefinition(dexBackedMethodImplementation),
    dexBackedMethodImplementation.method,

  @Override protected void writeIndent() throws IOException {
    writer.write("# ");
    super.writeIndent();
  }
}

  public void printUnsignedIntAsDec(int value) throws IOException {
    int bufferIndex = 15;

    if (value < 0) {
      printSignedLongAsDec(value & 0xFFFFFFFFL);
    } else {
      printSignedIntAsDec(value);
    }
  }
}

  @Test
  public void testPrintSignedLongAsDec() throws IOException {
    StringWriter stringWriter = new StringWriter();
    IndentingWriter writer = new IndentingWriter(stringWriter);

    writer.printUnsignedIntAsDec(-1);
    writer.close();

    Assert.assertEquals("4294967295", stringWriter.toString());
  }
}

@Nonnull
public static String getNormalizedSmali(@Nonnull ClassDef classDef, @Nonnull BaksmaliOptions options,
                    boolean stripComments)
    throws IOException {
  StringWriter stringWriter = new StringWriter();
  IndentingWriter writer = new IndentingWriter(stringWriter);
  ClassDefinition classDefinition = new ClassDefinition(options, classDef);
  classDefinition.writeTo(writer);
  writer.close();
  return normalizeSmali(stringWriter.toString(), stripComments);
}

public void printUnsignedLongAsHex(long value) throws IOException {
  int bufferIndex = 23;
  do {
    int digit = (int)(value & 15);
    if (digit < 10) {
      buffer[bufferIndex--] = (char)(digit + '0');
    } else {
      buffer[bufferIndex--] = (char)((digit - 10) + 'a');
    }
    value >>>= 4;
  } while (value != 0);
  bufferIndex++;
  writeLine(buffer, bufferIndex, 24-bufferIndex);
}

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write("#@");
    writer.printUnsignedLongAsHex(codeAddress & 0xFFFFFFFFL);
    return true;
  }
});

writer.write(".method ");
writeAccessFlags(writer, method.getAccessFlags());
writer.write(method.getName());
writer.write("(");
for (MethodParameter parameter: methodParameters) {
  String type = parameter.getType();
  writer.write(type);
  parameterRegisterCount++;
  if (TypeUtils.isWideType(type)) {
writer.write(")");
writer.write(method.getReturnType());
writer.write('\n');
writer.indent(4);
if (classDef.options.localsDirective) {
  writer.write(".locals ");
  writer.printSignedIntAsDec(methodImpl.getRegisterCount() - parameterRegisterCount);
} else {
  writer.write(".registers ");
  writer.printSignedIntAsDec(methodImpl.getRegisterCount());
writer.write('\n');
writeParameters(writer, method, methodParameters, classDef.options);
writer.write('\n');
    writer.write('\n');

public void printSignedLongAsDec(long value) throws IOException {
  int bufferIndex = 23;
  if (value < 0) {
    value *= -1;
    write('-');
  }
  do {
    long digit = value % 10;
    buffer[bufferIndex--] = (char)(digit + '0');
    value = value / 10;
  } while (value != 0);
  bufferIndex++;
  writeLine(buffer, bufferIndex, 24-bufferIndex);
}

@Override
public void write(char[] chars, int start, int len) throws IOException {
  //synchronized(lock) {
    len = start+len;
    while (start < len) {
      write(chars[start++]);
    }
  //}
}

  @Override
  public boolean writeTo(IndentingWriter writer) throws IOException {
    writer.write(".line ");
    writer.printUnsignedIntAsDec(lineNumber);
    return true;
  }
}