definiteassignment.jrag

JDK1.4编译器前端

      }
    }
    return true;
  }

  eq FieldDeclaration.isDAafter(Variable v) {
    if(v == this)
      return hasInit();
    return hasInit() ? getInit().isDAafter(v) : isDAbefore(v);
  }

  eq FieldDeclaration.getInit().isDAbefore(Variable v) {
    return isDAbefore(v);
  }
  
  eq Program.getChild().isDAbefore(Variable v) = true;
  eq Stmt.isDAafter(Variable v) = isDAbefore(v);
  /*eq Stmt.isDAafter(Variable v) {
    //System.out.println("### isDAafter reached in " + getClass().getName());
    //throw new NullPointerException();
    throw new Error("Can not compute isDAafter for " + getClass().getName() + " at " + errorPrefix());
  }*/
  
  syn boolean Expr.isDAafterTrue(Variable v);
  syn boolean Expr.isDAafterFalse(Variable v);
  
  eq AbstractDot.isDAafterTrue(Variable v) = isDAafter(v);
  eq AbstractDot.isDAafterFalse(Variable v) = isDAafter(v);

  eq Expr.isDAafterFalse(Variable v) = isTrue() || isDAbefore(v);
  //= isFalse() && isDAbefore(v) || isTrue();
  eq Expr.isDAafterTrue(Variable v) = isFalse() || isDAbefore(v);
  //= isTrue() && isDAbefore(v) || isFalse();

  eq Expr.isDAafter(Variable v) = (isDAafterFalse(v) && isDAafterTrue(v)) || isDAbefore(v);

  eq InstanceOfExpr.isDAafterFalse(Variable v) = isDAafter(v);
  eq InstanceOfExpr.isDAafterTrue(Variable v) = isDAafter(v);

  eq ParExpr.isDAafterTrue(Variable v) = getExpr().isDAafterTrue(v) || isFalse();
  eq ParExpr.isDAafterFalse(Variable v) = getExpr().isDAafterFalse(v) || isTrue();

  syn lazy boolean VarAccess.isDAafter(Variable v) {
    return (isDest() && decl() == v) || isDAbefore(v);
  }
  eq AbstractDot.getRight().isDAbefore(Variable v) = getLeft().isDAafter(v);
  eq AbstractDot.isDAafter(Variable v) = lastAccess().isDAafter(v);

  eq ArrayAccess.isDAafter(Variable v) = getExpr().isDAafter(v);
  eq ArrayTypeAccess.isDAafter(Variable v) = getAccess().isDAafter(v);
  eq ArrayTypeWithSizeAccess.isDAafter(Variable v) = getExpr().isDAafter(v);
  eq ArrayTypeWithSizeAccess.getExpr().isDAbefore(Variable v) = getAccess().isDAafter(v);

  // 16.1.2 1st bullet
  eq AndLogicalExpr.isDAafterTrue(Variable v) = getRightOperand().isDAafterTrue(v) || isFalse();
  // 16.1.2 2nd bullet
  eq AndLogicalExpr.isDAafterFalse(Variable v) = (getLeftOperand().isDAafterFalse(v) && getRightOperand().isDAafterFalse(v)) || isTrue();
  // 16.1.2 3rd bullet
  eq AndLogicalExpr.getLeftOperand().isDAbefore(Variable v) = isDAbefore(v);
  // 16.1.2 4th bullet
  eq AndLogicalExpr.getRightOperand().isDAbefore(Variable v) = getLeftOperand().isDAafterTrue(v); 
  // 16.1.2 5th bullet
  eq AndLogicalExpr.isDAafter(Variable v) = isDAafterTrue(v) && isDAafterFalse(v);

  eq OrLogicalExpr.isDAafterTrue(Variable v) = (getLeftOperand().isDAafterTrue(v) && getRightOperand().isDAafterTrue(v)) || isFalse();
  eq OrLogicalExpr.isDAafterFalse(Variable v) = getRightOperand().isDAafterFalse(v) || isTrue();
  eq OrLogicalExpr.getLeftOperand().isDAbefore(Variable v) = isDAbefore(v);
  eq OrLogicalExpr.getRightOperand().isDAbefore(Variable v) = getLeftOperand().isDAafterFalse(v);
  eq OrLogicalExpr.isDAafter(Variable v) = isDAafterTrue(v) && isDAafterFalse(v);

  eq LogNotExpr.isDAafterTrue(Variable v) = getOperand().isDAafterFalse(v) || isFalse();
  eq LogNotExpr.isDAafterFalse(Variable v) = getOperand().isDAafterTrue(v) || isTrue();
  eq LogNotExpr.getOperand().isDAbefore(Variable v) = isDAbefore(v);
  eq LogNotExpr.isDAafter(Variable v) = isDAafterTrue(v) && isDAafterFalse(v);
  
  eq ConditionalExpr.isDAafterTrue(Variable v) = (getTrueExpr().isDAafterTrue(v) && getFalseExpr().isDAafterTrue(v)) || isFalse();
  eq ConditionalExpr.isDAafterFalse(Variable v) = (getTrueExpr().isDAafterFalse(v) && getFalseExpr().isDAafterFalse(v)) || isTrue();
  eq ConditionalExpr.getCondition().isDAbefore(Variable v) = isDAbefore(v);
  eq ConditionalExpr.getTrueExpr().isDAbefore(Variable v) = getCondition().isDAafterTrue(v);
  eq ConditionalExpr.getFalseExpr().isDAbefore(Variable v) = getCondition().isDAafterFalse(v);
  eq ConditionalExpr.isDAafter(Variable v) = booleanOperator() ? isDAafterTrue(v) && isDAafterFalse(v) : getTrueExpr().isDAafter(v) && getFalseExpr().isDAafter(v);

  //eq AssignExpr.isDAafter(Variable v) = (getDest().isVariable() && getDest().varDecl() == v) || getSource().isDAafter(v);
  eq AssignExpr.isDAafter(Variable v) = getSource().isDAafter(v);
  eq AssignExpr.getSource().isDAbefore(Variable v) = getDest().isDAafter(v);
  eq AssignExpr.getDest().isDAbefore(Variable v) = isDAbefore(v);

  eq AssignExpr.isDAafterTrue(Variable v) = isDAafter(v) || isFalse();
  eq AssignExpr.isDAafterFalse(Variable v) = isDAafter(v) || isTrue();

  eq ParExpr.isDAafter(Variable v) = getExpr().isDAafter(v);
  eq Unary.isDAafter(Variable v) = getOperand().isDAafter(v);
  eq CastExpr.isDAafter(Variable v) = getExpr().isDAafter(v);
  
  syn lazy boolean Binary.isDAafterTrue(Variable v) = getRightOperand().isDAafter(v) || isFalse();
  syn lazy boolean Binary.isDAafterFalse(Variable v) = getRightOperand().isDAafter(v) || isTrue();
  
  eq Binary.isDAafter(Variable v) = getRightOperand().isDAafter(v);
  eq Binary.getRightOperand().isDAbefore(Variable v) = getLeftOperand().isDAafter(v);

  eq InstanceOfExpr.isDAafter(Variable v) = getExpr().isDAafter(v);

  eq MethodAccess.getArg(int i).isDAbefore(Variable v) = computeDAbefore(i, v);
  syn lazy boolean MethodAccess.computeDAbefore(int i, Variable v) =
    i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v);
  eq MethodAccess.isDAafter(Variable v) = getNumArg() == 0 ? isDAbefore(v) : getArg(getNumArg()-1).isDAafter(v);
  
  eq EmptyStmt.isDAafter(Variable v) = isDAbefore(v);

  eq AssertStmt.isDAafter(Variable v) = getfirst().isDAafter(v);

  syn lazy boolean ClassInstanceExpr.isDAafterInstance(Variable v) {
    if(getNumArg() == 0)
      return isDAbefore(v);
    return getArg(getNumArg()-1).isDAafter(v);
  }
  eq ClassInstanceExpr.isDAafter(Variable v) = isDAafterInstance(v);
  eq ClassInstanceExpr.getArg(int i).isDAbefore(Variable v) = computeDAbefore(i, v);
  syn lazy boolean ClassInstanceExpr.computeDAbefore(int i, Variable v) =
    i == 0 ? isDAbefore(v) : getArg(i-1).isDAafter(v);
  eq ClassInstanceExpr.getTypeDecl().isDAbefore(Variable v) = isDAafterInstance(v);
  
  syn boolean ArrayCreationExpr.isDAafterCreation(Variable v) = getTypeAccess().isDAafter(v);
  eq ArrayCreationExpr.isDAafter(Variable v) = hasArrayInit() ? getArrayInit().isDAafter(v) : isDAafterCreation(v);
  eq ArrayCreationExpr.getArrayInit().isDAbefore(Variable v) = isDAafterCreation(v);

  // 16.2.2 1st bullet
  eq MethodDecl.getBlock().isDAbefore(Variable v) = v.isFinal() && (v.isClassVariable() || v.isInstanceVariable()) ? true : isDAbefore(v);
  eq InstanceInitializer.getBlock().isDAbefore(Variable v) = isDAbefore(v);
  eq StaticInitializer.getBlock().isDAbefore(Variable v) = isDAbefore(v);
  
  eq Block.isDAafter(Variable v) = getNumStmt() == 0 ? isDAbefore(v) : getStmt(getNumStmt()-1).isDAafter(v);

  // 16.2.2 7th bullet
  eq Block.getStmt(int index).isDAbefore(Variable v) = index == 0 ? isDAbefore(v) : getStmt(index - 1).isDAafter(v);

  // 16.2.2 8th, 9th, 10th bullet
  syn boolean Block.isDUeverywhere(Variable v) = isDUbefore(v) && checkDUeverywhere(v);

  // 16.2.2 9th, 10th bullet
  protected boolean ASTNode.checkDUeverywhere(Variable v) {
    for(int i = 0; i < getNumChild(); i++)
      if(!getChild(i).checkDUeverywhere(v))
        return false;
    return true;
  }

  protected boolean VarAccess.checkDUeverywhere(Variable v) {
    if(isDest() && decl() == v)
      return false;
    return super.checkDUeverywhere(v);
  }
  // 16.2.2 9th bullet
  protected boolean AssignExpr.checkDUeverywhere(Variable v) {
    if(getDest().isVariable() && getDest().varDecl() == v)
      if(!getSource().isDAafter(v))
        return false;
    return super.checkDUeverywhere(v);
  }
  
  // 16.2.2 10th bullet
  protected boolean PostfixExpr.checkDUeverywhere(Variable v) {
    if(getOperand().isVariable() && getOperand().varDecl() == v)
      if(!isDAbefore(v))
        return false;
    return super.checkDUeverywhere(v);
  }
  protected boolean PreIncExpr.checkDUeverywhere(Variable v) {
    if(getOperand().isVariable() && getOperand().varDecl() == v)
      if(!isDAbefore(v))
        return false;
    return super.checkDUeverywhere(v);
  }
  protected boolean PreDecExpr.checkDUeverywhere(Variable v) {
    if(getOperand().isVariable() && getOperand().varDecl() == v)
      if(!isDAbefore(v))
        return false;
    return super.checkDUeverywhere(v);
  }
  
  eq LocalClassDeclStmt.isDAafter(Variable v) = isDAbefore(v);

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

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

  eq ExprStmt.isDAafter(Variable v) = getExpr().isDAafter(v);
  eq ExprStmt.getExpr().isDAbefore(Variable v) = isDAbefore(v);

  eq IfStmt.isDAafter(Variable v) = hasElse() ? getThen().isDAafter(v) && getElse().isDAafter(v) : getThen().isDAafter(v) && getCondition().isDAafterFalse(v);
  eq IfStmt.getCondition().isDAbefore(Variable v) = isDAbefore(v);
  eq IfStmt.getThen().isDAbefore(Variable v) = getCondition().isDAafterTrue(v);
  eq IfStmt.getElse().isDAbefore(Variable v) = getCondition().isDAafterFalse(v);

  // 16.2.9 1st bullet
  eq SwitchStmt.isDAafter(Variable v) {
    if(!(!noDefaultLabel() || getExpr().isDAafter(v))) {
      return false;
    }
    if(!(!switchLabelEndsBlock() || getExpr().isDAafter(v))) {
      return false;
    }
    if(!assignedAfterLastStmt(v)) {
      return false;
    }
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

  syn boolean SwitchStmt.assignedAfterLastStmt(Variable v) =
    getBlock().isDAafter(v);
  
  // 16.2.9 2nd bullet
  eq SwitchStmt.getExpr().isDAbefore(Variable v) {
    if(((ASTNode)v).isDescendantTo(this))
      return false;
    boolean result = isDAbefore(v);
    return result;
  }

  protected boolean ASTNode.isDescendantTo(ASTNode node) {
    if(this == node)
      return true;
    if(getParent() == null)
      return false;
    return getParent().isDescendantTo(node);
  }

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

  syn lazy boolean Case.isDAbefore(Variable v) = 
    getParent().getParent() instanceof Block && ((Block)getParent().getParent()).isDAbefore(v)
    && super.isDAbefore(v);

  eq Case.isDAafter(Variable v) = isDAbefore(v);

  eq WhileStmt.isDAafter(Variable v) {
    if(!getCondition().isDAafterFalse(v))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }
  eq WhileStmt.getCondition().isDAbefore(Variable v) = isDAbefore(v);
  eq WhileStmt.getStmt().isDAbefore(Variable v) = getCondition().isDAafterTrue(v);

  eq DoStmt.isDAafter(Variable v) {
    if(!getCondition().isDAafterFalse(v))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }
  eq DoStmt.getStmt().isDAbefore(Variable v) = isDAbefore(v);
  eq DoStmt.getCondition().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;
  }
    
  // 16.2.11 1st bullet
  eq ForStmt.isDAafter(Variable v) {
    if(!(!hasCondition() || getCondition().isDAafterFalse(v)))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDAafterReachedFinallyBlocks(v))
        return false;
    }