jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/comp/Flow.java@366a7b9b5627 (annotated)

src/share/classes/com/sun/tools/javac/comp/Flow.java@366a7b9b5627 (annotated)

src/share/classes/com/sun/tools/javac/comp/Flow.java

Thu, 10 Jun 2010 17:09:56 -0700

author: jjg
date: Thu, 10 Jun 2010 17:09:56 -0700
changeset 582: 366a7b9b5627
parent 581: f2fdd52e4e87
child 609: 13354e1abba7
permissions: -rw-r--r--

6960407: Potential rebranding issues in openjdk/langtools repository sources
Reviewed-by: darcy

 /*
  * Copyright (c) 1999, 2009, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 //todo: one might eliminate uninits.andSets when monotonic
 package com.sun.tools.javac.comp;
 import java.util.HashMap;
 import com.sun.tools.javac.code.*;
 import com.sun.tools.javac.tree.*;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
 import com.sun.tools.javac.code.Symbol.*;
 import com.sun.tools.javac.tree.JCTree.*;
 import static com.sun.tools.javac.code.Flags.*;
 import static com.sun.tools.javac.code.Kinds.*;
 import static com.sun.tools.javac.code.TypeTags.*;
 /** This pass implements dataflow analysis for Java programs.
  *  Liveness analysis checks that every statement is reachable.
  *  Exception analysis ensures that every checked exception that is
  *  thrown is declared or caught.  Definite assignment analysis
  *  ensures that each variable is assigned when used.  Definite
  *  unassignment analysis ensures that no final variable is assigned
  *  more than once.
  *
  *  <p>The second edition of the JLS has a number of problems in the
  *  specification of these flow analysis problems. This implementation
  *  attempts to address those issues.
  *
  *  <p>First, there is no accommodation for a finally clause that cannot
  *  complete normally. For liveness analysis, an intervening finally
  *  clause can cause a break, continue, or return not to reach its
  *  target.  For exception analysis, an intervening finally clause can
  *  cause any exception to be "caught".  For DA/DU analysis, the finally
  *  clause can prevent a transfer of control from propagating DA/DU
  *  state to the target.  In addition, code in the finally clause can
  *  affect the DA/DU status of variables.
  *
  *  <p>For try statements, we introduce the idea of a variable being
  *  definitely unassigned "everywhere" in a block.  A variable V is
  *  "unassigned everywhere" in a block iff it is unassigned at the
  *  beginning of the block and there is no reachable assignment to V
  *  in the block.  An assignment V=e is reachable iff V is not DA
  *  after e.  Then we can say that V is DU at the beginning of the
  *  catch block iff V is DU everywhere in the try block.  Similarly, V
  *  is DU at the beginning of the finally block iff V is DU everywhere
  *  in the try block and in every catch block.  Specifically, the
  *  following bullet is added to 16.2.2
  *  <pre>
  *      V is <em>unassigned everywhere</em> in a block if it is
  *      unassigned before the block and there is no reachable
  *      assignment to V within the block.
  *  </pre>
  *  <p>In 16.2.15, the third bullet (and all of its sub-bullets) for all
  *  try blocks is changed to
  *  <pre>
  *      V is definitely unassigned before a catch block iff V is
  *      definitely unassigned everywhere in the try block.
  *  </pre>
  *  <p>The last bullet (and all of its sub-bullets) for try blocks that
  *  have a finally block is changed to
  *  <pre>
  *      V is definitely unassigned before the finally block iff
  *      V is definitely unassigned everywhere in the try block
  *      and everywhere in each catch block of the try statement.
  *  </pre>
  *  <p>In addition,
  *  <pre>
  *      V is definitely assigned at the end of a constructor iff
  *      V is definitely assigned after the block that is the body
  *      of the constructor and V is definitely assigned at every
  *      return that can return from the constructor.
  *  </pre>
  *  <p>In addition, each continue statement with the loop as its target
  *  is treated as a jump to the end of the loop body, and "intervening"
  *  finally clauses are treated as follows: V is DA "due to the
  *  continue" iff V is DA before the continue statement or V is DA at
  *  the end of any intervening finally block.  V is DU "due to the
  *  continue" iff any intervening finally cannot complete normally or V
  *  is DU at the end of every intervening finally block.  This "due to
  *  the continue" concept is then used in the spec for the loops.
  *
  *  <p>Similarly, break statements must consider intervening finally
  *  blocks.  For liveness analysis, a break statement for which any
  *  intervening finally cannot complete normally is not considered to
  *  cause the target statement to be able to complete normally. Then
  *  we say V is DA "due to the break" iff V is DA before the break or
  *  V is DA at the end of any intervening finally block.  V is DU "due
  *  to the break" iff any intervening finally cannot complete normally
  *  or V is DU at the break and at the end of every intervening
  *  finally block.  (I suspect this latter condition can be
  *  simplified.)  This "due to the break" is then used in the spec for
  *  all statements that can be "broken".
  *
  *  <p>The return statement is treated similarly.  V is DA "due to a
  *  return statement" iff V is DA before the return statement or V is
  *  DA at the end of any intervening finally block.  Note that we
  *  don't have to worry about the return expression because this
  *  concept is only used for construcrors.
  *
  *  <p>There is no spec in JLS2 for when a variable is definitely
  *  assigned at the end of a constructor, which is needed for final
  *  fields (8.3.1.2).  We implement the rule that V is DA at the end
  *  of the constructor iff it is DA and the end of the body of the
  *  constructor and V is DA "due to" every return of the constructor.
  *
  *  <p>Intervening finally blocks similarly affect exception analysis.  An
  *  intervening finally that cannot complete normally allows us to ignore
  *  an otherwise uncaught exception.
  *
  *  <p>To implement the semantics of intervening finally clauses, all
  *  nonlocal transfers (break, continue, return, throw, method call that
  *  can throw a checked exception, and a constructor invocation that can
  *  thrown a checked exception) are recorded in a queue, and removed
  *  from the queue when we complete processing the target of the
  *  nonlocal transfer.  This allows us to modify the queue in accordance
  *  with the above rules when we encounter a finally clause.  The only
  *  exception to this [no pun intended] is that checked exceptions that
  *  are known to be caught or declared to be caught in the enclosing
  *  method are not recorded in the queue, but instead are recorded in a
  *  global variable "Set<Type> thrown" that records the type of all
  *  exceptions that can be thrown.
  *
  *  <p>Other minor issues the treatment of members of other classes
  *  (always considered DA except that within an anonymous class
  *  constructor, where DA status from the enclosing scope is
  *  preserved), treatment of the case expression (V is DA before the
  *  case expression iff V is DA after the switch expression),
  *  treatment of variables declared in a switch block (the implied
  *  DA/DU status after the switch expression is DU and not DA for
  *  variables defined in a switch block), the treatment of boolean ?:
  *  expressions (The JLS rules only handle b and c non-boolean; the
  *  new rule is that if b and c are boolean valued, then V is
  *  (un)assigned after a?b:c when true/false iff V is (un)assigned
  *  after b when true/false and V is (un)assigned after c when
  *  true/false).
  *
  *  <p>There is the remaining question of what syntactic forms constitute a
  *  reference to a variable.  It is conventional to allow this.x on the
  *  left-hand-side to initialize a final instance field named x, yet
  *  this.x isn't considered a "use" when appearing on a right-hand-side
  *  in most implementations.  Should parentheses affect what is
  *  considered a variable reference?  The simplest rule would be to
  *  allow unqualified forms only, parentheses optional, and phase out
  *  support for assigning to a final field via this.x.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class Flow extends TreeScanner {
     protected static final Context.Key<Flow> flowKey =
         new Context.Key<Flow>();
     private final Names names;
     private final Log log;
     private final Symtab syms;
     private final Types types;
     private final Check chk;
     private       TreeMaker make;
     private       Lint lint;
     private final boolean allowRethrowAnalysis;
     public static Flow instance(Context context) {
         Flow instance = context.get(flowKey);
         if (instance == null)
             instance = new Flow(context);
         return instance;
     }
     protected Flow(Context context) {
         context.put(flowKey, this);
         names = Names.instance(context);
         log = Log.instance(context);
         syms = Symtab.instance(context);
         types = Types.instance(context);
         chk = Check.instance(context);
         lint = Lint.instance(context);
         Source source = Source.instance(context);
         allowRethrowAnalysis = source.allowMulticatch();
     }
     /** A flag that indicates whether the last statement could
      *  complete normally.
      */
     private boolean alive;
     /** The set of definitely assigned variables.
      */
     Bits inits;
     /** The set of definitely unassigned variables.
      */
     Bits uninits;
     HashMap<Symbol, List<Type>> multicatchTypes;
     /** The set of variables that are definitely unassigned everywhere
      *  in current try block. This variable is maintained lazily; it is
      *  updated only when something gets removed from uninits,
      *  typically by being assigned in reachable code.  To obtain the
      *  correct set of variables which are definitely unassigned
      *  anywhere in current try block, intersect uninitsTry and
      *  uninits.
      */
     Bits uninitsTry;
     /** When analyzing a condition, inits and uninits are null.
      *  Instead we have:
      */
     Bits initsWhenTrue;
     Bits initsWhenFalse;
     Bits uninitsWhenTrue;
     Bits uninitsWhenFalse;
     /** A mapping from addresses to variable symbols.
      */
     VarSymbol[] vars;
     /** The current class being defined.
      */
     JCClassDecl classDef;
     /** The first variable sequence number in this class definition.
      */
     int firstadr;
     /** The next available variable sequence number.
      */
     int nextadr;
     /** The list of possibly thrown declarable exceptions.
      */
     List<Type> thrown;
     /** The list of exceptions that are either caught or declared to be
      *  thrown.
      */
     List<Type> caught;
     /** Set when processing a loop body the second time for DU analysis. */
     boolean loopPassTwo = false;
     /*-------------------- Environments ----------------------*/
     /** A pending exit.  These are the statements return, break, and
      *  continue.  In addition, exception-throwing expressions or
      *  statements are put here when not known to be caught.  This
      *  will typically result in an error unless it is within a
      *  try-finally whose finally block cannot complete normally.
      */
     static class PendingExit {
         JCTree tree;
         Bits inits;
         Bits uninits;
         Type thrown;
         PendingExit(JCTree tree, Bits inits, Bits uninits) {
             this.tree = tree;
             this.inits = inits.dup();
             this.uninits = uninits.dup();
         }
         PendingExit(JCTree tree, Type thrown) {
             this.tree = tree;
             this.thrown = thrown;
         }
     }
     /** The currently pending exits that go from current inner blocks
      *  to an enclosing block, in source order.
      */
     ListBuffer<PendingExit> pendingExits;
     /*-------------------- Exceptions ----------------------*/
     /** Complain that pending exceptions are not caught.
      */
     void errorUncaught() {
         for (PendingExit exit = pendingExits.next();
              exit != null;
              exit = pendingExits.next()) {
             boolean synthetic = classDef != null &&
                 classDef.pos == exit.tree.pos;
             log.error(exit.tree.pos(),
                       synthetic
                       ? "unreported.exception.default.constructor"
                       : "unreported.exception.need.to.catch.or.throw",
                       exit.thrown);
         }
     }
     /** Record that exception is potentially thrown and check that it
      *  is caught.
      */
     void markThrown(JCTree tree, Type exc) {
         if (!chk.isUnchecked(tree.pos(), exc)) {
             if (!chk.isHandled(exc, caught))
                 pendingExits.append(new PendingExit(tree, exc));
             thrown = chk.incl(exc, thrown);
         }
     }
     /*-------------- Processing variables ----------------------*/
     /** Do we need to track init/uninit state of this symbol?
      *  I.e. is symbol either a local or a blank final variable?
      */
     boolean trackable(VarSymbol sym) {
         return
             (sym.owner.kind == MTH ||
              ((sym.flags() & (FINAL | HASINIT | PARAMETER)) == FINAL &&
               classDef.sym.isEnclosedBy((ClassSymbol)sym.owner)));
     }
     /** Initialize new trackable variable by setting its address field
      *  to the next available sequence number and entering it under that
      *  index into the vars array.
      */
     void newVar(VarSymbol sym) {
         if (nextadr == vars.length) {
             VarSymbol[] newvars = new VarSymbol[nextadr * 2];
             System.arraycopy(vars, 0, newvars, 0, nextadr);
             vars = newvars;
         }
         sym.adr = nextadr;
         vars[nextadr] = sym;
         inits.excl(nextadr);
         uninits.incl(nextadr);
         nextadr++;
     }
     /** Record an initialization of a trackable variable.
      */
     void letInit(DiagnosticPosition pos, VarSymbol sym) {
         if (sym.adr >= firstadr && trackable(sym)) {
             if ((sym.flags() & FINAL) != 0) {
                 if ((sym.flags() & PARAMETER) != 0) {
                     if ((sym.flags() & DISJOINT) != 0) { //multi-catch parameter
                         log.error(pos, "multicatch.parameter.may.not.be.assigned",
                                   sym);
                     }
                     else {
                         log.error(pos, "final.parameter.may.not.be.assigned",
                               sym);
                     }
                 } else if (!uninits.isMember(sym.adr)) {
                     log.error(pos,
                               loopPassTwo
                               ? "var.might.be.assigned.in.loop"
                               : "var.might.already.be.assigned",
                               sym);
                 } else if (!inits.isMember(sym.adr)) {
                     // reachable assignment
                     uninits.excl(sym.adr);
                     uninitsTry.excl(sym.adr);
                 } else {
                     //log.rawWarning(pos, "unreachable assignment");//DEBUG
                     uninits.excl(sym.adr);
                 }
             }
             inits.incl(sym.adr);
         } else if ((sym.flags() & FINAL) != 0) {
             log.error(pos, "var.might.already.be.assigned", sym);
         }
     }
     /** If tree is either a simple name or of the form this.name or
      *  C.this.name, and tree represents a trackable variable,
      *  record an initialization of the variable.
      */
     void letInit(JCTree tree) {
         tree = TreeInfo.skipParens(tree);
         if (tree.getTag() == JCTree.IDENT || tree.getTag() == JCTree.SELECT) {
             Symbol sym = TreeInfo.symbol(tree);
             letInit(tree.pos(), (VarSymbol)sym);
         }
     }
     /** Check that trackable variable is initialized.
      */
     void checkInit(DiagnosticPosition pos, VarSymbol sym) {
         if ((sym.adr >= firstadr || sym.owner.kind != TYP) &&
             trackable(sym) &&
             !inits.isMember(sym.adr)) {
             log.error(pos, "var.might.not.have.been.initialized",
                       sym);
             inits.incl(sym.adr);
         }
     }
     /*-------------------- Handling jumps ----------------------*/
     /** Record an outward transfer of control. */
     void recordExit(JCTree tree) {
         pendingExits.append(new PendingExit(tree, inits, uninits));
         markDead();
     }
     /** Resolve all breaks of this statement. */
     boolean resolveBreaks(JCTree tree,
                           ListBuffer<PendingExit> oldPendingExits) {
         boolean result = false;
         List<PendingExit> exits = pendingExits.toList();
         pendingExits = oldPendingExits;
         for (; exits.nonEmpty(); exits = exits.tail) {
             PendingExit exit = exits.head;
             if (exit.tree.getTag() == JCTree.BREAK &&
                 ((JCBreak) exit.tree).target == tree) {
                 inits.andSet(exit.inits);
                 uninits.andSet(exit.uninits);
                 result = true;
             } else {
                 pendingExits.append(exit);
             }
         }
         return result;
     }
     /** Resolve all continues of this statement. */
     boolean resolveContinues(JCTree tree) {
         boolean result = false;
         List<PendingExit> exits = pendingExits.toList();
         pendingExits = new ListBuffer<PendingExit>();
         for (; exits.nonEmpty(); exits = exits.tail) {
             PendingExit exit = exits.head;
             if (exit.tree.getTag() == JCTree.CONTINUE &&
                 ((JCContinue) exit.tree).target == tree) {
                 inits.andSet(exit.inits);
                 uninits.andSet(exit.uninits);
                 result = true;
             } else {
                 pendingExits.append(exit);
             }
         }
         return result;
     }
     /** Record that statement is unreachable.
      */
     void markDead() {
         inits.inclRange(firstadr, nextadr);
         uninits.inclRange(firstadr, nextadr);
         alive = false;
     }
     /** Split (duplicate) inits/uninits into WhenTrue/WhenFalse sets
      */
     void split() {
         initsWhenFalse = inits.dup();
         uninitsWhenFalse = uninits.dup();
         initsWhenTrue = inits;
         uninitsWhenTrue = uninits;
         inits = uninits = null;
     }
     /** Merge (intersect) inits/uninits from WhenTrue/WhenFalse sets.
      */
     void merge() {
         inits = initsWhenFalse.andSet(initsWhenTrue);
         uninits = uninitsWhenFalse.andSet(uninitsWhenTrue);
     }
 /* ************************************************************************
  * Visitor methods for statements and definitions
  *************************************************************************/
     /** Analyze a definition.
      */
     void scanDef(JCTree tree) {
         scanStat(tree);
         if (tree != null && tree.getTag() == JCTree.BLOCK && !alive) {
             log.error(tree.pos(),
                       "initializer.must.be.able.to.complete.normally");
         }
     }
     /** Analyze a statement. Check that statement is reachable.
      */
     void scanStat(JCTree tree) {
         if (!alive && tree != null) {
             log.error(tree.pos(), "unreachable.stmt");
             if (tree.getTag() != JCTree.SKIP) alive = true;
         }
         scan(tree);
     }
     /** Analyze list of statements.
      */
     void scanStats(List<? extends JCStatement> trees) {
         if (trees != null)
             for (List<? extends JCStatement> l = trees; l.nonEmpty(); l = l.tail)
                 scanStat(l.head);
     }
     /** Analyze an expression. Make sure to set (un)inits rather than
      *  (un)initsWhenTrue(WhenFalse) on exit.
      */
     void scanExpr(JCTree tree) {
         if (tree != null) {
             scan(tree);
             if (inits == null) merge();
         }
     }
     /** Analyze a list of expressions.
      */
     void scanExprs(List<? extends JCExpression> trees) {
         if (trees != null)
             for (List<? extends JCExpression> l = trees; l.nonEmpty(); l = l.tail)
                 scanExpr(l.head);
     }
     /** Analyze a condition. Make sure to set (un)initsWhenTrue(WhenFalse)
      *  rather than (un)inits on exit.
      */
     void scanCond(JCTree tree) {
         if (tree.type.isFalse()) {
             if (inits == null) merge();
             initsWhenTrue = inits.dup();
             initsWhenTrue.inclRange(firstadr, nextadr);
             uninitsWhenTrue = uninits.dup();
             uninitsWhenTrue.inclRange(firstadr, nextadr);
             initsWhenFalse = inits;
             uninitsWhenFalse = uninits;
         } else if (tree.type.isTrue()) {
             if (inits == null) merge();
             initsWhenFalse = inits.dup();
             initsWhenFalse.inclRange(firstadr, nextadr);
             uninitsWhenFalse = uninits.dup();
             uninitsWhenFalse.inclRange(firstadr, nextadr);
             initsWhenTrue = inits;
             uninitsWhenTrue = uninits;
         } else {
             scan(tree);
             if (inits != null) split();
         }
         inits = uninits = null;
     }
     /* ------------ Visitor methods for various sorts of trees -------------*/
     public void visitClassDef(JCClassDecl tree) {
         if (tree.sym == null) return;
         JCClassDecl classDefPrev = classDef;
         List<Type> thrownPrev = thrown;
         List<Type> caughtPrev = caught;
         boolean alivePrev = alive;
         int firstadrPrev = firstadr;
         int nextadrPrev = nextadr;
         ListBuffer<PendingExit> pendingExitsPrev = pendingExits;
         Lint lintPrev = lint;
         pendingExits = new ListBuffer<PendingExit>();
         if (tree.name != names.empty) {
             caught = List.nil();
             firstadr = nextadr;
         }
         classDef = tree;
         thrown = List.nil();
         lint = lint.augment(tree.sym.attributes_field);
         try {
             // define all the static fields
             for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                 if (l.head.getTag() == JCTree.VARDEF) {
                     JCVariableDecl def = (JCVariableDecl)l.head;
                     if ((def.mods.flags & STATIC) != 0) {
                         VarSymbol sym = def.sym;
                         if (trackable(sym))
                             newVar(sym);
                     }
                 }
             }
             // process all the static initializers
             for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                 if (l.head.getTag() != JCTree.METHODDEF &&
                     (TreeInfo.flags(l.head) & STATIC) != 0) {
                     scanDef(l.head);
                     errorUncaught();
                 }
             }
             // add intersection of all thrown clauses of initial constructors
             // to set of caught exceptions, unless class is anonymous.
             if (tree.name != names.empty) {
                 boolean firstConstructor = true;
                 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                     if (TreeInfo.isInitialConstructor(l.head)) {
                         List<Type> mthrown =
                             ((JCMethodDecl) l.head).sym.type.getThrownTypes();
                         if (firstConstructor) {
                             caught = mthrown;
                             firstConstructor = false;
                         } else {
                             caught = chk.intersect(mthrown, caught);
                         }
                     }
                 }
             }
             // define all the instance fields
             for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                 if (l.head.getTag() == JCTree.VARDEF) {
                     JCVariableDecl def = (JCVariableDecl)l.head;
                     if ((def.mods.flags & STATIC) == 0) {
                         VarSymbol sym = def.sym;
                         if (trackable(sym))
                             newVar(sym);
                     }
                 }
             }
             // process all the instance initializers
             for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                 if (l.head.getTag() != JCTree.METHODDEF &&
                     (TreeInfo.flags(l.head) & STATIC) == 0) {
                     scanDef(l.head);
                     errorUncaught();
                 }
             }
             // in an anonymous class, add the set of thrown exceptions to
             // the throws clause of the synthetic constructor and propagate
             // outwards.
             if (tree.name == names.empty) {
                 for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                     if (TreeInfo.isInitialConstructor(l.head)) {
                         JCMethodDecl mdef = (JCMethodDecl)l.head;
                         mdef.thrown = make.Types(thrown);
                         mdef.sym.type.setThrown(thrown);
                     }
                 }
                 thrownPrev = chk.union(thrown, thrownPrev);
             }
             // process all the methods
             for (List<JCTree> l = tree.defs; l.nonEmpty(); l = l.tail) {
                 if (l.head.getTag() == JCTree.METHODDEF) {
                     scan(l.head);
                     errorUncaught();
                 }
             }
             thrown = thrownPrev;
         } finally {
             pendingExits = pendingExitsPrev;
             alive = alivePrev;
             nextadr = nextadrPrev;
             firstadr = firstadrPrev;
             caught = caughtPrev;
             classDef = classDefPrev;
             lint = lintPrev;
         }
     }
     public void visitMethodDef(JCMethodDecl tree) {
         if (tree.body == null) return;
         List<Type> caughtPrev = caught;
         List<Type> mthrown = tree.sym.type.getThrownTypes();
         Bits initsPrev = inits.dup();
         Bits uninitsPrev = uninits.dup();
         int nextadrPrev = nextadr;
         int firstadrPrev = firstadr;
         Lint lintPrev = lint;
         lint = lint.augment(tree.sym.attributes_field);
         assert pendingExits.isEmpty();
         try {
             boolean isInitialConstructor =
                 TreeInfo.isInitialConstructor(tree);
             if (!isInitialConstructor)
                 firstadr = nextadr;
             for (List<JCVariableDecl> l = tree.params; l.nonEmpty(); l = l.tail) {
                 JCVariableDecl def = l.head;
                 scan(def);
                 inits.incl(def.sym.adr);
                 uninits.excl(def.sym.adr);
             }
             if (isInitialConstructor)
                 caught = chk.union(caught, mthrown);
             else if ((tree.sym.flags() & (BLOCK | STATIC)) != BLOCK)
                 caught = mthrown;
             // else we are in an instance initializer block;
             // leave caught unchanged.
             alive = true;
             scanStat(tree.body);
             if (alive && tree.sym.type.getReturnType().tag != VOID)
                 log.error(TreeInfo.diagEndPos(tree.body), "missing.ret.stmt");
             if (isInitialConstructor) {
                 for (int i = firstadr; i < nextadr; i++)
                     if (vars[i].owner == classDef.sym)
                         checkInit(TreeInfo.diagEndPos(tree.body), vars[i]);
             }
             List<PendingExit> exits = pendingExits.toList();
             pendingExits = new ListBuffer<PendingExit>();
             while (exits.nonEmpty()) {
                 PendingExit exit = exits.head;
                 exits = exits.tail;
                 if (exit.thrown == null) {
                     assert exit.tree.getTag() == JCTree.RETURN;
                     if (isInitialConstructor) {
                         inits = exit.inits;
                         for (int i = firstadr; i < nextadr; i++)
                             checkInit(exit.tree.pos(), vars[i]);
                     }
                 } else {
                     // uncaught throws will be reported later
                     pendingExits.append(exit);
                 }
             }
         } finally {
             inits = initsPrev;
             uninits = uninitsPrev;
             nextadr = nextadrPrev;
             firstadr = firstadrPrev;
             caught = caughtPrev;
             lint = lintPrev;
         }
     }
     public void visitVarDef(JCVariableDecl tree) {
         boolean track = trackable(tree.sym);
         if (track && tree.sym.owner.kind == MTH) newVar(tree.sym);
         if (tree.init != null) {
             Lint lintPrev = lint;
             lint = lint.augment(tree.sym.attributes_field);
             try{
                 scanExpr(tree.init);
                 if (track) letInit(tree.pos(), tree.sym);
             } finally {
                 lint = lintPrev;
             }
         }
     }
     public void visitBlock(JCBlock tree) {
         int nextadrPrev = nextadr;
         scanStats(tree.stats);
         nextadr = nextadrPrev;
     }
     public void visitDoLoop(JCDoWhileLoop tree) {
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         boolean prevLoopPassTwo = loopPassTwo;
         pendingExits = new ListBuffer<PendingExit>();
         do {
             Bits uninitsEntry = uninits.dup();
             scanStat(tree.body);
             alive |= resolveContinues(tree);
             scanCond(tree.cond);
             if (log.nerrors != 0 ||
                 loopPassTwo ||
                 uninitsEntry.diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
                 break;
             inits = initsWhenTrue;
             uninits = uninitsEntry.andSet(uninitsWhenTrue);
             loopPassTwo = true;
             alive = true;
         } while (true);
         loopPassTwo = prevLoopPassTwo;
         inits = initsWhenFalse;
         uninits = uninitsWhenFalse;
         alive = alive && !tree.cond.type.isTrue();
         alive |= resolveBreaks(tree, prevPendingExits);
     }
     public void visitWhileLoop(JCWhileLoop tree) {
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         boolean prevLoopPassTwo = loopPassTwo;
         Bits initsCond;
         Bits uninitsCond;
         pendingExits = new ListBuffer<PendingExit>();
         do {
             Bits uninitsEntry = uninits.dup();
             scanCond(tree.cond);
             initsCond = initsWhenFalse;
             uninitsCond = uninitsWhenFalse;
             inits = initsWhenTrue;
             uninits = uninitsWhenTrue;
             alive = !tree.cond.type.isFalse();
             scanStat(tree.body);
             alive |= resolveContinues(tree);
             if (log.nerrors != 0 ||
                 loopPassTwo ||
                 uninitsEntry.diffSet(uninits).nextBit(firstadr) == -1)
                 break;
             uninits = uninitsEntry.andSet(uninits);
             loopPassTwo = true;
             alive = true;
         } while (true);
         loopPassTwo = prevLoopPassTwo;
         inits = initsCond;
         uninits = uninitsCond;
         alive = resolveBreaks(tree, prevPendingExits) ||
             !tree.cond.type.isTrue();
     }
     public void visitForLoop(JCForLoop tree) {
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         boolean prevLoopPassTwo = loopPassTwo;
         int nextadrPrev = nextadr;
         scanStats(tree.init);
         Bits initsCond;
         Bits uninitsCond;
         pendingExits = new ListBuffer<PendingExit>();
         do {
             Bits uninitsEntry = uninits.dup();
             if (tree.cond != null) {
                 scanCond(tree.cond);
                 initsCond = initsWhenFalse;
                 uninitsCond = uninitsWhenFalse;
                 inits = initsWhenTrue;
                 uninits = uninitsWhenTrue;
                 alive = !tree.cond.type.isFalse();
             } else {
                 initsCond = inits.dup();
                 initsCond.inclRange(firstadr, nextadr);
                 uninitsCond = uninits.dup();
                 uninitsCond.inclRange(firstadr, nextadr);
                 alive = true;
             }
             scanStat(tree.body);
             alive |= resolveContinues(tree);
             scan(tree.step);
             if (log.nerrors != 0 ||
                 loopPassTwo ||
                 uninitsEntry.dup().diffSet(uninits).nextBit(firstadr) == -1)
                 break;
             uninits = uninitsEntry.andSet(uninits);
             loopPassTwo = true;
             alive = true;
         } while (true);
         loopPassTwo = prevLoopPassTwo;
         inits = initsCond;
         uninits = uninitsCond;
         alive = resolveBreaks(tree, prevPendingExits) ||
             tree.cond != null && !tree.cond.type.isTrue();
         nextadr = nextadrPrev;
     }
     public void visitForeachLoop(JCEnhancedForLoop tree) {
         visitVarDef(tree.var);
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         boolean prevLoopPassTwo = loopPassTwo;
         int nextadrPrev = nextadr;
         scan(tree.expr);
         Bits initsStart = inits.dup();
         Bits uninitsStart = uninits.dup();
         letInit(tree.pos(), tree.var.sym);
         pendingExits = new ListBuffer<PendingExit>();
         do {
             Bits uninitsEntry = uninits.dup();
             scanStat(tree.body);
             alive |= resolveContinues(tree);
             if (log.nerrors != 0 ||
                 loopPassTwo ||
                 uninitsEntry.diffSet(uninits).nextBit(firstadr) == -1)
                 break;
             uninits = uninitsEntry.andSet(uninits);
             loopPassTwo = true;
             alive = true;
         } while (true);
         loopPassTwo = prevLoopPassTwo;
         inits = initsStart;
         uninits = uninitsStart.andSet(uninits);
         resolveBreaks(tree, prevPendingExits);
         alive = true;
         nextadr = nextadrPrev;
     }
     public void visitLabelled(JCLabeledStatement tree) {
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         pendingExits = new ListBuffer<PendingExit>();
         scanStat(tree.body);
         alive |= resolveBreaks(tree, prevPendingExits);
     }
     public void visitSwitch(JCSwitch tree) {
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         pendingExits = new ListBuffer<PendingExit>();
         int nextadrPrev = nextadr;
         scanExpr(tree.selector);
         Bits initsSwitch = inits;
         Bits uninitsSwitch = uninits.dup();
         boolean hasDefault = false;
         for (List<JCCase> l = tree.cases; l.nonEmpty(); l = l.tail) {
             alive = true;
             inits = initsSwitch.dup();
             uninits = uninits.andSet(uninitsSwitch);
             JCCase c = l.head;
             if (c.pat == null)
                 hasDefault = true;
             else
                 scanExpr(c.pat);
             scanStats(c.stats);
             addVars(c.stats, initsSwitch, uninitsSwitch);
             // Warn about fall-through if lint switch fallthrough enabled.
             if (!loopPassTwo &&
                 alive &&
                 lint.isEnabled(Lint.LintCategory.FALLTHROUGH) &&
                 c.stats.nonEmpty() && l.tail.nonEmpty())
                 log.warning(l.tail.head.pos(),
                             "possible.fall-through.into.case");
         }
         if (!hasDefault) {
             inits.andSet(initsSwitch);
             alive = true;
         }
         alive |= resolveBreaks(tree, prevPendingExits);
         nextadr = nextadrPrev;
     }
     // where
         /** Add any variables defined in stats to inits and uninits. */
         private static void addVars(List<JCStatement> stats, Bits inits,
                                     Bits uninits) {
             for (;stats.nonEmpty(); stats = stats.tail) {
                 JCTree stat = stats.head;
                 if (stat.getTag() == JCTree.VARDEF) {
                     int adr = ((JCVariableDecl) stat).sym.adr;
                     inits.excl(adr);
                     uninits.incl(adr);
                 }
             }
         }
     public void visitTry(JCTry tree) {
         List<Type> caughtPrev = caught;
         List<Type> thrownPrev = thrown;
         thrown = List.nil();
         for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
             List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
                     ((JCTypeDisjoint)l.head.param.vartype).components :
                     List.of(l.head.param.vartype);
             for (JCExpression ct : subClauses) {
                 caught = chk.incl(ct.type, caught);
             }
         }
         Bits uninitsTryPrev = uninitsTry;
         ListBuffer<PendingExit> prevPendingExits = pendingExits;
         pendingExits = new ListBuffer<PendingExit>();
         Bits initsTry = inits.dup();
         uninitsTry = uninits.dup();
         scanStat(tree.body);
         List<Type> thrownInTry = thrown;
         thrown = thrownPrev;
         caught = caughtPrev;
         boolean aliveEnd = alive;
         uninitsTry.andSet(uninits);
         Bits initsEnd = inits;
         Bits uninitsEnd = uninits;
         int nextadrCatch = nextadr;
         List<Type> caughtInTry = List.nil();
         for (List<JCCatch> l = tree.catchers; l.nonEmpty(); l = l.tail) {
             alive = true;
             JCVariableDecl param = l.head.param;
             List<JCExpression> subClauses = TreeInfo.isMultiCatch(l.head) ?
                     ((JCTypeDisjoint)l.head.param.vartype).components :
                     List.of(l.head.param.vartype);
             List<Type> ctypes = List.nil();
             List<Type> rethrownTypes = chk.diff(thrownInTry, caughtInTry);
             for (JCExpression ct : subClauses) {
                 Type exc = ct.type;
                 ctypes = ctypes.append(exc);
                 if (types.isSameType(exc, syms.objectType))
                     continue;
                 if (chk.subset(exc, caughtInTry)) {
                     log.error(l.head.pos(),
                               "except.already.caught", exc);
                 } else if (!chk.isUnchecked(l.head.pos(), exc) &&
                            exc.tsym != syms.throwableType.tsym &&
                            exc.tsym != syms.exceptionType.tsym &&
                            !chk.intersects(exc, thrownInTry)) {
                     log.error(l.head.pos(),
                               "except.never.thrown.in.try", exc);
                 }
                 caughtInTry = chk.incl(exc, caughtInTry);
             }
             inits = initsTry.dup();
             uninits = uninitsTry.dup();
             scan(param);
             inits.incl(param.sym.adr);
             uninits.excl(param.sym.adr);
             multicatchTypes.put(param.sym, chk.intersect(ctypes, rethrownTypes));
             scanStat(l.head.body);
             initsEnd.andSet(inits);
             uninitsEnd.andSet(uninits);
             nextadr = nextadrCatch;
             multicatchTypes.remove(param.sym);
             aliveEnd |= alive;
         }
         if (tree.finalizer != null) {
             List<Type> savedThrown = thrown;
             thrown = List.nil();
             inits = initsTry.dup();
             uninits = uninitsTry.dup();
             ListBuffer<PendingExit> exits = pendingExits;
             pendingExits = prevPendingExits;
             alive = true;
             scanStat(tree.finalizer);
             if (!alive) {
                 // discard exits and exceptions from try and finally
                 thrown = chk.union(thrown, thrownPrev);
                 if (!loopPassTwo &&
                     lint.isEnabled(Lint.LintCategory.FINALLY)) {
                     log.warning(TreeInfo.diagEndPos(tree.finalizer),
                                 "finally.cannot.complete");
                 }
             } else {
                 thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
                 thrown = chk.union(thrown, savedThrown);
                 uninits.andSet(uninitsEnd);
                 // FIX: this doesn't preserve source order of exits in catch
                 // versus finally!
                 while (exits.nonEmpty()) {
                     PendingExit exit = exits.next();
                     if (exit.inits != null) {
                         exit.inits.orSet(inits);
                         exit.uninits.andSet(uninits);
                     }
                     pendingExits.append(exit);
                 }
                 inits.orSet(initsEnd);
                 alive = aliveEnd;
             }
         } else {
             thrown = chk.union(thrown, chk.diff(thrownInTry, caughtInTry));
             inits = initsEnd;
             uninits = uninitsEnd;
             alive = aliveEnd;
             ListBuffer<PendingExit> exits = pendingExits;
             pendingExits = prevPendingExits;
             while (exits.nonEmpty()) pendingExits.append(exits.next());
         }
         uninitsTry.andSet(uninitsTryPrev).andSet(uninits);
     }
     public void visitConditional(JCConditional tree) {
         scanCond(tree.cond);
         Bits initsBeforeElse = initsWhenFalse;
         Bits uninitsBeforeElse = uninitsWhenFalse;
         inits = initsWhenTrue;
         uninits = uninitsWhenTrue;
         if (tree.truepart.type.tag == BOOLEAN &&
             tree.falsepart.type.tag == BOOLEAN) {
             // if b and c are boolean valued, then
             // v is (un)assigned after a?b:c when true iff
             //    v is (un)assigned after b when true and
             //    v is (un)assigned after c when true
             scanCond(tree.truepart);
             Bits initsAfterThenWhenTrue = initsWhenTrue.dup();
             Bits initsAfterThenWhenFalse = initsWhenFalse.dup();
             Bits uninitsAfterThenWhenTrue = uninitsWhenTrue.dup();
             Bits uninitsAfterThenWhenFalse = uninitsWhenFalse.dup();
             inits = initsBeforeElse;
             uninits = uninitsBeforeElse;
             scanCond(tree.falsepart);
             initsWhenTrue.andSet(initsAfterThenWhenTrue);
             initsWhenFalse.andSet(initsAfterThenWhenFalse);
             uninitsWhenTrue.andSet(uninitsAfterThenWhenTrue);
             uninitsWhenFalse.andSet(uninitsAfterThenWhenFalse);
         } else {
             scanExpr(tree.truepart);
             Bits initsAfterThen = inits.dup();
             Bits uninitsAfterThen = uninits.dup();
             inits = initsBeforeElse;
             uninits = uninitsBeforeElse;
             scanExpr(tree.falsepart);
             inits.andSet(initsAfterThen);
             uninits.andSet(uninitsAfterThen);
         }
     }
     public void visitIf(JCIf tree) {
         scanCond(tree.cond);
         Bits initsBeforeElse = initsWhenFalse;
         Bits uninitsBeforeElse = uninitsWhenFalse;
         inits = initsWhenTrue;
         uninits = uninitsWhenTrue;
         scanStat(tree.thenpart);
         if (tree.elsepart != null) {
             boolean aliveAfterThen = alive;
             alive = true;
             Bits initsAfterThen = inits.dup();
             Bits uninitsAfterThen = uninits.dup();
             inits = initsBeforeElse;
             uninits = uninitsBeforeElse;
             scanStat(tree.elsepart);
             inits.andSet(initsAfterThen);
             uninits.andSet(uninitsAfterThen);
             alive = alive | aliveAfterThen;
         } else {
             inits.andSet(initsBeforeElse);
             uninits.andSet(uninitsBeforeElse);
             alive = true;
         }
     }
     public void visitBreak(JCBreak tree) {
         recordExit(tree);
     }
     public void visitContinue(JCContinue tree) {
         recordExit(tree);
     }
     public void visitReturn(JCReturn tree) {
         scanExpr(tree.expr);
         // if not initial constructor, should markDead instead of recordExit
         recordExit(tree);
     }
     public void visitThrow(JCThrow tree) {
         scanExpr(tree.expr);
         Symbol sym = TreeInfo.symbol(tree.expr);
         if (sym != null &&
             sym.kind == VAR &&
             (sym.flags() & FINAL) != 0 &&
             multicatchTypes.get(sym) != null &&
             allowRethrowAnalysis) {
             for (Type t : multicatchTypes.get(sym)) {
                 markThrown(tree, t);
             }
         }
         else {
             markThrown(tree, tree.expr.type);
         }
         markDead();
     }
     public void visitApply(JCMethodInvocation tree) {
         scanExpr(tree.meth);
         scanExprs(tree.args);
         for (List<Type> l = tree.meth.type.getThrownTypes(); l.nonEmpty(); l = l.tail)
             markThrown(tree, l.head);
     }
     public void visitNewClass(JCNewClass tree) {
         scanExpr(tree.encl);
         scanExprs(tree.args);
        // scan(tree.def);
         for (List<Type> l = tree.constructorType.getThrownTypes();
              l.nonEmpty();
              l = l.tail) {
             markThrown(tree, l.head);
         }
         List<Type> caughtPrev = caught;
         try {
             // If the new class expression defines an anonymous class,
             // analysis of the anonymous constructor may encounter thrown
             // types which are unsubstituted type variables.
             // However, since the constructor's actual thrown types have
             // already been marked as thrown, it is safe to simply include
             // each of the constructor's formal thrown types in the set of
             // 'caught/declared to be thrown' types, for the duration of
             // the class def analysis.
             if (tree.def != null)
                 for (List<Type> l = tree.constructor.type.getThrownTypes();
                      l.nonEmpty();
                      l = l.tail) {
                     caught = chk.incl(l.head, caught);
                 }
             scan(tree.def);
         }
         finally {
             caught = caughtPrev;
         }
     }
     public void visitNewArray(JCNewArray tree) {
         scanExprs(tree.dims);
         scanExprs(tree.elems);
     }
     public void visitAssert(JCAssert tree) {
         Bits initsExit = inits.dup();
         Bits uninitsExit = uninits.dup();
         scanCond(tree.cond);
         uninitsExit.andSet(uninitsWhenTrue);
         if (tree.detail != null) {
             inits = initsWhenFalse;
             uninits = uninitsWhenFalse;
             scanExpr(tree.detail);
         }
         inits = initsExit;
         uninits = uninitsExit;
     }
     public void visitAssign(JCAssign tree) {
         JCTree lhs = TreeInfo.skipParens(tree.lhs);
         if (!(lhs instanceof JCIdent)) scanExpr(lhs);
         scanExpr(tree.rhs);
         letInit(lhs);
     }
     public void visitAssignop(JCAssignOp tree) {
         scanExpr(tree.lhs);
         scanExpr(tree.rhs);
         letInit(tree.lhs);
     }
     public void visitUnary(JCUnary tree) {
         switch (tree.getTag()) {
         case JCTree.NOT:
             scanCond(tree.arg);
             Bits t = initsWhenFalse;
             initsWhenFalse = initsWhenTrue;
             initsWhenTrue = t;
             t = uninitsWhenFalse;
             uninitsWhenFalse = uninitsWhenTrue;
             uninitsWhenTrue = t;
             break;
         case JCTree.PREINC: case JCTree.POSTINC:
         case JCTree.PREDEC: case JCTree.POSTDEC:
             scanExpr(tree.arg);
             letInit(tree.arg);
             break;
         default:
             scanExpr(tree.arg);
         }
     }
     public void visitBinary(JCBinary tree) {
         switch (tree.getTag()) {
         case JCTree.AND:
             scanCond(tree.lhs);
             Bits initsWhenFalseLeft = initsWhenFalse;
             Bits uninitsWhenFalseLeft = uninitsWhenFalse;
             inits = initsWhenTrue;
             uninits = uninitsWhenTrue;
             scanCond(tree.rhs);
             initsWhenFalse.andSet(initsWhenFalseLeft);
             uninitsWhenFalse.andSet(uninitsWhenFalseLeft);
             break;
         case JCTree.OR:
             scanCond(tree.lhs);
             Bits initsWhenTrueLeft = initsWhenTrue;
             Bits uninitsWhenTrueLeft = uninitsWhenTrue;
             inits = initsWhenFalse;
             uninits = uninitsWhenFalse;
             scanCond(tree.rhs);
             initsWhenTrue.andSet(initsWhenTrueLeft);
             uninitsWhenTrue.andSet(uninitsWhenTrueLeft);
             break;
         default:
             scanExpr(tree.lhs);
             scanExpr(tree.rhs);
         }
     }
     public void visitAnnotatedType(JCAnnotatedType tree) {
         // annotations don't get scanned
         tree.underlyingType.accept(this);
     }
     public void visitIdent(JCIdent tree) {
         if (tree.sym.kind == VAR)
             checkInit(tree.pos(), (VarSymbol)tree.sym);
     }
     public void visitTypeCast(JCTypeCast tree) {
         super.visitTypeCast(tree);
         if (!tree.type.isErroneous()
             && lint.isEnabled(Lint.LintCategory.CAST)
             && types.isSameType(tree.expr.type, tree.clazz.type)
             && !(ignoreAnnotatedCasts && containsTypeAnnotation(tree.clazz))) {
             log.warning(tree.pos(), "redundant.cast", tree.expr.type);
         }
     }
     public void visitTopLevel(JCCompilationUnit tree) {
         // Do nothing for TopLevel since each class is visited individually
     }
 /**************************************************************************
  * utility methods for ignoring type-annotated casts lint checking
  *************************************************************************/
     private static final boolean ignoreAnnotatedCasts = true;
     private static class AnnotationFinder extends TreeScanner {
         public boolean foundTypeAnno = false;
         public void visitAnnotation(JCAnnotation tree) {
             foundTypeAnno = foundTypeAnno || (tree instanceof JCTypeAnnotation);
         }
     }
     private boolean containsTypeAnnotation(JCTree e) {
         AnnotationFinder finder = new AnnotationFinder();
         finder.scan(e);
         return finder.foundTypeAnno;
     }
 /**************************************************************************
  * main method
  *************************************************************************/
     /** Perform definite assignment/unassignment analysis on a tree.
      */
     public void analyzeTree(JCTree tree, TreeMaker make) {
         try {
             this.make = make;
             inits = new Bits();
             uninits = new Bits();
             uninitsTry = new Bits();
             initsWhenTrue = initsWhenFalse =
                 uninitsWhenTrue = uninitsWhenFalse = null;
             if (vars == null)
                 vars = new VarSymbol[32];
             else
                 for (int i=0; i<vars.length; i++)
                     vars[i] = null;
             firstadr = 0;
             nextadr = 0;
             pendingExits = new ListBuffer<PendingExit>();
             multicatchTypes = new HashMap<Symbol, List<Type>>();
             alive = true;
             this.thrown = this.caught = null;
             this.classDef = null;
             scan(tree);
         } finally {
             // note that recursive invocations of this method fail hard
             inits = uninits = uninitsTry = null;
             initsWhenTrue = initsWhenFalse =
                 uninitsWhenTrue = uninitsWhenFalse = null;
             if (vars != null) for (int i=0; i<vars.length; i++)
                 vars[i] = null;
             firstadr = 0;
             nextadr = 0;
             pendingExits = null;
             this.make = null;
             this.thrown = this.caught = null;
             this.classDef = null;
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/comp/Flow.java@366a7b9b5627 (annotated)

src/share/classes/com/sun/tools/javac/comp/Flow.java