definiteassignment.jrag

JDK1.4编译器前端

        return false;
    }
    return true;
  }
  
  syn lazy boolean ContinueStmt.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))
        return false;
    }
    return true;
  }
  syn lazy boolean ReturnStmt.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))
        return false;
    }
    return true;
  }

  syn lazy boolean BreakStmt.isDAafterReachedFinallyBlocks(Variable v) {
    if(isDAbefore(v))
      return true;
    if(finallyList().isEmpty())
      return false;
    for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
      FinallyHost f = (FinallyHost)iter.next();
      if(!f.isDAafterFinally(v))
        return false;
    }
    return true;
  }
  
  syn lazy boolean ContinueStmt.isDAafterReachedFinallyBlocks(Variable v) {
    if(isDAbefore(v))
      return true;
    if(finallyList().isEmpty())
      return false;
    for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
      FinallyHost f = (FinallyHost)iter.next();
      if(!f.isDAafterFinally(v))
        return false;
    }
    return true;
  }
  syn lazy boolean ReturnStmt.isDAafterReachedFinallyBlocks(Variable v) {
    if(hasResult() ? getResult().isDAafter(v) : isDAbefore(v))
      return true;
    if(finallyList().isEmpty())
      return false;
    for(Iterator iter = finallyList().iterator(); iter.hasNext(); ) {
      FinallyHost f = (FinallyHost)iter.next();
      if(!f.isDAafterFinally(v))
        return false;
    }
    return true;
  }

  eq ExprStmt.isDUafter(Variable v) = getExpr().isDUafter(v);
  eq ExprStmt.getExpr().isDUbefore(Variable v) = isDUbefore(v);

  eq IfStmt.isDUafter(Variable v) = hasElse() ? getThen().isDUafter(v) && getElse().isDUafter(v) : getThen().isDUafter(v) && getCondition().isDUafterFalse(v);
  eq IfStmt.getCondition().isDUbefore(Variable v) = isDUbefore(v);
  eq IfStmt.getThen().isDUbefore(Variable v) = getCondition().isDUafterTrue(v);
  eq IfStmt.getElse().isDUbefore(Variable v) = getCondition().isDUafterFalse(v);

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

  syn boolean SwitchStmt.unassignedAfterLastStmt(Variable v) =
    getBlock().isDUafter(v);
  
  syn boolean SwitchStmt.switchLabelEndsBlock() =
    getBlock().getNumStmt() > 0 && getBlock().getStmt(getBlock().getNumStmt()-1) instanceof ConstCase;
  
  // 16.2.8 2nd bullet
  eq SwitchStmt.getExpr().isDUbefore(Variable v) = isDUbefore(v);
  eq SwitchStmt.getBlock().isDUbefore(Variable v) = getExpr().isDUafter(v);

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

  eq Case.isDUafter(Variable v) = isDUbefore(v);

  // 16.2.10 1st bullet
  eq WhileStmt.isDUafter(Variable v) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(!getCondition().isDUafterFalse(v))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

  // 16.2.10 3rd bullet
  eq WhileStmt.getCondition().isDUbefore(Variable v) = isDUbeforeCondition(v);

  // 16.2.10 3rd bullet
  syn boolean WhileStmt.isDUbeforeCondition(Variable v) circular [true] {
    // 1st
    if(!isDUbefore(v))
      return false;
    else if(!getStmt().isDUafter(v))
      return false;
    else {
      for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
        ContinueStmt stmt = (ContinueStmt)iter.next();
        if(!stmt.isDUafterReachedFinallyBlocks(v))
          return false;
      }
    }
    return true;
  }
  
  // 16.2.10 4th bullet
  eq WhileStmt.getStmt().isDUbefore(Variable v) = getCondition().isDUafterTrue(v);

  eq DoStmt.isDUafter(Variable v) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(!getCondition().isDUafterFalse(v))
      return false;
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }
  eq DoStmt.getStmt().isDUbefore(Variable v) = isDUbefore(v) && getCondition().isDUafterTrue(v);
  eq DoStmt.getCondition().isDUbefore(Variable v) = isDUbeforeCondition(v);
  syn boolean DoStmt.isDUbeforeCondition(Variable v) circular [true] {
    if(!getStmt().isDUafter(v))
      return false;
    else {
      for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
        ContinueStmt stmt = (ContinueStmt)iter.next();
        if(!stmt.isDUafterReachedFinallyBlocks(v))
          return false;
      }
    }
    return true;
  }
    
  // 16.2.11 1st bullet
  eq ForStmt.isDUafter(Variable v) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(!(!hasCondition() || getCondition().isDUafterFalse(v))) {
      return false;
    }
    for(Iterator iter = targetBreaks().iterator(); iter.hasNext(); ) {
      BreakStmt stmt = (BreakStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    //if(!isDUafterUpdate(v))
    //  return false;
    return true;
  }
  // 16.2.11 2nd  bullet
  eq ForStmt.getInitStmt().isDUbefore(Variable v) = childIndex == 0 ? isDUbefore(v) : getInitStmt(childIndex-1).isDUafter(v);
  // 16.2.11 3rd bullet
  eq ForStmt.getCondition().isDUbefore(Variable v) = isDUbeforeCondition(v);
  // 16.2.11 3rd bullet
  syn boolean ForStmt.isDUafterInit(Variable v) = getNumInitStmt() == 0 ? isDUbefore(v) : getInitStmt(getNumInitStmt()-1).isDUafter(v);
  // 16.2.11 4th bullet
  syn boolean ForStmt.isDUbeforeCondition(Variable v) circular [true] {
    if(!isDUafterInit(v))
      return false;
    else if(!isDUafterUpdate(v))
      return false;
    return true;
  }
  // 16.2.11 5th bullet
  eq ForStmt.getStmt().isDUbefore(Variable v) = isDUbeforeCondition(v) && (hasCondition() ?
    getCondition().isDUafterTrue(v) : isDUafterInit(v));

  syn boolean ForStmt.isDUafterUpdate(Variable v) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(getNumUpdateStmt() > 0)
      return getUpdateStmt(getNumUpdateStmt()-1).isDUafter(v);
    if(!getStmt().isDUafter(v))
      return false;
    for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
      ContinueStmt stmt = (ContinueStmt)iter.next();
      if(!stmt.isDUafterReachedFinallyBlocks(v))
        return false;
    }
    return true;
  }

  // 16.2.11 6th bullet
  eq ForStmt.getUpdateStmt(int i).isDUbefore(Variable v) {
    if(!isDUbeforeCondition(v)) // start a circular evaluation here
      return false;
    if(i == 0) {
      if(!getStmt().isDUafter(v))
        return false;
      for(Iterator iter = targetContinues().iterator(); iter.hasNext(); ) {
        ContinueStmt stmt = (ContinueStmt)iter.next();
        if(!stmt.isDUafterReachedFinallyBlocks(v))
          return false;
      }
      return true;
    }
    else
      return getUpdateStmt(i-1).isDUafter(v);
  }

  rewrite ForStmt {
    when (!hasCondition())
    to ForStmt {
      setCondition(new BooleanLiteral("true"));
      return this;
    }
  }

  eq BreakStmt.isDUafter(Variable v) = true;
  eq ContinueStmt.isDUafter(Variable v) = true;
  eq ReturnStmt.isDUafter(Variable v) = true;
  eq ThrowStmt.isDUafter(Variable v) = true;
  
  eq ReturnStmt.getResult().isDUbefore(Variable v) = isDUbefore(v);
  eq ThrowStmt.getExpr().isDUbefore(Variable v) = isDUbefore(v);

  eq SynchronizedStmt.isDUafter(Variable v) = getBlock().isDUafter(v);
  eq SynchronizedStmt.getExpr().isDUbefore(Variable v) = isDUbefore(v);
  eq SynchronizedStmt.getBlock().isDUbefore(Variable v) = getExpr().isDUafter(v);

  // 16.2.15 1st bullet
  eq TryStmt.getBlock().isDUbefore(Variable v) = isDUbefore(v);

  syn boolean TryStmt.isDUbefore(Variable v) circular [true] = super.isDUbefore(v);

  // 16.2.15 3rd bullet
  eq TryStmt.getCatchClause().isDUbefore(Variable v) {
    if(!getBlock().isDUafter(v))
      return false;
    if(!getBlock().isDUeverywhere(v))
      return false;
    return true;
  }

  syn boolean ASTNode.unassignedEverywhere(Variable v, TryStmt stmt) {
    for(int i = 0; i < getNumChild(); i++) {
      if(!getChild(i).unassignedEverywhere(v, stmt))
        return false;
    }
    return true;
  }

  eq VarAccess.unassignedEverywhere(Variable v, TryStmt stmt) {
    if(isDest() && decl() == v && enclosingStmt().reachable()) {
      return false;
    }
    return super.unassignedEverywhere(v, stmt);
  }

  // 16.2.14 6th bullet
  eq TryStmt.getFinally().isDUbefore(Variable v) {
    if(!getBlock().isDUeverywhere(v))
      return false;
    for(int i = 0; i < getNumCatchClause(); i++)
      if(!getCatchClause(i).getBlock().unassignedEverywhere(v, this))
        return false;
    return true;
  }
  
  eq TryStmt.isDUafter(Variable v) {
    // 16.2.14 4th bullet
    if(!hasFinally()) {
      if(!getBlock().isDUafter(v))
        return false;
      for(int i = 0; i < getNumCatchClause(); i++)
        if(!getCatchClause(i).getBlock().isDUafter(v))
          return false;
      return true;
    }
    else
      return getFinally().isDUafter(v);
  }
}