--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/nashorn/src/jdk/nashorn/internal/ir/visitor/NodeOperatorVisitor.java Fri Dec 21 16:36:24 2012 -0400
@@ -0,0 +1,1287 @@
+/*
+ * Copyright (c) 2010, 2012, 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.codegen.CompileUnit;
+import jdk.nashorn.internal.codegen.MethodEmitter;
+import jdk.nashorn.internal.ir.BinaryNode;
+import jdk.nashorn.internal.ir.Node;
+import jdk.nashorn.internal.ir.UnaryNode;
+
+/**
+ * Like NodeVisitor but navigating further into operators.
+ */
+public class NodeOperatorVisitor extends NodeVisitor {
+ /**
+ * Constructor
+ */
+ public NodeOperatorVisitor() {
+ super();
+ }
+
+ /**
+ * Constructor
+ *
+ * @param compileUnit compile unit
+ * @param method method emitter
+ */
+ public NodeOperatorVisitor(final CompileUnit compileUnit, final MethodEmitter method) {
+ super(compileUnit, method);
+ }
+
+ @Override
+ public final Node enter(final UnaryNode unaryNode) {
+ switch (unaryNode.tokenType()) {
+ case ADD:
+ return enterADD(unaryNode);
+ case BIT_NOT:
+ return enterBIT_NOT(unaryNode);
+ case CONVERT:
+ return enterCONVERT(unaryNode);
+ case DELETE:
+ return enterDELETE(unaryNode);
+ case DISCARD:
+ return enterDISCARD(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.enter(unaryNode);
+ }
+ }
+
+ @Override
+ public final Node leave(final UnaryNode unaryNode) {
+ switch (unaryNode.tokenType()) {
+ case ADD:
+ return leaveADD(unaryNode);
+ case BIT_NOT:
+ return leaveBIT_NOT(unaryNode);
+ case CONVERT:
+ return leaveCONVERT(unaryNode);
+ case DELETE:
+ return leaveDELETE(unaryNode);
+ case DISCARD:
+ return leaveDISCARD(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.leave(unaryNode);
+ }
+ }
+
+ @Override
+ public final Node enter(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 BIND:
+ return enterBIND(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.enter(binaryNode);
+ }
+ }
+
+ @Override
+ public final Node leave(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 BIND:
+ return leaveBIND(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.leave(binaryNode);
+ }
+ }
+
+ /*
+ @Override
+ public Node enter(final TernaryNode ternaryNode) {
+ return enterDefault(ternaryNode);
+ }
+
+ @Override
+ public Node leave(final TernaryNode ternaryNode) {
+ return leaveDefault(ternaryNode);
+ }*/
+
+ /*
+ * Unary entries and exists.
+ */
+
+ /**
+ * Unary enter - callback for entering a unary +
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterADD(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterBIT_NOT(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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 conversion
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterCONVERT(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * Unary leave - callback for leaving a conversion
+ *
+ * @param unaryNode the node
+ * @return processed node, which will replace the original one, or the original node
+ */
+ public Node leaveCONVERT(final UnaryNode unaryNode) {
+ return leaveDefault(unaryNode);
+ }
+
+ /**
+ * Unary enter - callback for entering a ++ or -- operator
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterDECINC(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterDELETE(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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 discard operator
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterDISCARD(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * Unary leave - callback for leaving a discard operator
+ *
+ * @param unaryNode the node
+ * @return processed node, which will replace the original one, or the original node
+ */
+ public Node leaveDISCARD(final UnaryNode unaryNode) {
+ return leaveDefault(unaryNode);
+ }
+
+ /**
+ * Unary enter - callback for entering a new operator
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterNEW(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterNOT(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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 -
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterSUB(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterTYPEOF(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param unaryNode the node
+ * @return processed node
+ */
+ public Node enterVOID(final UnaryNode unaryNode) {
+ return enterDefault(unaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterADD(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterAND(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveAND(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering an assignment
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_ADD(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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_AND(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering |= operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_DIV(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_MOD(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_MUL(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_SAR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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_SAR(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering a <<= operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_SHL(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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_SHL(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering >>>= operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_SHR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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_SHR(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering -= operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterASSIGN_SUB(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 bind operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterBIND(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * Binary leave - callback for leaving a bind operator
+ *
+ * @param binaryNode the node
+ * @return processed node, which will replace the original one, or the original node
+ */
+ public Node leaveBIND(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering & operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterBIT_AND(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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_AND(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering | operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterBIT_OR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterBIT_XOR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterCOMMALEFT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterCOMMARIGHT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterDIV(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterEQ(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterEQ_STRICT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterGE(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveGE(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering > operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterGT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveGT(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering in operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterIN(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterINSTANCEOF(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterLE(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveLE(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering < operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterLT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveLT(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+ /**
+ * Binary enter - callback for entering % operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterMOD(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterMUL(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterNE(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterNE_STRICT(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterOR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterSAR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveSAR(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering << operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterSHL(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveSHL(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+ /**
+ * Binary enter - callback for entering >>> operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterSHR(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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 leaveSHR(final BinaryNode binaryNode) {
+ return leaveDefault(binaryNode);
+ }
+
+ /**
+ * Binary enter - callback for entering - operator
+ *
+ * @param binaryNode the node
+ * @return processed node
+ */
+ public Node enterSUB(final BinaryNode binaryNode) {
+ return enterDefault(binaryNode);
+ }
+
+ /**
+ * 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);
+ }
+
+
+}