Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## jif.visit
Class LabelChecker

    java.lang.Object
      jif.visit.LabelChecker

All Implemented Interfaces:
  java.lang.Cloneable, polyglot.util.Copy

    public class LabelChecker

extends java.lang.Object
implements polyglot.util.Copy

The `LabelChecker` class is used in the label checking of Jif. Primarily it provides the method `labelCheck(Node)` which invokes the `labelCheck` method on nodes, utility functions to help in the implementation of the `labelCheck` methods, as well as references to the appropriate `Solver` and `JifContext`.

`LabelChecker` is mostly imperative; however, the `JifContext` is treated functionally, and whenever a `LabelChecker` is given a new `JifContext`, a new `LabelChecker` is created.

Field Summary
`protected polyglot.frontend.Job` | `job`
`protected polyglot.ast.NodeFactory` | `nf`
`protected boolean` | `solvePerClassBody` If true, then a new system of constraints will be used for each class body, and upon leaving the class body, the system of constraints will be solved.
`protected boolean` | `solvePerMethod` If true, then a new system of constraints will be used for each method body, and upon leaving the method body, the system of constraints will be solved.
`protected Solver` | `solver` The `Solver` to add constraints to.
`protected JifTypeSystem` | `ts`

Constructor Summary
`LabelChecker(polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf, boolean solvePerClassBody, boolean solvePerMethod, boolean doLabelSubst)`

Method Summary
`protected void` | `constrain(Constraint c)`
`void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos)`
`void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos, boolean report, ConstraintMessage msg)`
`void` | `constrain(NamedLabel lhs, Constraint.Kind kind, NamedLabel rhs, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg)`
`void` | `constrain(Principal p, Constraint.Kind kind, Principal q, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg)`
`void` | `constrain(Principal p, Constraint.Kind kind, Principal q, LabelEnv env, polyglot.util.Position pos, ConstraintMessage msg, boolean report)`
`JifContext` | `context()`
`LabelChecker` | `context(JifContext c)`
`java.lang.Object` | `copy()`
`CallHelper` | `createCallHelper(Label receiverLabel, polyglot.ast.Receiver receiver, polyglot.types.ReferenceType calleeContainer, JifProcedureInstance pi, java.util.List actualArgs, polyglot.util.Position position)`
`CallHelper` | `createCallHelper(Label receiverLabel, polyglot.types.ReferenceType calleeContainer, JifProcedureInstance pi, java.util.List actualArgs, polyglot.util.Position position)`
`CallHelper` | `createOverrideHelper(JifMethodInstance overridden, JifMethodInstance overriding)`
`void` | `enteringClassDecl(polyglot.types.ClassType ct)` Called by JifClassDeclExt just before this label checker is used to check a class body.
`void` | `enteringMethod(polyglot.types.MethodInstance mi)` Called by JifMethodDeclExt just before this label checker is used to check a method body.
`polyglot.util.ErrorQueue` | `errorQueue()`
`polyglot.ast.Node` | `finishedLabelCheckPass(polyglot.ast.Node n)` This method should be called on the top level label checker once the label checking has finished.
`JifContext` | `jifContext()`
`JifTypeSystem` | `jifTypeSystem()`
`polyglot.frontend.Job` | `job()`
`polyglot.ast.Node` | `labelCheck(polyglot.ast.Node n)`
`JifClassDecl` | `leavingClassDecl(JifClassDecl n)` Called by JifClassDeclExt just after this label checker has been used to check a class body.
`JifMethodDecl` | `leavingMethod(JifMethodDecl n)` Called by JifClassDeclExt just after this label checker has been used to check a class body.
`Label` | `lowerBound(Label L1, Label L2)` Returns a lower bound for L1 and L2
`polyglot.ast.NodeFactory` | `nodeFactory()`
`protected polyglot.ast.Node` | `postLabelCheck(polyglot.ast.Node old, polyglot.ast.Node n)`
`protected polyglot.ast.Node` | `preLabelCheck(polyglot.ast.Node n)`
`void` | `reportSemanticException(polyglot.types.SemanticException e)`
`protected polyglot.ast.Node` | `solveConstraints(polyglot.ast.Node n)`
`Solver` | `solver()`
`JifTypeSystem` | `typeSystem()`
`Label` | `upperBound(Label L1, Label L2)` Returns an upper bound for L1 and L2
`Label` | `upperBound(Label L1, Label L2, Label L3)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### ts

    protected final JifTypeSystem ts

### job

    protected final polyglot.frontend.Job job

### nf

    protected final polyglot.ast.NodeFactory nf

### solvePerClassBody

    protected final boolean solvePerClassBody

  If true, then a new system of constraints will be used for each class body, and upon leaving the class body, the system of constraints will be solved.

### solvePerMethod

    protected final boolean solvePerMethod

  If true, then a new system of constraints will be used for each method body, and upon leaving the method body, the system of constraints will be solved.

### solver

    protected Solver solver

  The `Solver` to add constraints to. Depending on `solveClassBodies`, a new `Solver` is used for every class, or a single `Solver` used for the entire compilation.

Constructor Detail

### LabelChecker

    public LabelChecker(polyglot.frontend.Job job,
                        polyglot.types.TypeSystem ts,
                        polyglot.ast.NodeFactory nf,
                        boolean solvePerClassBody,
                        boolean solvePerMethod,
                        boolean doLabelSubst)

Method Detail

### copy

    public java.lang.Object copy()

  Specified by:
    `copy` in interface `polyglot.util.Copy`

### context

    public JifContext context()

### jifContext

    public JifContext jifContext()

### context

    public LabelChecker context(JifContext c)

### typeSystem

    public JifTypeSystem typeSystem()

### jifTypeSystem

    public JifTypeSystem jifTypeSystem()

### nodeFactory

    public polyglot.ast.NodeFactory nodeFactory()

### solver

    public Solver solver()

### job

    public polyglot.frontend.Job job()

### errorQueue

    public polyglot.util.ErrorQueue errorQueue()

### upperBound

    public Label upperBound(Label L1,
                            Label L2)

  Returns an upper bound for L1 and L2

### upperBound

    public Label upperBound(Label L1,
                            Label L2,
                            Label L3)

### lowerBound

    public Label lowerBound(Label L1,
                            Label L2)

  Returns a lower bound for L1 and L2

### preLabelCheck

    protected polyglot.ast.Node preLabelCheck(polyglot.ast.Node n)

### postLabelCheck

    protected polyglot.ast.Node postLabelCheck(polyglot.ast.Node old,
                                               polyglot.ast.Node n)

### labelCheck

    public polyglot.ast.Node labelCheck(polyglot.ast.Node n)
                                 throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    public void constrain(NamedLabel lhs,
                          Constraint.Kind kind,
                          NamedLabel rhs,
                          LabelEnv env,
                          polyglot.util.Position pos,
                          ConstraintMessage msg)
                   throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    public void constrain(NamedLabel lhs,
                          Constraint.Kind kind,
                          NamedLabel rhs,
                          LabelEnv env,
                          polyglot.util.Position pos,
                          boolean report,
                          ConstraintMessage msg)
                   throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    public void constrain(NamedLabel lhs,
                          Constraint.Kind kind,
                          NamedLabel rhs,
                          LabelEnv env,
                          polyglot.util.Position pos)
                   throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    protected void constrain(Constraint c)
                      throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    public void constrain(Principal p,
                          Constraint.Kind kind,
                          Principal q,
                          LabelEnv env,
                          polyglot.util.Position pos,
                          ConstraintMessage msg)
                   throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### constrain

    public void constrain(Principal p,
                          Constraint.Kind kind,
                          Principal q,
                          LabelEnv env,
                          polyglot.util.Position pos,
                          ConstraintMessage msg,
                          boolean report)
                   throws polyglot.types.SemanticException

  Throws:
    `polyglot.types.SemanticException`

### enteringClassDecl

    public void enteringClassDecl(polyglot.types.ClassType ct)

  Called by JifClassDeclExt just before this label checker is used to check a class body. This allows us to use a different solver if required.

### enteringMethod

    public void enteringMethod(polyglot.types.MethodInstance mi)

  Called by JifMethodDeclExt just before this label checker is used to check a method body. This allows us to use a different solver if required.

### leavingClassDecl

    public JifClassDecl leavingClassDecl(JifClassDecl n)

  Called by JifClassDeclExt just after this label checker has been used to check a class body. This allows us to use a different solver if required.

### leavingMethod

    public JifMethodDecl leavingMethod(JifMethodDecl n)

  Called by JifClassDeclExt just after this label checker has been used to check a class body. This allows us to use a different solver if required.

### finishedLabelCheckPass

    public polyglot.ast.Node finishedLabelCheckPass(polyglot.ast.Node n)

  This method should be called on the top level label checker once the label checking has finished. This will perform label substitution if required.

### solveConstraints

    protected polyglot.ast.Node solveConstraints(polyglot.ast.Node n)

### reportSemanticException

    public void reportSemanticException(polyglot.types.SemanticException e)

### createCallHelper

    public CallHelper createCallHelper(Label receiverLabel,
                                       polyglot.ast.Receiver receiver,
                                       polyglot.types.ReferenceType calleeContainer,
                                       JifProcedureInstance pi,
                                       java.util.List actualArgs,
                                       polyglot.util.Position position)

### createCallHelper

    public CallHelper createCallHelper(Label receiverLabel,
                                       polyglot.types.ReferenceType calleeContainer,
                                       JifProcedureInstance pi,
                                       java.util.List actualArgs,
                                       polyglot.util.Position position)

### createOverrideHelper

    public CallHelper createOverrideHelper(JifMethodInstance overridden,
                                           JifMethodInstance overriding)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD