public abstract class Pass extends Object
| Modifier and Type | Field and Description |
|---|---|
protected AST |
ast
Stores the same thing as
root, but this variable is declared as AST
. |
static boolean |
canAddErrorsAndWarnings
A global flag controlling whether or not errors and warnings can currently be added.
|
static boolean |
fatalError
This flag gets set if an error occurs that should cause the LBJava compiler to stop executing
after this pass finishes.
|
protected ASTNode |
root
A reference to the root node of the AST over which this pass will operate.
|
| Constructor and Description |
|---|
Pass()
Default constructor.
|
Pass(ASTNode r)
Initializing constructor.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
printErrorsAndWarnings()
Prints the errors and warnings to STDERR sorted by line.
|
static void |
reportError(int line,
String message)
This method prints the given error message and sets the
fatalError variable. |
static void |
reportWarning(int line,
String message)
This method simply prints the given warning message.
|
void |
run()
The main interface: call this method to apply the pass to the AST.
|
void |
run(Argument node)
One of the recursive "helper" methods for
run(). |
void |
run(ArrayCreationExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(ArrayInitializer node)
One of the recursive "helper" methods for
run(). |
void |
run(ArrayType node)
One of the recursive "helper" methods for
run(). |
void |
run(AssertStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(Assignment node)
One of the recursive "helper" methods for
run(). |
void |
run(AST node)
One of the recursive "helper" methods for
run(). |
void |
run(AtLeastQuantifierExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(AtMostQuantifierExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(BinaryConstraintExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(BinaryExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(Block node)
One of the recursive "helper" methods for
run(). |
void |
run(BreakStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(CastExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(CatchClause node)
One of the recursive "helper" methods for
run(). |
void |
run(CatchList node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierAssignment node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierCastExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierExpressionList node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierName node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierReturnType node)
One of the recursive "helper" methods for
run(). |
void |
run(ClassifierType node)
One of the recursive "helper" methods for
run(). |
void |
run(CodedClassifier node)
One of the recursive "helper" methods for
run(). |
void |
run(CompositeGenerator node)
One of the recursive "helper" methods for
run(). |
void |
run(Conditional node)
One of the recursive "helper" methods for
run(). |
void |
run(Conjunction node)
One of the recursive "helper" methods for
run(). |
void |
run(Constant node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstantList node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstraintDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstraintEqualityExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstraintInvocation node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstraintStatementExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(ConstraintType node)
One of the recursive "helper" methods for
run(). |
void |
run(ContinueStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(DeclarationList node)
One of the recursive "helper" methods for
run(). |
void |
run(DoStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(EmptyStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(ExistentialQuantifierExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(ExpressionList node)
One of the recursive "helper" methods for
run(). |
void |
run(ExpressionStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(FieldAccess node)
One of the recursive "helper" methods for
run(). |
void |
run(ForStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(IfStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(ImportDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(ImportList node)
One of the recursive "helper" methods for
run(). |
void |
run(IncrementExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(InferenceDeclaration.HeadFinder node)
One of the recursive "helper" methods for
run(). |
void |
run(InferenceDeclaration.NormalizerDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(InferenceDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(InferenceInvocation node)
One of the recursive "helper" methods for
run(). |
void |
run(InferenceType node)
One of the recursive "helper" methods for
run(). |
void |
run(InstanceCreationExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(InstanceofExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(LabeledStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(LearningClassifierExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(MethodInvocation node)
One of the recursive "helper" methods for
run(). |
void |
run(Name node)
One of the recursive "helper" methods for
run(). |
void |
run(NameList node)
One of the recursive "helper" methods for
run(). |
void |
run(NegatedConstraintExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(NormalizerType node)
One of the recursive "helper" methods for
run(). |
void |
run(Operator node)
One of the recursive "helper" methods for
run(). |
void |
run(PackageDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(ParameterSet node)
One of the recursive "helper" methods for
run(). |
void |
run(PrimitiveType node)
One of the recursive "helper" methods for
run(). |
void |
run(ReferenceType node)
One of the recursive "helper" methods for
run(). |
void |
run(ReturnStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(SenseStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(StatementList node)
One of the recursive "helper" methods for
run(). |
void |
run(SubscriptVariable node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchBlock node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchGroup node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchGroupList node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchLabel node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchLabelList node)
One of the recursive "helper" methods for
run(). |
void |
run(SwitchStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(SynchronizedStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(ThrowStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(TryStatement node)
One of the recursive "helper" methods for
run(). |
void |
run(UnaryExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(UniversalQuantifierExpression node)
One of the recursive "helper" methods for
run(). |
void |
run(VariableDeclaration node)
One of the recursive "helper" methods for
run(). |
void |
run(WhileStatement node)
One of the recursive "helper" methods for
run(). |
void |
runOnChildren(ASTNode node)
This method supports derived passes that continue to descend down the AST after operating on
a particular type of node.
|
void |
setRoot(ASTNode r)
Sets the
root member variable. |
public static boolean fatalError
public static boolean canAddErrorsAndWarnings
reportError(int,String) and
reportWarning(int,String) methods become no-ops.protected ASTNode root
protected AST ast
root, but this variable is declared as AST
.public Pass()
public Pass(ASTNode r)
root.r - The reference with which root will be initialized.public static void reportError(int line,
String message)
fatalError variable.line - The line on which the error was recognized.message - The error message.public static void reportWarning(int line,
String message)
line - The line on which the warning was recognized.message - The warning message.public static void printErrorsAndWarnings()
public void setRoot(ASTNode r)
root member variable.r - The reference with which root will be set.public void run()
run() method with any
ASTNode argument type in a class that extends Pass, and those
methods will be called at the appropriate times during the traversal of the AST.public void runOnChildren(ASTNode node)
node - The node on whose children the pass should be run.public void run(AST node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(PackageDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ImportDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(BinaryExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InstanceCreationExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ParameterSet node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InstanceofExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ArrayCreationExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ArrayInitializer node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Conditional node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(LearningClassifierExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(CastExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(IncrementExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Assignment node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Constant node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(UnaryExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Name node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(FieldAccess node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SubscriptVariable node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Argument node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Operator node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(NameList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstantList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(StatementList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ImportList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(DeclarationList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ExpressionList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstraintType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InferenceType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(NormalizerType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ReferenceType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ArrayType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(PrimitiveType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierReturnType node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierExpressionList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierAssignment node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierName node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ClassifierCastExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Conjunction node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(CodedClassifier node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(CompositeGenerator node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InferenceInvocation node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(VariableDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(EmptyStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(LabeledStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(IfStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchBlock node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchGroupList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchGroup node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchLabelList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SwitchLabel node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(DoStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(WhileStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ForStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ExpressionStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ContinueStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ReturnStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SenseStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ThrowStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(SynchronizedStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(TryStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(CatchList node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(Block node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(CatchClause node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(AssertStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(BreakStatement node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(MethodInvocation node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(AtLeastQuantifierExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(AtMostQuantifierExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(BinaryConstraintExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstraintDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstraintEqualityExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstraintInvocation node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ConstraintStatementExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(ExistentialQuantifierExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InferenceDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InferenceDeclaration.HeadFinder node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(InferenceDeclaration.NormalizerDeclaration node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(NegatedConstraintExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.public void run(UniversalQuantifierExpression node)
run(). Simply in charge of delegating
its work to the children of the node passed to it. Derived Passes will override
this method when there is something useful to be done for the given node in that pass. If
there isn't, it won't be overriden, and execution will continue to traverse the AST.node - A reference to the node currently being processed.Copyright © 2016. All rights reserved.