{

public static final int

FUNCTION_PROP = 1,

LOCAL_PROP = 2,

LOCAL_BLOCK_PROP = 3,

REGEXP_PROP = 4,

CASEARRAY_PROP = 5,

// the following properties are defined and manipulated by the

// optimizer -

// TARGETBLOCK_PROP - the block referenced by a branch node

// VARIABLE_PROP - the variable referenced by a BIND or NAME node

// ISNUMBER_PROP - this node generates code on Number children and

// delivers a Number result (as opposed to Objects)

// DIRECTCALL_PROP - this call node should emit code to test the function

// object against the known class and call direct if it

// matches.

TARGETBLOCK_PROP = 6,

VARIABLE_PROP = 7,

ISNUMBER_PROP = 8,

DIRECTCALL_PROP = 9,

SPECIALCALL_PROP = 10,

SKIP_INDEXES_PROP = 11, // array of skipped indexes of array literal

OBJECT_IDS_PROP = 12, // array of properties for object literal

INCRDECR_PROP = 13, // pre or post type of increment/decrement

CATCH_SCOPE_PROP = 14, // index of catch scope block in catch

LABEL_ID_PROP = 15, // label id: code generation uses it

MEMBER_TYPE_PROP = 16, // type of element access operation

NAME_PROP = 17, // property name

CONTROL_BLOCK_PROP = 18, // flags a control block that can drop off

PARENTHESIZED_PROP = 19, // expression is parenthesized

GENERATOR_END_PROP = 20,

DESTRUCTURING_ARRAY_LENGTH = 21,

DESTRUCTURING_NAMES = 22,

DESTRUCTURING_PARAMS = 23,

JSDOC_PROP = 24,

EXPRESSION_CLOSURE_PROP = 25, // JS 1.8 expression closure pseudo-return

DESTRUCTURING_SHORTHAND = 26, // JS 1.8 destructuring shorthand

ARROW_FUNCTION_PROP = 27,

LAST_PROP = 27;

// values of ISNUMBER_PROP to specify

// which of the children are Number types

public static final int

BOTH = 0,

LEFT = 1,

RIGHT = 2;

public static final int // values for SPECIALCALL_PROP

NON_SPECIALCALL = 0,

SPECIALCALL_EVAL = 1,

SPECIALCALL_WITH = 2;

public static final int // flags for INCRDECR_PROP

DECR_FLAG = 0x1,

POST_FLAG = 0x2;

public static final int // flags for MEMBER_TYPE_PROP

PROPERTY_FLAG = 0x1, // property access: element is valid name

ATTRIBUTE_FLAG = 0x2, // x.@y or x..@y

DESCENDANTS_FLAG = 0x4; // x..y or x..@i

private static class PropListItem

{

PropListItem next;

int type;

int intValue;

Object objectValue;

}

public Node(int nodeType) {

type = nodeType;

}

public Node(int nodeType, Node child) {

type = nodeType;

first = last = child;

child.next = null;

}

public Node(int nodeType, Node left, Node right) {

type = nodeType;

first = left;

last = right;

left.next = right;

right.next = null;

}

public Node(int nodeType, Node left, Node mid, Node right) {

type = nodeType;

first = left;

last = right;

left.next = mid;

mid.next = right;

right.next = null;

}

public Node(int nodeType, int line) {

type = nodeType;

lineno = line;

}

public Node(int nodeType, Node child, int line) {

this(nodeType, child);

lineno = line;

}

public Node(int nodeType, Node left, Node right, int line) {

this(nodeType, left, right);

lineno = line;

}

public Node(int nodeType, Node left, Node mid, Node right, int line) {

this(nodeType, left, mid, right);

lineno = line;

}

public static Node newNumber(double number) {

NumberLiteral n = new NumberLiteral();

n.setNumber(number);

return n;

}

public static Node newString(String str) {

return newString(Token.STRING, str);

}

public static Node newString(int type, String str) {

Name name = new Name();

name.setIdentifier(str);

name.setType(type);

return name;

}

public int getType() {

return type;

}

/**

public Node setType(int type) {

this.type = type;

return this;

}

/**

public String getJsDoc() {

Comment comment = getJsDocNode();

if (comment != null) {

return comment.getValue();

}

return null;

}

/**

public Comment getJsDocNode() {

return (Comment) getProp(JSDOC_PROP);

}

/**

public void setJsDocNode(Comment jsdocNode) {

putProp(JSDOC_PROP, jsdocNode);

}

public boolean hasChildren() {

return first != null;

}

public Node getFirstChild() {

return first;

}

public Node getLastChild() {

return last;

}

public Node getNext() {

return next;

}

public Node getChildBefore(Node child) {

if (child == first)

return null;

Node n = first;

while (n.next != child) {

n = n.next;

if (n == null)

throw new RuntimeException("node is not a child");

}

return n;

}

public Node getLastSibling() {

Node n = this;

while (n.next != null) {

n = n.next;

}

return n;

}

public void addChildToFront(Node child) {

child.next = first;

first = child;

if (last == null) {

last = child;

}

}

public void addChildToBack(Node child) {

child.next = null;

if (last == null) {

first = last = child;

return;

}

last.next = child;

last = child;

}

public void addChildrenToFront(Node children) {

Node lastSib = children.getLastSibling();

lastSib.next = first;

first = children;

if (last == null) {

last = lastSib;

}

}

public void addChildrenToBack(Node children) {

if (last != null) {

last.next = children;

}

last = children.getLastSibling();

if (first == null) {

first = children;

}

}

/**

public void addChildBefore(Node newChild, Node node) {

if (newChild.next != null)

throw new RuntimeException(

"newChild had siblings in addChildBefore");

if (first == node) {

newChild.next = first;

first = newChild;

return;

}

Node prev = getChildBefore(node);

addChildAfter(newChild, prev);

}

/**

public void addChildAfter(Node newChild, Node node) {

if (newChild.next != null)

throw new RuntimeException(

"newChild had siblings in addChildAfter");

newChild.next = node.next;

node.next = newChild;

if (last == node)

last = newChild;

}

public void removeChild(Node child) {

Node prev = getChildBefore(child);

if (prev == null)

first = first.next;

else

prev.next = child.next;

if (child == last) last = prev;

child.next = null;

}

public void replaceChild(Node child, Node newChild) {

newChild.next = child.next;

if (child == first) {

first = newChild;

} else {

Node prev = getChildBefore(child);

prev.next = newChild;

}

if (child == last)

last = newChild;

child.next = null;

}

public void replaceChildAfter(Node prevChild, Node newChild) {

Node child = prevChild.next;

newChild.next = child.next;

prevChild.next = newChild;

if (child == last)

last = newChild;

child.next = null;

}

public void removeChildren() {

first = last = null;

}

private static final Node NOT_SET = new Node(Token.ERROR);

/**

public class NodeIterator implements Iterator<Node> {

private Node cursor; // points to node to be returned next

private Node prev = NOT_SET;

private Node prev2;

private boolean removed = false;

public NodeIterator() {

cursor = Node.this.first;

}

@Override

public boolean hasNext() {

return cursor != null;

}

@Override

public Node next() {

if (cursor == null) {

throw new NoSuchElementException();

}

removed = false;

prev2 = prev;

prev = cursor;

cursor = cursor.next;

return prev;

}

@Override

public void remove() {

if (prev == NOT_SET) {

throw new IllegalStateException("next() has not been called");

}

if (removed) {

throw new IllegalStateException(

"remove() already called for current element");

}

if (prev == first) {

first = prev.next;

} else if (prev == last) {

prev2.next = null;

last = prev2;

} else {

prev2.next = cursor;

}

}

}

/**

@Override

public Iterator<Node> iterator() {

return new NodeIterator();

}

private static final String propToString(int propType)

{

if (Token.printTrees) {

// If Context.printTrees is false, the compiler

// can remove all these strings.

switch (propType) {

case FUNCTION_PROP: return "function";

case LOCAL_PROP: return "local";

case LOCAL_BLOCK_PROP: return "local_block";

case REGEXP_PROP: return "regexp";

case CASEARRAY_PROP: return "casearray";

case TARGETBLOCK_PROP: return "targetblock";

case VARIABLE_PROP: return "variable";

case ISNUMBER_PROP: return "isnumber";

case DIRECTCALL_PROP: return "directcall";

case SPECIALCALL_PROP: return "specialcall";

case SKIP_INDEXES_PROP: return "skip_indexes";

case OBJECT_IDS_PROP: return "object_ids_prop";

case INCRDECR_PROP: return "incrdecr_prop";

case CATCH_SCOPE_PROP: return "catch_scope_prop";

case LABEL_ID_PROP: return "label_id_prop";

case MEMBER_TYPE_PROP: return "member_type_prop";

case NAME_PROP: return "name_prop";

case CONTROL_BLOCK_PROP: return "control_block_prop";

case PARENTHESIZED_PROP: return "parenthesized_prop";

case GENERATOR_END_PROP: return "generator_end";

case DESTRUCTURING_ARRAY_LENGTH:

return "destructuring_array_length";

case DESTRUCTURING_NAMES: return "destructuring_names";

case DESTRUCTURING_PARAMS: return "destructuring_params";

default: Kit.codeBug();

}

}

return null;

}

private PropListItem lookupProperty(int propType)

{

PropListItem x = propListHead;

while (x != null && propType != x.type) {

x = x.next;

}

return x;

}

private PropListItem ensureProperty(int propType)

{

PropListItem item = lookupProperty(propType);

if (item == null) {

item = new PropListItem();

item.type = propType;

item.next = propListHead;

propListHead = item;

}

return item;

}

public void removeProp(int propType)

{

PropListItem x = propListHead;

if (x != null) {

PropListItem prev = null;

while (x.type != propType) {

prev = x;

x = x.next;

if (x == null) { return; }

}

if (prev == null) {

propListHead = x.next;

} else {

prev.next = x.next;

}

}

}

public Object getProp(int propType)

{

PropListItem item = lookupProperty(propType);

if (item == null) { return null; }

return item.objectValue;

}

public int getIntProp(int propType, int defaultValue)

{

PropListItem item = lookupProperty(propType);

if (item == null) { return defaultValue; }

return item.intValue;

}

public int getExistingIntProp(int propType)

{

PropListItem item = lookupProperty(propType);

if (item == null) { Kit.codeBug(); }

return item.intValue;

}

public void putProp(int propType, Object prop)

{

if (prop == null) {

removeProp(propType);

} else {

PropListItem item = ensureProperty(propType);

item.objectValue = prop;

}

}

public void putIntProp(int propType, int prop)

{

PropListItem item = ensureProperty(propType);

item.intValue = prop;

}

/**

public int getLineno() {

return lineno;

}

public void setLineno(int lineno) {

this.lineno = lineno;

}

/** Can only be called when <tt>getType() == Token.NUMBER</tt> */

public final double getDouble() {

return ((NumberLiteral)this).getNumber();

}

public final void setDouble(double number) {

((NumberLiteral)this).setNumber(number);

}

/** Can only be called when node has String context. */

public final String getString() {

return ((Name)this).getIdentifier();

}

/** Can only be called when node has String context. */

public final void setString(String s) {

if (s == null) Kit.codeBug();

((Name)this).setIdentifier(s);

}

/** Can only be called when node has String context. */

public Scope getScope() {

return ((Name)this).getScope();

}

/** Can only be called when node has String context. */

public void setScope(Scope s) {

if (s == null) Kit.codeBug();

if (!(this instanceof Name)) {

throw Kit.codeBug();

}

((Name)this).setScope(s);

}

public static Node newTarget()

{

return new Node(Token.TARGET);

}

public final int labelId()

{

if (type != Token.TARGET && type != Token.YIELD) Kit.codeBug();

return getIntProp(LABEL_ID_PROP, -1);

}

public void labelId(int labelId)

{

if (type != Token.TARGET && type != Token.YIELD) Kit.codeBug();

putIntProp(LABEL_ID_PROP, labelId);

}

/**

/**

public static final int END_UNREACHED = 0;

public static final int END_DROPS_OFF = 1;

public static final int END_RETURNS = 2;

public static final int END_RETURNS_VALUE = 4;

public static final int END_YIELDS = 8;

/**

public boolean hasConsistentReturnUsage()

{

int n = endCheck();

return (n & END_RETURNS_VALUE) == 0 ||

(n & (END_DROPS_OFF|END_RETURNS|END_YIELDS)) == 0;

}

/**

private int endCheckIf()

{

Node th, el;

int rv = END_UNREACHED;

th = next;

el = ((Jump)this).target;

rv = th.endCheck();

if (el != null)

rv |= el.endCheck();

else

rv |= END_DROPS_OFF;

return rv;

}

/**

private int endCheckSwitch()

{

int rv = END_UNREACHED;

// examine the cases

return rv;

}

/**

private int endCheckTry()

{

int rv = END_UNREACHED;

// a TryStatement isn't a jump - needs rewriting

// check the finally if it exists

return rv;

}

/**

private int endCheckLoop()

{

Node n;

int rv = END_UNREACHED;

// To find the loop body, we look at the second to last node of the

// loop node, which should be the predicate that the loop should

// satisfy.

// The target of the predicate is the loop-body for all 4 kinds of

// loops.

for (n = first; n.next != last; n = n.next) {

/* skip */

}

if (n.type != Token.IFEQ)

return END_DROPS_OFF;

// The target's next is the loop body block

rv = ((Jump)n).target.next.endCheck();

// check to see if the loop condition is true

if (n.first.type == Token.TRUE)

rv &= ~END_DROPS_OFF;

// look for effect of breaks

rv |= getIntProp(CONTROL_BLOCK_PROP, END_UNREACHED);

return rv;

}

/**

private int endCheckBlock()

{

Node n;

int rv = END_DROPS_OFF;

// check each statment and if the statement can continue onto the next

// one, then check the next statement

for (n=first; ((rv & END_DROPS_OFF) != 0) && n != null; n = n.next)

{

rv &= ~END_DROPS_OFF;

rv |= n.endCheck();

}

return rv;

}

/**

private int endCheckLabel()

{

int rv = END_UNREACHED;

rv = next.endCheck();

rv |= getIntProp(CONTROL_BLOCK_PROP, END_UNREACHED);

return rv;

}

/**

private int endCheckBreak()

{

Node n = ((Jump) this).getJumpStatement();

n.putIntProp(CONTROL_BLOCK_PROP, END_DROPS_OFF);

return END_UNREACHED;

}

/**

private int endCheck()

{

switch(type)

{

case Token.BREAK:

return endCheckBreak();

case Token.EXPR_VOID:

if (this.first != null)

return first.endCheck();

return END_DROPS_OFF;

case Token.YIELD:

return END_YIELDS;

case Token.CONTINUE:

case Token.THROW:

return END_UNREACHED;

case Token.RETURN:

if (this.first != null)

return END_RETURNS_VALUE;

return END_RETURNS;

case Token.TARGET:

if (next != null)

return next.endCheck();

return END_DROPS_OFF;

case Token.LOOP:

return endCheckLoop();

case Token.LOCAL_BLOCK:

case Token.BLOCK:

// there are several special kinds of blocks

if (first == null)

return END_DROPS_OFF;

switch(first.type) {

case Token.LABEL:

return first.endCheckLabel();

case Token.IFNE:

return first.endCheckIf();

case Token.SWITCH:

return first.endCheckSwitch();

case Token.TRY:

return first.endCheckTry();

default:

return endCheckBlock();

}

default:

return END_DROPS_OFF;

}

}

public boolean hasSideEffects()

{

switch (type) {

case Token.EXPR_VOID:

case Token.COMMA:

if (last != null)

return last.hasSideEffects();

return true;

case Token.HOOK:

if (first == null ||

first.next == null ||

first.next.next == null)

Kit.codeBug();

return first.next.hasSideEffects() &&

first.next.next.hasSideEffects();

case Token.AND:

case Token.OR:

if (first == null || last == null)

Kit.codeBug();

return first.hasSideEffects() || last.hasSideEffects();

case Token.ERROR: // Avoid cascaded error messages

case Token.EXPR_RESULT:

case Token.ASSIGN:

case Token.ASSIGN_ADD:

case Token.ASSIGN_SUB:

case Token.ASSIGN_MUL:

case Token.ASSIGN_DIV:

case Token.ASSIGN_MOD:

case Token.ASSIGN_BITOR:

case Token.ASSIGN_BITXOR:

case Token.ASSIGN_BITAND:

case Token.ASSIGN_LSH:

case Token.ASSIGN_RSH:

case Token.ASSIGN_URSH:

case Token.ENTERWITH:

case Token.LEAVEWITH:

case Token.RETURN:

case Token.GOTO:

case Token.IFEQ:

case Token.IFNE:

case Token.NEW:

case Token.DELPROP:

case Token.SETNAME:

case Token.SETPROP:

case Token.SETELEM:

case Token.CALL:

case Token.THROW:

case Token.RETHROW:

case Token.SETVAR:

case Token.CATCH_SCOPE:

case Token.RETURN_RESULT:

case Token.SET_REF:

case Token.DEL_REF:

case Token.REF_CALL:

case Token.TRY:

case Token.SEMI:

case Token.INC:

case Token.DEC:

case Token.IF:

case Token.ELSE:

case Token.SWITCH:

case Token.WHILE:

case Token.DO:

case Token.FOR:

case Token.BREAK:

case Token.CONTINUE:

case Token.VAR:

case Token.CONST:

case Token.LET:

case Token.LETEXPR:

case Token.WITH:

case Token.WITHEXPR:

case Token.CATCH:

case Token.FINALLY:

case Token.BLOCK:

case Token.LABEL:

case Token.TARGET:

case Token.LOOP: