definiteassignment.jrag

JDK1.4编译器前端

    return true;
  }
  // 16.2.11 2nd bullet
  eq ForStmt.getInitStmt(int i).isDAbefore(Variable v) = i == 0 ? isDAbefore(v) : getInitStmt(i-1).isDAafter(v);
  // 16.2.11 3rd bullet
  syn boolean ForStmt.isDAafterInitialization(Variable v) = getNumInitStmt() == 0 ? isDAbefore(v) : getInitStmt(getNumInitStmt()-1).isDAafter(v);
  eq ForStmt.getCondition().isDAbefore(Variable v) = isDAafterInitialization(v);
  // 16.2.11 5th bullet
  eq ForStmt.getStmt().isDAbefore(Variable v) {
    if(hasCondition() && getCondition().isDAafterTrue(v))
      return true;
    if(!hasCondition() && isDAafterInitialization(v))
      return true;
    return false;
  }
  // 16.2.11 6th bullet
  eq ForStmt.getUpdateStmt().isDAbefore(Variable v) {
    if(!getStmt().isDAafter(v))
      return false;
    for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
      ContinueStmt stmt = (ContinueStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

  eq BreakStmt.isDAafter(Variable v) = true;
  eq ContinueStmt.isDAafter(Variable v) = true;
  eq ReturnStmt.isDAafter(Variable v) = true;
  eq ThrowStmt.isDAafter(Variable v) = true;
  
  eq ReturnStmt.getResult().isDAbefore(Variable v) = isDAbefore(v);
  eq ThrowStmt.getExpr().isDAbefore(Variable v) = isDAbefore(v);

  eq SynchronizedStmt.isDAafter(Variable v) = getBlock().isDAafter(v);
  eq SynchronizedStmt.getExpr().isDAbefore(Variable v) = isDAbefore(v);
  eq SynchronizedStmt.getBlock().isDAbefore(Variable v) = getExpr().isDAafter(v);

  // 16.2.15 1st bullet
  eq TryStmt.getBlock().isDAbefore(Variable v) = isDAbefore(v);
  // 16.2.15 2nd bullet
  eq TryStmt.getCatchClause().isDAbefore(Variable v) = getBlock().isDAbefore(v);
  
  // 16.2.15 6th bullet
  eq TryStmt.getFinally().isDAbefore(Variable v) = isDAbefore(v);
  eq TryStmt.isDAafter(Variable v) {
    // 16.2.15 4th bullet
    if(!hasFinally()) {
      if(!getBlock().isDAafter(v))
        return false;
      for(int i = 0; i < getNumCatchClause(); i++)
        if(!getCatchClause(i).getBlock().isDAafter(v))
          return false;
      return true;
    }
    else {
      // 16.2.15 5th bullet
      if(getFinally().isDAafter(v))
        return true;
      if(!getBlock().isDAafter(v))
        return false;
      for(int i = 0; i < getNumCatchClause(); i++)
        if(!getCatchClause(i).getBlock().isDAafter(v))
          return false;
      return true;
    }
  }
}

aspect DU {
  inh boolean Stmt.isDUbefore(Variable v);
  syn lazy boolean Stmt.isDUafter(Variable v);
  inh boolean Expr.isDUbefore(Variable v);
  syn boolean Expr.isDUafter(Variable v);

  inh lazy boolean Binary.isDUbefore(Variable v);
  inh lazy boolean AbstractDot.isDUbefore(Variable v);
  
  syn lazy boolean Binary.isDUafter(Variable v);
  syn lazy boolean AbstractDot.isDUafter(Variable v);

  syn boolean Expr.isDUafterTrue(Variable v);
  syn boolean Expr.isDUafterFalse(Variable v);

  inh lazy boolean TypeDecl.isDUbefore(Variable v);

  inh lazy boolean BodyDecl.isDUbefore(Variable v);
  syn lazy boolean BodyDecl.isDUafter(Variable v) = true;

  eq Program.getChild().isDUbefore(Variable v) = true;

  eq TypeDecl.getBodyDecl().isDUbefore(Variable v) {
    BodyDecl b = getBodyDecl(childIndex);
    if(b instanceof MethodDecl || b instanceof MemberTypeDecl) {
      return false;
    }
    if(v.isClassVariable() || v.isInstanceVariable()) {
      int index = childIndex - 1;
      if(b instanceof ConstructorDecl)
        index = getNumBodyDecl() - 1;
        
      for(int i = index; i >= 0; i--) {
        b = getBodyDecl(i);
        if(b instanceof FieldDeclaration) {
          FieldDeclaration f = (FieldDeclaration)b;
          //System.err.println("  working on field " + f.name() + " which is child " + i);
          if(f == v)
            return !f.hasInit();
          if((v.isClassVariable() && f.isStatic()) || (v.isInstanceVariable() && !f.isStatic()))
            return f.isDUafter(v);
          //System.err.println("  field " + f.name() + " can not affect " + v.name());
        }
        else if(b instanceof StaticInitializer && v.isClassVariable()) {
          StaticInitializer si = (StaticInitializer)b;
          //System.err.println("  working on static initializer which is child " + i);
          return si.isDUafter(v);
        }
        else if(b instanceof InstanceInitializer && v.isInstanceVariable()) {
          InstanceInitializer ii = (InstanceInitializer)b;
          //System.err.println("  working on instance initializer which is child " + i);
          return ii.isDUafter(v);
        }
      }
    }
    //System.err.println("Reached TypeDecl when searching for DU for variable");
    return isDUbefore(v);
  }

  eq InstanceInitializer.isDUafter(Variable v) = getBlock().isDUafter(v);
  eq StaticInitializer.isDUafter(Variable v) = getBlock().isDUafter(v);
  
  eq ConstructorDecl.isDUafter(Variable v) = getBlock().isDUafter(v) && getBlock().checkReturnDU(v);
  eq ConstructorAccess.isDUafter(Variable v) = decl().isDUafter(v);
  eq SuperConstructorAccess.isDUafter(Variable v) = isDUbefore(v);
  eq ConstructorDecl.getBlock().isDUbefore(Variable v) = hasConstructorInvocation() ? getConstructorInvocation().isDUafter(v) : isDUbefore(v);

  syn lazy boolean Block.checkReturnDU(Variable v) {
    HashSet set = new HashSet();
    collectBranches(set);
    for(Iterator iter = set.iterator(); iter.hasNext(); ) {
      Object o = iter.next();
      if(o instanceof ReturnStmt) {
        ReturnStmt stmt = (ReturnStmt)o;
        if(!stmt.isDUafterReachedFinallyBlocks(v))
          return false;
      }
    }
    return true;
  }

  eq FieldDeclaration.isDUafter(Variable v) {
    if(v == this)
      return !hasInit();
    return hasInit() ? getInit().isDUafter(v) : isDUbefore(v);
  }
  
  eq Stmt.isDUafter(Variable v) {
    throw new Error("isDUafter in " + getClass().getName());
  }

  eq Expr.isDUafterFalse(Variable v) {
    if(isTrue())
      return true;
    return isDUbefore(v);
  }
  //= isFalse() && isDUbefore(v) || isTrue();
  eq Expr.isDUafterTrue(Variable v) {
    if(isFalse())
      return true;
    return isDUbefore(v);
  }

  eq AbstractDot.isDUafterTrue(Variable v) = isDUafter(v);
  eq AbstractDot.isDUafterFalse(Variable v) = isDUafter(v);
  
  //= isTrue() && isDUbefore(v) || isFalse();
  eq Expr.isDUafter(Variable v) = (isDUafterFalse(v) && isDUafterTrue(v)) || isDUbefore(v);

  eq ParExpr.isDUafterTrue(Variable v) = getExpr().isDUafterTrue(v);
  eq ParExpr.isDUafterFalse(Variable v) = getExpr().isDUafterFalse(v);

  eq AndLogicalExpr.isDUafterTrue(Variable v) = getRightOperand().isDUafterTrue(v);
  eq AndLogicalExpr.isDUafterFalse(Variable v) = getLeftOperand().isDUafterFalse(v) && getRightOperand().isDUafterFalse(v);
  eq AndLogicalExpr.getLeftOperand().isDUbefore(Variable v) = isDUbefore(v);
  eq AndLogicalExpr.getRightOperand().isDUbefore(Variable v) = getLeftOperand().isDUafterTrue(v);
  eq AndLogicalExpr.isDUafter(Variable v) = isDUafterTrue(v) && isDUafterFalse(v);

  eq OrLogicalExpr.isDUafterTrue(Variable v) = getLeftOperand().isDUafterTrue(v) && getRightOperand().isDUafterTrue(v);
  eq OrLogicalExpr.isDUafterFalse(Variable v) = getRightOperand().isDUafterFalse(v);
  eq OrLogicalExpr.getLeftOperand().isDUbefore(Variable v) = isDUbefore(v);
  eq OrLogicalExpr.getRightOperand().isDUbefore(Variable v) = getLeftOperand().isDUafterFalse(v);
  eq OrLogicalExpr.isDUafter(Variable v) = isDUafterTrue(v) && isDUafterFalse(v);

  eq LogNotExpr.isDUafterTrue(Variable v) = getOperand().isDUafterFalse(v);
  eq LogNotExpr.isDUafterFalse(Variable v) = getOperand().isDUafterTrue(v);
  eq LogNotExpr.getOperand().isDUbefore(Variable v) = isDUbefore(v);
  eq LogNotExpr.isDUafter(Variable v) = isDUafterTrue(v) && isDUafterFalse(v);

  eq ConditionalExpr.isDUafterTrue(Variable v) = getTrueExpr().isDUafterTrue(v) && getFalseExpr().isDUafterTrue(v);
  eq ConditionalExpr.isDUafterFalse(Variable v) = getTrueExpr().isDUafterFalse(v) && getFalseExpr().isDUafterFalse(v);
  eq ConditionalExpr.getCondition().isDUbefore(Variable v) = isDUbefore(v);
  eq ConditionalExpr.getTrueExpr().isDUbefore(Variable v) = getCondition().isDUafterTrue(v);
  eq ConditionalExpr.getFalseExpr().isDUbefore(Variable v) = getCondition().isDUafterFalse(v);
  eq ConditionalExpr.isDUafter(Variable v) = booleanOperator() ? isDUafterTrue(v) && isDUafterFalse(v) : getTrueExpr().isDUafter(v) && getFalseExpr().isDUafter(v);

  eq AssignExpr.isDUafter(Variable v) = getSource().isDUafter(v);
  eq AssignExpr.getSource().isDUbefore(Variable v) = getDest().isDUafter(v);
  eq AssignExpr.getDest().isDUbefore(Variable v) = isDUbefore(v);
  eq AssignExpr.isDUafterTrue(Variable v) = isDUafter(v);
  eq AssignExpr.isDUafterFalse(Variable v) = isDUafter(v);

  syn boolean VarAccess.isDUafter(Variable v) {
    if(isDest() && decl() == v)
      return false;
    return isDUbefore(v);
  }
  eq AbstractDot.getRight().isDUbefore(Variable v) = getLeft().isDUafter(v);
  eq AbstractDot.isDUafter(Variable v) = lastAccess().isDUafter(v);
  eq ArrayAccess.isDUafter(Variable v) = getExpr().isDUafter(v);
  eq ArrayTypeAccess.isDUafter(Variable v) = getAccess().isDUafter(v);
  eq ArrayTypeWithSizeAccess.isDUafter(Variable v) = getExpr().isDUafter(v);
  eq ArrayTypeWithSizeAccess.getExpr().isDUbefore(Variable v) = getAccess().isDUafter(v);

  eq ParExpr.isDUafter(Variable v) = getExpr().isDUafter(v);
  eq Unary.isDUafter(Variable v) = getOperand().isDUafter(v);
  eq CastExpr.isDUafter(Variable v) = getExpr().isDUafter(v);
  
  eq Binary.isDUafter(Variable v) = getRightOperand().isDUafter(v);
  eq Binary.getRightOperand().isDUbefore(Variable v) = getLeftOperand().isDUafter(v);

  eq InstanceOfExpr.isDUafter(Variable v) = getExpr().isDUafter(v);
  
  syn boolean ClassInstanceExpr.isDUafterInstance(Variable v) {
    if(getNumArg() == 0)
      return isDUbefore(v);
    return getArg(getNumArg()-1).isDUafter(v);
  }
  eq ClassInstanceExpr.isDUafter(Variable v) = isDUafterInstance(v);
  eq ClassInstanceExpr.getArg(int i).isDUbefore(Variable v) = computeDUbefore(i, v);
  syn lazy boolean ClassInstanceExpr.computeDUbefore(int i, Variable v) =
    i == 0 ? isDUbefore(v) : getArg(i-1).isDUafter(v);

  syn boolean ArrayCreationExpr.isDUafterCreation(Variable v) = getTypeAccess().isDUafter(v);
  eq ArrayCreationExpr.isDUafter(Variable v) = hasArrayInit() ? getArrayInit().isDUafter(v) : isDUafterCreation(v);
  
  eq ArrayCreationExpr.getArrayInit().isDUbefore(Variable v) = isDUafterCreation(v);

  eq EmptyStmt.isDUafter(Variable v) = isDUbefore(v);
  eq AssertStmt.isDUafter(Variable v) = getfirst().isDUafter(v);

  eq MethodDecl.getBlock().isDUbefore(Variable v) = v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? false : true;

  eq Block.isDUafter(Variable v) = getNumStmt() == 0 ? isDUbefore(v) : getStmt(getNumStmt()-1).isDUafter(v);
  eq Block.getStmt(int index).isDUbefore(Variable v) = index == 0 ? isDUbefore(v) : getStmt(index - 1).isDUafter(v);
  
  eq LocalClassDeclStmt.isDUafter(Variable v) = isDUbefore(v);

  eq VariableDeclaration.isDUafter(Variable v) {
    if(v == this)
      return !hasInit();
    return hasInit() ? getInit().isDUafter(v) : isDUbefore(v);
  }
  eq VariableDeclaration.getInit().isDUbefore(Variable v) = isDUbefore(v);

  eq ArrayInit.isDUafter(Variable v) = getNumInit() == 0 ? isDUbefore(v) : getInit(getNumInit()-1).isDUafter(v);
  eq ArrayInit.getInit().isDUbefore(Variable v) = computeDUbefore(childIndex, v);
  // force caching of computation
  syn lazy boolean ArrayInit.computeDUbefore(int childIndex, Variable v) {
    if(childIndex == 0) return isDUbefore(v);
    int index = childIndex-1;
    while(index > 0 && getInit(index).isConstant())
      index--;
    return getInit(childIndex-1).isDUafter(v);
  }

  eq LabeledStmt.getStmt().isDUbefore(Variable v) = isDUbefore(v);
  eq LabeledStmt.isDUafter(Variable v) {
    if(!getStmt().isDUafter(v))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

  interface FinallyHost {
    //public Block getFinally();
    public boolean isDUafterFinally(Variable v);
    public boolean isDAafterFinally(Variable v);
  }
  TryStmt implements FinallyHost;
  SynchronizedStmt implements FinallyHost;

  
  syn boolean TryStmt.isDUafterFinally(Variable v) = getFinally().isDUafter(v);
  syn boolean SynchronizedStmt.isDUafterFinally(Variable v) = true;
  
  syn boolean TryStmt.isDAafterFinally(Variable v) = getFinally().isDAafter(v);
  syn boolean SynchronizedStmt.isDAafterFinally(Variable v) = false;

  
  syn lazy boolean BreakStmt.isDUafterReachedFinallyBlocks(Variable v) {
    if(!isDUbefore(v) && finallyList().isEmpty())
      return false;
    for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
      FinallyHost f = (FinallyHost)iter.next();
      if(!f.isDUafterFinally(v))