Beispiel #1
0
  CFG createCFG(String className) throws ClassNotFoundException {
    CFG cfg = new CFG();
    JavaClass jc = Repository.lookupClass(className);
    ClassGen cg = new ClassGen(jc);
    ConstantPoolGen cpg = cg.getConstantPool();
    for (Method m : cg.getMethods()) {
      MethodGen mg = new MethodGen(m, cg.getClassName(), cpg);
      InstructionList il = mg.getInstructionList();
      InstructionHandle[] handles = il.getInstructionHandles();
      int prev = 0;
      for (InstructionHandle ih : handles) {
        int position = ih.getPosition();
        cfg.addNode(position, m, jc);
        Instruction inst = ih.getInstruction();

        boolean br = inst.getName().contains("if") || inst.getName().contains("goto");
        boolean ret = inst.getName().contains("return");
        boolean stat = inst.getName().contains("invokestatic");
        int len = inst.getLength();

        if (stat) {
          int index = inst.toString(true).indexOf(" ");
          String name = inst.toString(true).substring(index + 1);
          int tar = Integer.valueOf(name);
          INVOKESTATIC inv = new INVOKESTATIC(tar);
          name = inv.getMethodName(cpg);

          Method m2 = null;
          Method[] tm = cg.getMethods();
          for (int i = 0; i < tm.length; i++) {
            if (tm[i].getName().equals(name)) {
              m2 = tm[i];
            }
          }
          cfg.addEdge(position, m, jc, 0, m2, jc);
          cfg.addEdge(-1, m2, jc, position + len, m, jc);
        }

        if (!ret && !stat) {
          cfg.addEdge(position, position + len, m, jc);
        }
        if (br) {
          cfg.addEdge(position, position + len, m, jc);
          IF_ICMPGE comp = new IF_ICMPGE(ih);
          String name = comp.getTarget().toString(false);
          int index = name.indexOf(">");
          name = name.substring(index + 2);
          int tar = Integer.valueOf(name);
          cfg.addEdge(position, tar, m, jc);
        }
        if (ret) {
          cfg.addEdge(position, -1, m, jc);
        }

        prev = position;
      }
      System.out.println(cfg.toString());
    }
    return cfg;
  }
Beispiel #2
0
  // Returns false on encountering something that can't be analyzed properly
  static boolean breakIntoPaths(
      List<CodePath> paths,
      List<PathInstruction> previousInstructions,
      int index,
      CFG cfg,
      MethodNode m,
      int maxPaths) {
    // Get the next instruction and check if we can handle it
    AbstractInsnNode instruction = m.instructions.get(index);

    // TODO: various control-flow instructions that we don't currently handle
    if (instruction instanceof LookupSwitchInsnNode) return false;
    if (instruction instanceof TableSwitchInsnNode) return false;
    if (instruction.getOpcode() == Opcodes.JSR) return false;
    if (instruction.getOpcode() == Opcodes.RET) return false;

    // Handle conditional branches specially
    if (instruction instanceof JumpInsnNode && instruction.getOpcode() != Opcodes.GOTO) {
      int nextIndex = index + 1;
      int branchIndex = index + 1;
      for (int next : cfg.succsOf(index)) if (next != nextIndex) branchIndex = next;
      // Add the instruction to the path, recurse, then remove the instruction
      previousInstructions.add(PathInstruction.branch(instruction, true));
      if (!breakIntoPaths(paths, previousInstructions, branchIndex, cfg, m, maxPaths)) return false;
      previousInstructions.remove(previousInstructions.size() - 1);

      // Add the instruction to the path, recurse, then remove the instruction
      previousInstructions.add(PathInstruction.branch(instruction, false));
      if (!breakIntoPaths(paths, previousInstructions, nextIndex, cfg, m, maxPaths)) return false;
      previousInstructions.remove(previousInstructions.size() - 1);
    } else if (cfg.succsOf(index) != null) {
      // Add the instruction to the path, recurse, then remove the instruction
      assert (cfg.succsOf(index).size() == 1);
      int nextIndex = cfg.succsOf(index).get(0);
      previousInstructions.add(new PathInstruction(instruction));
      if (!breakIntoPaths(paths, previousInstructions, nextIndex, cfg, m, maxPaths)) return false;
      previousInstructions.remove(previousInstructions.size() - 1);
    } else {
      // We've reached the end of a path, so record it
      previousInstructions.add(new PathInstruction(instruction));
      paths.add(new CodePath(previousInstructions));
      previousInstructions.remove(previousInstructions.size() - 1);

      // Abort if there are too many paths
      if (paths.size() > maxPaths) return false;
    }

    return true;
  }
  /**
   * Constructs a nullable set for the given grammar.
   *
   * @param g
   */
  public NullableNonterminals(CFG g) {
    super();

    // Construct Nullable Nonterminals
    List<Production> productions = g.productions();
    boolean changing = true;
    while (changing) {
      changing = false;
      for (Production p : productions) {
        Token left = p.leftHandSide();
        if (!nullable.contains(left)) {
          if (p.goesToEpsilon()) {
            nullable.add(left);
            changing = true;
          } else {
            List<Token> rhs = p.rightHandSide();
            boolean all_nullable = true;
            for (Token right : rhs) {
              if (!nullable.contains(right)) {
                all_nullable = false;
                break;
              }
            }

            if (all_nullable) {
              nullable.add(left);
              changing = true;
            }
          }
        }
      }
    }

    // ---------------------------------------------------------------------
    /*
     * Stores an immutable version of the non-terminal set to avoid
     * accidentally mutating it later.
     */
    this.nullable = Collections.unmodifiableSortedSet(nullable);
  }
Beispiel #4
0
/** @author thomas */
@PlainStorage
public interface MyInterface extends ConfigInterface {
  public static final MyInterface CFG = JsonConfig.create(MyInterface.class);

  @SuppressWarnings("unchecked")
  public static final StorageHandler<MyInterface> SH =
      (StorageHandler<MyInterface>) CFG._getStorageHandler();

  @DefaultBooleanValue(value = true)
  public boolean getB2();

  @DefaultBooleanArrayValue(value = {true, false, true})
  public boolean[] getBooleanArray();

  @DefaultByteValue(value = 0)
  public byte getByte();

  @DefaultByteArrayValue(value = {1, 2, 3})
  public byte[] getByteArray();

  @DefaultFactory(DefaultD.class)
  public double getD();

  @DefaultDoubleArrayValue(value = {1.0d, 2.0d, 3.0d})
  public double[] getDoubleArray();

  public void setDoubleArray(double[] arr);

  @DefaultEnumValue(value = "A")
  public Type getEnum();

  @DefaultFloatValue(value = 0.5f)
  public float getFloat();

  @DefaultFloatArrayValue(value = {1.0f, 2.0f, 3.0f})
  public Float[] getFloatArray();

  /** @return */
  public ArrayList<TestObject> getGenericList();

  public static final IntegerKeyHandler INT =
      CFG._getStorageHandler().getKeyHandler("Int", IntegerKeyHandler.class);

  @DefaultIntValue(value = 2)
  @SpinnerValidator(min = 1, max = 10, step = 1)
  public int getInt();

  @DefaultIntArrayValue(value = {1, 2, 3})
  public int[] getIntArray();

  @DefaultLongValue(value = 0l)
  public long getL();

  @DefaultLongArrayValue(value = {1, 2, 3})
  public long[] getLongArray();

  // @DefaultJsonObject(value = "{\"a\":5}")
  public TestObject getObject();

  public HashSet<String> getSet();

  public void setSet(HashSet<String> set);

  public ArrayList<TestObject[]> getStorableArrayList();

  // public Object[] getObjectArray();
  @DefaultStringValue(value = "test")
  public String getString();

  @DefaultStringArrayValue(value = {"test", "testb"})
  public String[] getStringArray();

  @DefaultEnumArrayValue(
      value = {"org.appwork.storage.config.test.Type.A", "org.appwork.storage.config.test.Type.B"})
  public Type[] getTypeArray();

  /** @param list */
  @CryptedStorage(
      key = {
        0x01, 0x02, 0x11, 0x01, 0x01, 0x54, 0x01, 0x01, 0x01, 0x01, 0x12, 0x01, 0x01, 0x01, 0x22,
        0x01
      })
  public void setGenericList(ArrayList<TestObject> list);

  public void setInt(int i);

  /** @param is */
  public void setIntArray(int[] is);

  class DefFac extends AbstractDefaultFactory<TestObject> {

    @Override
    public TestObject getDefaultValue() {
      // TODO Auto-generated method stub
      return null;
    }
  }

  class DefValid extends AbstractValidator<TestObject> {

    /*
     * (non-Javadoc)
     *
     * @see
     * org.appwork.storage.config.annotations.AbstractValidator#validate
     * (java.lang.Object)
     */
    @Override
    public void validate(TestObject object) throws ValidationException {
      System.out.println("CHECK " + object);
    }
  }

  /** @param o */
  @DefaultFactory(org.appwork.storage.config.test.MyInterface.DefFac.class)
  @ValidatorFactory(org.appwork.storage.config.test.MyInterface.DefValid.class)
  public void setObject(TestObject o);

  @DefaultFactory(MyDefaultCreator.class)
  public ArrayList<Integer> getDefault();
}