/*
 * Copyright (c) 2010, 2013, 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.
 */

package jdk.nashorn.internal.ir.visitor;

import jdk.nashorn.internal.ir.BinaryNode;
import jdk.nashorn.internal.ir.LexicalContext;
import jdk.nashorn.internal.ir.Node;
import jdk.nashorn.internal.ir.UnaryNode;

Like NodeVisitor but navigating further into operators.
Type parameters:
  • <T> – Lexical context class for this NodeOperatorVisitor
/** * Like NodeVisitor but navigating further into operators. * @param <T> Lexical context class for this NodeOperatorVisitor */
public abstract class NodeOperatorVisitor<T extends LexicalContext> extends NodeVisitor<T> {
Constructor
Params:
  • lc – a custom lexical context
/** * Constructor * * @param lc a custom lexical context */
public NodeOperatorVisitor(final T lc) { super(lc); } @Override public boolean enterUnaryNode(final UnaryNode unaryNode) { switch (unaryNode.tokenType()) { case ADD: return enterADD(unaryNode); case BIT_NOT: return enterBIT_NOT(unaryNode); case DELETE: return enterDELETE(unaryNode); case NEW: return enterNEW(unaryNode); case NOT: return enterNOT(unaryNode); case SUB: return enterSUB(unaryNode); case TYPEOF: return enterTYPEOF(unaryNode); case VOID: return enterVOID(unaryNode); case DECPREFIX: case DECPOSTFIX: case INCPREFIX: case INCPOSTFIX: return enterDECINC(unaryNode); default: return super.enterUnaryNode(unaryNode); } } @Override public final Node leaveUnaryNode(final UnaryNode unaryNode) { switch (unaryNode.tokenType()) { case ADD: return leaveADD(unaryNode); case BIT_NOT: return leaveBIT_NOT(unaryNode); case DELETE: return leaveDELETE(unaryNode); case NEW: return leaveNEW(unaryNode); case NOT: return leaveNOT(unaryNode); case SUB: return leaveSUB(unaryNode); case TYPEOF: return leaveTYPEOF(unaryNode); case VOID: return leaveVOID(unaryNode); case DECPREFIX: case DECPOSTFIX: case INCPREFIX: case INCPOSTFIX: return leaveDECINC(unaryNode); default: return super.leaveUnaryNode(unaryNode); } } @Override public final boolean enterBinaryNode(final BinaryNode binaryNode) { switch (binaryNode.tokenType()) { case ADD: return enterADD(binaryNode); case AND: return enterAND(binaryNode); case ASSIGN: return enterASSIGN(binaryNode); case ASSIGN_ADD: return enterASSIGN_ADD(binaryNode); case ASSIGN_BIT_AND: return enterASSIGN_BIT_AND(binaryNode); case ASSIGN_BIT_OR: return enterASSIGN_BIT_OR(binaryNode); case ASSIGN_BIT_XOR: return enterASSIGN_BIT_XOR(binaryNode); case ASSIGN_DIV: return enterASSIGN_DIV(binaryNode); case ASSIGN_MOD: return enterASSIGN_MOD(binaryNode); case ASSIGN_MUL: return enterASSIGN_MUL(binaryNode); case ASSIGN_SAR: return enterASSIGN_SAR(binaryNode); case ASSIGN_SHL: return enterASSIGN_SHL(binaryNode); case ASSIGN_SHR: return enterASSIGN_SHR(binaryNode); case ASSIGN_SUB: return enterASSIGN_SUB(binaryNode); case ARROW: return enterARROW(binaryNode); case BIT_AND: return enterBIT_AND(binaryNode); case BIT_OR: return enterBIT_OR(binaryNode); case BIT_XOR: return enterBIT_XOR(binaryNode); case COMMARIGHT: return enterCOMMARIGHT(binaryNode); case COMMALEFT: return enterCOMMALEFT(binaryNode); case DIV: return enterDIV(binaryNode); case EQ: return enterEQ(binaryNode); case EQ_STRICT: return enterEQ_STRICT(binaryNode); case GE: return enterGE(binaryNode); case GT: return enterGT(binaryNode); case IN: return enterIN(binaryNode); case INSTANCEOF: return enterINSTANCEOF(binaryNode); case LE: return enterLE(binaryNode); case LT: return enterLT(binaryNode); case MOD: return enterMOD(binaryNode); case MUL: return enterMUL(binaryNode); case NE: return enterNE(binaryNode); case NE_STRICT: return enterNE_STRICT(binaryNode); case OR: return enterOR(binaryNode); case SAR: return enterSAR(binaryNode); case SHL: return enterSHL(binaryNode); case SHR: return enterSHR(binaryNode); case SUB: return enterSUB(binaryNode); default: return super.enterBinaryNode(binaryNode); } } @Override public final Node leaveBinaryNode(final BinaryNode binaryNode) { switch (binaryNode.tokenType()) { case ADD: return leaveADD(binaryNode); case AND: return leaveAND(binaryNode); case ASSIGN: return leaveASSIGN(binaryNode); case ASSIGN_ADD: return leaveASSIGN_ADD(binaryNode); case ASSIGN_BIT_AND: return leaveASSIGN_BIT_AND(binaryNode); case ASSIGN_BIT_OR: return leaveASSIGN_BIT_OR(binaryNode); case ASSIGN_BIT_XOR: return leaveASSIGN_BIT_XOR(binaryNode); case ASSIGN_DIV: return leaveASSIGN_DIV(binaryNode); case ASSIGN_MOD: return leaveASSIGN_MOD(binaryNode); case ASSIGN_MUL: return leaveASSIGN_MUL(binaryNode); case ASSIGN_SAR: return leaveASSIGN_SAR(binaryNode); case ASSIGN_SHL: return leaveASSIGN_SHL(binaryNode); case ASSIGN_SHR: return leaveASSIGN_SHR(binaryNode); case ASSIGN_SUB: return leaveASSIGN_SUB(binaryNode); case ARROW: return leaveARROW(binaryNode); case BIT_AND: return leaveBIT_AND(binaryNode); case BIT_OR: return leaveBIT_OR(binaryNode); case BIT_XOR: return leaveBIT_XOR(binaryNode); case COMMARIGHT: return leaveCOMMARIGHT(binaryNode); case COMMALEFT: return leaveCOMMALEFT(binaryNode); case DIV: return leaveDIV(binaryNode); case EQ: return leaveEQ(binaryNode); case EQ_STRICT: return leaveEQ_STRICT(binaryNode); case GE: return leaveGE(binaryNode); case GT: return leaveGT(binaryNode); case IN: return leaveIN(binaryNode); case INSTANCEOF: return leaveINSTANCEOF(binaryNode); case LE: return leaveLE(binaryNode); case LT: return leaveLT(binaryNode); case MOD: return leaveMOD(binaryNode); case MUL: return leaveMUL(binaryNode); case NE: return leaveNE(binaryNode); case NE_STRICT: return leaveNE_STRICT(binaryNode); case OR: return leaveOR(binaryNode); case SAR: return leaveSAR(binaryNode); case SHL: return leaveSHL(binaryNode); case SHR: return leaveSHR(binaryNode); case SUB: return leaveSUB(binaryNode); default: return super.leaveBinaryNode(binaryNode); } } /* * Unary entries and exists. */
Unary enter - callback for entering a unary +
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a unary + * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterADD(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a unary +
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a unary + * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveADD(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a ~ operator
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a ~ operator * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterBIT_NOT(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a unary ~
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a unary ~ * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveBIT_NOT(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a ++ or -- operator
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a ++ or -- operator * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterDECINC(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a ++ or -- operator
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a ++ or -- operator * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveDECINC(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a delete operator
Params:
  • unaryNode – the node
Returns:processed node
/** * Unary enter - callback for entering a delete operator * * @param unaryNode the node * @return processed node */
public boolean enterDELETE(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a delete operator
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a delete operator * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveDELETE(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a new operator
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a new operator * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterNEW(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a new operator
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a new operator * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveNEW(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a ! operator
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a ! operator * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterNOT(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a ! operator
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a ! operator * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveNOT(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a unary -
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a unary - * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterSUB(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a unary -
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a unary - * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveSUB(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a typeof
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a typeof * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterTYPEOF(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a typeof operator
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a typeof operator * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveTYPEOF(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Unary enter - callback for entering a void
Params:
  • unaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Unary enter - callback for entering a void * * @param unaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterVOID(final UnaryNode unaryNode) { return enterDefault(unaryNode); }
Unary leave - callback for leaving a void
Params:
  • unaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Unary leave - callback for leaving a void * * @param unaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveVOID(final UnaryNode unaryNode) { return leaveDefault(unaryNode); }
Binary enter - callback for entering + operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering + operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterADD(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a + operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a + operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveADD(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering && operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal &&} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterAND(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a && operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal &&} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveAND(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering an assignment
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering an assignment * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving an assignment
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving an assignment * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering += operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering += operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_ADD(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a += operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a += operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_ADD(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering &= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal &=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a &= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal &=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_BIT_AND(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering |= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering |= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a |= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a |= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_BIT_OR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering ^= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering ^= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a ^= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a ^= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_BIT_XOR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering /= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering /= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_DIV(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a /= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a /= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_DIV(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering %= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering %= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_MOD(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a %= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a %= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_MOD(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering *= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering *= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_MUL(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a *= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a *= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_MUL(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering >>= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >>=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_SAR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a >>= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal >>=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_SAR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering a <<= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering a {@literal <<=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_SHL(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a <<= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal <<=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_SHL(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering >>>= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >>>=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_SHR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a >>>= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal >>>=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_SHR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering -= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering -= operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterASSIGN_SUB(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a -= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a -= operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveASSIGN_SUB(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering a arrow operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering a arrow operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterARROW(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a arrow operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a arrow operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveARROW(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering & operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal &} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterBIT_AND(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a & operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a {@literal &} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveBIT_AND(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering | operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering | operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterBIT_OR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a | operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a | operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveBIT_OR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering ^ operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering ^ operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterBIT_XOR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveBIT_XOR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering comma left operator (a, b) where the result is a
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering comma left operator * (a, b) where the result is a * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterCOMMALEFT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a comma left operator (a, b) where the result is a
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a comma left operator * (a, b) where the result is a * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveCOMMALEFT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering comma right operator (a, b) where the result is b
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering comma right operator * (a, b) where the result is b * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterCOMMARIGHT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a comma left operator (a, b) where the result is b
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a comma left operator * (a, b) where the result is b * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveCOMMARIGHT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering a division
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering a division * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterDIV(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving a division
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving a division * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveDIV(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering == operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering == operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterEQ(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving == operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving == operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveEQ(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering === operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering === operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterEQ_STRICT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving === operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving === operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveEQ_STRICT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering >= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterGE(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving >= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal >=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveGE(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering > operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterGT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving > operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal >} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveGT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering in operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering in operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterIN(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving in operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving in operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveIN(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering instanceof operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering instanceof operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterINSTANCEOF(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving instanceof operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving instanceof operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveINSTANCEOF(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering <= operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal <=} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterLE(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving <= operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal <=} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveLE(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering < operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal <} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterLT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving < operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal <} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveLT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering % operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering % operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterMOD(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving % operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving % operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveMOD(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering * operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering * operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterMUL(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving * operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving * operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveMUL(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering != operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering != operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterNE(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving != operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving != operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveNE(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering a !== operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering a !== operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterNE_STRICT(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving !== operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving !== operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveNE_STRICT(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering || operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering || operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterOR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving || operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving || operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveOR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering >> operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >>} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterSAR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving >> operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal >>} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveSAR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering << operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal <<} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterSHL(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving << operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal <<} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveSHL(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering >>> operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering {@literal >>>} operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterSHR(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving >>> operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving {@literal >>>} operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveSHR(final BinaryNode binaryNode) { return leaveDefault(binaryNode); }
Binary enter - callback for entering - operator
Params:
  • binaryNode – the node
Returns:true if traversal should continue and node children be traversed, false otherwise
/** * Binary enter - callback for entering - operator * * @param binaryNode the node * @return true if traversal should continue and node children be traversed, false otherwise */
public boolean enterSUB(final BinaryNode binaryNode) { return enterDefault(binaryNode); }
Binary leave - callback for leaving - operator
Params:
  • binaryNode – the node
Returns:processed node, which will replace the original one, or the original node
/** * Binary leave - callback for leaving - operator * * @param binaryNode the node * @return processed node, which will replace the original one, or the original node */
public Node leaveSUB(final BinaryNode binaryNode) { return leaveDefault(binaryNode); } }