コード例 #1
0
  /**
   * Generates a printable string that represents the given ActionScript 3 code.
   *
   * @param resolvedCode The ActionScript 3 code to turn into a string.
   * @param code The raw ActionScript 3 code.
   * @param prefix The prefix to write before every printed line.
   * @return The generated ActionScript 3 code string.
   */
  private static String getCodeText(
      final ResolvedCode resolvedCode, final AS3Code code, final String prefix) {

    if (code.getInstructions().size() == 0) {
      return "";
    }

    final StringBuilder sb = new StringBuilder();

    final AS3Instruction firstInstruction = code.getInstructions().get(0);

    final int firstOffset = firstInstruction.getBitPosition();

    for (final AS3Instruction instruction : code.getInstructions()) {

      final int absoluteOffset = instruction.getBitPosition() / 8;
      final int relativeOffset = absoluteOffset - firstOffset / 8;
      sb.append(prefix);
      sb.append(String.format("%08X %08X  ", absoluteOffset, relativeOffset));

      addInstructionText(sb, instruction, resolvedCode, firstOffset / 8);

      sb.append('\n');
    }

    return sb.toString();
  }
コード例 #2
0
  /**
   * Adds the class header to the output.
   *
   * @param resolvedClass Provides the class information.
   * @param sb The string builder the output is appended to.
   */
  private static void addClassHeader(final ResolvedClass resolvedClass, final StringBuilder sb) {
    sb.append("class ");

    // Add the class name.
    final String className = ActionScript3Helpers.flattenNamespaceName(resolvedClass.getName());
    sb.append(className);

    // Add the opening class parentheses.
    sb.append("\n{\n");
  }
コード例 #3
0
  /**
   * Resolves and adds an unsigned integer value instruction to the output.
   *
   * @param sb The string builder the output is appended to.
   * @param mnemonic The mnemonic of the instruction.
   * @param uintIndex The unsigned integer index.
   * @param code The code the instruction belongs to.
   */
  private static void addUInteger(
      final StringBuilder sb, final String mnemonic, final int uintIndex, final ResolvedCode code) {

    final Long integer = code.resolveUInteger(uintIndex - 1);

    sb.append(mnemonic);
    sb.append(" ");

    if (integer == null) {
      sb.append(String.format("??? [0x%08X]", uintIndex));
    } else {
      sb.append(String.format("%d [0x%08X]", integer, uintIndex));
    }
  }
コード例 #4
0
  /**
   * Resolves and adds a namespace instruction to the output.
   *
   * @param sb The string builder the output is appended to.
   * @param mnemonic The mnemonic of the instruction.
   * @param namespace The namespace index.
   * @param code The code the instruction belongs to.
   */
  private static void addNamespace(
      final StringBuilder sb, final String mnemonic, final int namespace, final ResolvedCode code) {

    final String namespaceString = code.resolveNamespace(namespace);

    sb.append(mnemonic);
    sb.append(" ");

    if (namespaceString == null) {
      sb.append(String.format("??? [0x%08X]", namespace));
    } else {
      sb.append(String.format("\"%s\" [0x%08X]", namespaceString, namespace));
    }
  }
コード例 #5
0
  /**
   * Resolves and adds a double value to the output.
   *
   * @param sb The string builder the output is appended to.
   * @param mnemonic The mnemonic of the instruction.
   * @param doubleIndex The double index.
   * @param code The code the instruction belongs to.
   */
  private static void addDouble(
      final StringBuilder sb,
      final String mnemonic,
      final int doubleIndex,
      final ResolvedCode code) {

    final Double dbl = code.resolveDouble(doubleIndex - 1);

    sb.append(mnemonic);
    sb.append(" ");

    if (dbl == null) {
      sb.append(String.format("??? [0x%08X]", doubleIndex));
    } else {
      sb.append(String.format("%f [0x%08X]", dbl, doubleIndex));
    }
  }
コード例 #6
0
  /**
   * Resolves and adds a string value instruction to the output.
   *
   * @param sb The string builder the output is appended to.
   * @param mnemonic The mnemonic of the instruction.
   * @param stringIndex The string index.
   * @param code The code the instruction belongs to.
   */
  private static void addString(
      final StringBuilder sb,
      final String mnemonic,
      final int stringIndex,
      final ResolvedCode code) {

    final String string = code.resolveString(stringIndex - 1);

    sb.append(mnemonic);
    sb.append(" ");

    if (string == null) {
      sb.append(String.format("??? [0x%08X]", stringIndex));
    } else {
      sb.append(String.format("\"%s\" [0x%08X]", string, stringIndex));
    }
  }
コード例 #7
0
  /**
   * Resolves and adds an multiname instruction to the output.
   *
   * @param sb The string builder the output is appended to.
   * @param mnemonic The mnemonic of the instruction.
   * @param multiName The multiname index.
   * @param code The code the instruction belongs to.
   */
  private static void addMultiname(
      final StringBuilder sb, final String mnemonic, final int multiName, final ResolvedCode code) {

    final String[] multinameString = code.resolveMultiname(multiName);

    sb.append(mnemonic);
    sb.append(" ");

    if (multinameString == null) {
      sb.append(String.format("??? [0x%08X]", multiName));
    } else {
      sb.append(
          String.format(
              "%s [0x%08X]",
              ActionScript3Helpers.flattenNamespaceName(multinameString), multiName));
    }
  }
コード例 #8
0
  /**
   * Generates a printable string that represents all code in a given resolved ActionScript 3 code
   * snippet.
   *
   * @param code The resolved code to display.
   * @return The generated ActionScript 3 code string.
   */
  public static String getCodeText(final ResolvedCode code) {
    final StringBuilder sb = new StringBuilder();

    for (final ResolvedClass resolvedClass : code.getClasses()) {

      // Start out with the class definition.
      addClassHeader(resolvedClass, sb);

      boolean hadCode = false;

      // Start preparing all the methods for printing. Add the instance
      // constructor and the class constructor for printing.
      final ResolvedMethod staticConstructor = resolvedClass.getStaticConstructor();
      final ResolvedMethod constructor = resolvedClass.getConstructor();

      final List<ResolvedMethod> resolvedMethods = resolvedClass.getMethods();

      resolvedMethods.add(0, constructor);

      if (staticConstructor.getCode() != null) {
        // Only add the static constructor if it actually has code.
        resolvedMethods.add(0, staticConstructor);
      }

      final String className = ActionScript3Helpers.flattenNamespaceName(resolvedClass.getName());

      // Print the individual methods now.
      for (final ResolvedMethod resolvedMethod : resolvedMethods) {

        if (resolvedMethod != resolvedMethods.get(0)) {
          if (hadCode || resolvedMethod.getCode() != null) {
            sb.append("\n");
          }
        }

        hadCode = addMethod(code, resolvedMethod, className, sb);
      }

      addClassFooter(sb);
    }

    return sb.toString();
  }
コード例 #9
0
 /**
  * Adds the class footer to the output.
  *
  * @param sb The string builder the output is appended to.
  */
 private static void addClassFooter(final StringBuilder sb) {
   sb.append("}\n\n");
 }
コード例 #10
0
 /**
  * Adds an instruction with two arguments to the output.
  *
  * @param sb The string builder the output is appended to.
  * @param mnemonic The instruction mnemonic.
  * @param value1 The first instruction argument value.
  * @param value2 The second instruction argument value.
  */
 private static void add(
     final StringBuilder sb, final String mnemonic, final long value1, final long value2) {
   sb.append(String.format("%s %d, %d", mnemonic, value1, value2));
 }
コード例 #11
0
 /**
  * Adds a simple one-mnemonic instruction to the output.
  *
  * @param sb The string builder the output is appended to.
  * @param mnemonic The instruction mnemonic.
  */
 private static void add(final StringBuilder sb, final String mnemonic) {
   sb.append(mnemonic);
 }
コード例 #12
0
 /**
  * Adds an if instruction to the output.
  *
  * @param sb The string builder the output is appended to.
  * @param mnemonic The mnemonic of the if instruction.
  * @param value The branch offset value.
  */
 private static void addIf(final StringBuilder sb, final String mnemonic, final long value) {
   sb.append(String.format("%s %08X", mnemonic, value));
 }
コード例 #13
0
  /**
   * Adds a method to the output.
   *
   * @param code The code the method belongs to.
   * @param resolvedMethod The method to add to the output.
   * @param className The name of the enclosing class the method belongs to.
   * @param sb The string builder the output is appended to.
   * @return True, if the method has code. False, if the method is just a declaration.
   */
  private static boolean addMethod(
      final ResolvedCode code,
      final ResolvedMethod resolvedMethod,
      final String className,
      final StringBuilder sb) {
    sb.append("\t");
    final String flattenedReturnType =
        ActionScript3Helpers.flattenNamespaceName(resolvedMethod.getReturnType());
    sb.append(flattenedReturnType);

    if (!flattenedReturnType.isEmpty()) {
      // This path is taken for all methods but constructors.
      sb.append(" ");
    }

    final String functionName = ActionScript3Helpers.flattenNamespaceName(resolvedMethod.getName());

    if (functionName.startsWith(className)) {
      // To make code more readable, strip fully qualified type
      // information.
      sb.append(functionName.substring(className.length() + 1));
    } else {
      sb.append(functionName);
    }

    sb.append("(");

    // Print the method arguments.
    for (final String[] argument : resolvedMethod.getArguments()) {

      if (argument != resolvedMethod.getArguments().get(0)) {
        sb.append(", ");
      }

      sb.append(ActionScript3Helpers.flattenNamespaceName(argument));
    }

    sb.append(")");

    // Print the code.
    final AS3Code methodCode = resolvedMethod.getCode();

    if (methodCode == null) {
      sb.append(";\n");
      return false;
    } else {
      sb.append("\n");
      sb.append("\t{");
      sb.append("\n");
      sb.append(getCodeText(code, methodCode, "\t\t"));
      sb.append("\t}\n");
      return true;
    }
  }