/*

 * 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

     */