com.oracle.js.parser.ir

Class LoopNode

java.lang.Object

com.oracle.js.parser.ir.Node

com.oracle.js.parser.ir.Statement

com.oracle.js.parser.ir.LoopNode

All Implemented Interfaces:

BreakableNode, LexicalContextNode, Terminal, Cloneable

Direct Known Subclasses:

ForNode, WhileNode

public abstract class LoopNode
extends Statement

A loop node, for example a while node, do while node or for node

Field Summary

Fields

Modifier and Type	Field and Description
protected Block	body Loop body
protected boolean	controlFlowEscapes Can control flow escape from loop, e.g.
protected JoinPredecessorExpression	test Loop test node, null if infinite

Fields inherited from class com.oracle.js.parser.ir.Node

finish, start

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	LoopNode(int lineNumber, long token, int finish, Block body, JoinPredecessorExpression test, boolean controlFlowEscapes) Constructor
protected	LoopNode(LoopNode loopNode, JoinPredecessorExpression test, Block body, boolean controlFlowEscapes) Constructor

Method Summary

Modifier and Type	Method and Description
Node	accept(NodeVisitor<? extends LexicalContext> visitor) Provides a means to navigate the IR.
<R> R	accept(TranslatorNodeVisitor<? extends LexicalContext,R> visitor) Provides a means to navigate the IR.
abstract Block	getBody() Get the body for this for node
JoinPredecessorExpression	getTest() Get the test for this for node
abstract boolean	hasPerIterationScope() Does this loop have a LET declaration and hence require a per-iteration scope?
boolean	isBreakableWithoutLabel() Check whether this can be broken out from without using a label, e.g.
boolean	isCompletionValueNeverEmpty()
boolean	isLoop() Is this a loop node?
boolean	isTerminal() Is this a terminal statement, i.e.
abstract boolean	mustEnter() Conservative check: does this loop have to be entered?
abstract LoopNode	setBody(LexicalContext lc, Block body)
abstract LoopNode	setControlFlowEscapes(LexicalContext lc, boolean controlFlowEscapes) Set the control flow escapes flag for this node.
abstract LoopNode	setTest(LexicalContext lc, JoinPredecessorExpression test) Set the test for this for node

Methods inherited from class com.oracle.js.parser.ir.Statement

getLineNumber, hasGoto, hasTerminalFlags

Methods inherited from class com.oracle.js.parser.ir.Node

clone, equals, getFinish, getSourceOrder, getStart, getToken, hashCode, isAssignment, isTokenType, tokenType, toString, toString, toString

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.oracle.js.parser.ir.LexicalContextNode

accept, accept, accept, accept

Field Detail

test

protected final JoinPredecessorExpression test

Loop test node, null if infinite

body

protected final Block body

Loop body

controlFlowEscapes

protected final boolean controlFlowEscapes

Can control flow escape from loop, e.g. through breaks or continues to outer loops?

Constructor Detail

LoopNode

protected LoopNode(int lineNumber,
                   long token,
                   int finish,
                   Block body,
                   JoinPredecessorExpression test,
                   boolean controlFlowEscapes)

Constructor

Parameters:

lineNumber - lineNumber

token - token

finish - finish

body - loop body

test - test

controlFlowEscapes - controlFlowEscapes

LoopNode

protected LoopNode(LoopNode loopNode,
                   JoinPredecessorExpression test,
                   Block body,
                   boolean controlFlowEscapes)

Constructor

Parameters:

loopNode - loop node

test - new test

body - new body

controlFlowEscapes - controlFlowEscapes

Method Detail

isTerminal

public boolean isTerminal()

Description copied from class: Statement

Is this a terminal statement, i.e. does it end control flow like a throw or return?

Specified by:

isTerminal in interface Terminal

Overrides:

isTerminal in class Statement

Returns:

true if this node statement is terminal

mustEnter

public abstract boolean mustEnter()

Conservative check: does this loop have to be entered?

Returns:

true if body will execute at least once

isLoop

public boolean isLoop()

Description copied from class: Node

Is this a loop node?

Overrides:

isLoop in class Node

Returns:

true if atom

getBody

public abstract Block getBody()

Get the body for this for node

Returns:

the body

setBody

public abstract LoopNode setBody(LexicalContext lc,
                                 Block body)

Parameters:

lc - lexical context

body - new body

Returns:

new for node if changed or existing if not

getTest

public final JoinPredecessorExpression getTest()

Get the test for this for node

Returns:

the test

setTest

public abstract LoopNode setTest(LexicalContext lc,
                                 JoinPredecessorExpression test)

Set the test for this for node

Parameters:

lc - lexical context

test - new test

Returns:

same or new node depending on if test was changed

setControlFlowEscapes

public abstract LoopNode setControlFlowEscapes(LexicalContext lc,
                                               boolean controlFlowEscapes)

Set the control flow escapes flag for this node.

Parameters:

lc - lexical context

controlFlowEscapes - control flow escapes value

Returns:

new loop node if changed otherwise the same

hasPerIterationScope

public abstract boolean hasPerIterationScope()

Does this loop have a LET declaration and hence require a per-iteration scope?

Returns:

true if a per-iteration scope is required.

isCompletionValueNeverEmpty

public boolean isCompletionValueNeverEmpty()

Overrides:

isCompletionValueNeverEmpty in class Statement

Returns:

true if the completion value of this statement is never the value empty

isBreakableWithoutLabel

public boolean isBreakableWithoutLabel()

Check whether this can be broken out from without using a label, e.g. everything but Blocks, basically

Specified by:

isBreakableWithoutLabel in interface BreakableNode

Returns:

true if breakable without label

accept

public final Node accept(NodeVisitor<? extends LexicalContext> visitor)

Description copied from class: Node

Provides a means to navigate the IR.

Specified by:

accept in interface LexicalContextNode

Specified by:

accept in class Node

Parameters:

visitor - Node visitor.

Returns:

node the node or its replacement after visitation, null if no further visitations are required

accept

public final <R> R accept(TranslatorNodeVisitor<? extends LexicalContext,R> visitor)

Description copied from class: Node

Provides a means to navigate the IR.

Specified by:

accept in interface LexicalContextNode

Specified by:

accept in class Node

Parameters:

visitor - Node visitor.

Returns:

node the node or its replacement after visitation, null if no further visitations are required