/*

 * 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.

 * @param <T> Lexical context class for this NodeOperatorVisitor

 */

public abstract class NodeOperatorVisitor<T extends LexicalContext> extends NodeVisitor<T> {

    /**

     * 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 POS:

            return enterPOS(unaryNode);

        case BIT_NOT:

            return enterBIT_NOT(unaryNode);

        case DELETE:

            return enterDELETE(unaryNode);

        case NEW:

            return enterNEW(unaryNode);

        case NOT:

            return enterNOT(unaryNode);

        case NEG:

            return enterNEG(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 POS:

            return leavePOS(unaryNode);

        case BIT_NOT:

            return leaveBIT_NOT(unaryNode);

        case DELETE:

            return leaveDELETE(unaryNode);

        case NEW:

            return leaveNEW(unaryNode);

        case NOT:

            return leaveNOT(unaryNode);

        case NEG:

            return leaveNEG(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 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 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 +

     *

     * @param  unaryNode the node

     * @return true if traversal should continue and node children be traversed, false otherwise

     */

    public boolean enterPOS(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 leavePOS(final UnaryNode unaryNode) {

        return leaveDefault(unaryNode);

    }

    /**

     * 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 ~

     *

     * @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

     *

     * @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

     *

     * @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 boolean 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 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

     *

     * @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 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

     *

     * @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 true if traversal should continue and node children be traversed, false otherwise

     */

    public boolean enterNEG(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 leaveNEG(final UnaryNode unaryNode) {

        return leaveDefault(unaryNode);

    }

    /**

     * 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

     *

     * @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 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

     *

     * @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 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

     *

     * @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 {@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 {@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

     *

     * @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

     *

     * @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 true if traversal should continue and node children be traversed, false otherwise

     */