1 /*

     2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.nashorn.internal.ir.visitor;

    27 

    28 import jdk.nashorn.internal.ir.BinaryNode;

    29 import jdk.nashorn.internal.ir.LexicalContext;

    30 import jdk.nashorn.internal.ir.Node;

    31 import jdk.nashorn.internal.ir.UnaryNode;

    32 

    33 /**

    34  * Like NodeVisitor but navigating further into operators.

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

    36  */

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

    38     /**

    39      * Constructor

    40      *

    41      * @param lc a custom lexical context

    42      */

    43     public NodeOperatorVisitor(final T lc) {

    44         super(lc);

    45     }

    46 

    47     @Override

    48     public boolean enterUnaryNode(final UnaryNode unaryNode) {

    49         switch (unaryNode.tokenType()) {

    50         case POS:

    51             return enterPOS(unaryNode);

    52         case BIT_NOT:

    53             return enterBIT_NOT(unaryNode);

    54         case DELETE:

    55             return enterDELETE(unaryNode);

    56         case NEW:

    57             return enterNEW(unaryNode);

    58         case NOT:

    59             return enterNOT(unaryNode);

    60         case NEG:

    61             return enterNEG(unaryNode);

    62         case TYPEOF:

    63             return enterTYPEOF(unaryNode);

    64         case VOID:

    65             return enterVOID(unaryNode);

    66         case DECPREFIX:

    67         case DECPOSTFIX:

    68         case INCPREFIX:

    69         case INCPOSTFIX:

    70             return enterDECINC(unaryNode);

    71         default:

    72             return super.enterUnaryNode(unaryNode);

    73         }

    74     }

    75 

    76     @Override

    77     public final Node leaveUnaryNode(final UnaryNode unaryNode) {

    78         switch (unaryNode.tokenType()) {

    79         case POS:

    80             return leavePOS(unaryNode);

    81         case BIT_NOT:

    82             return leaveBIT_NOT(unaryNode);

    83         case DELETE:

    84             return leaveDELETE(unaryNode);

    85         case NEW:

    86             return leaveNEW(unaryNode);

    87         case NOT:

    88             return leaveNOT(unaryNode);

    89         case NEG:

    90             return leaveNEG(unaryNode);

    91         case TYPEOF:

    92             return leaveTYPEOF(unaryNode);

    93         case VOID:

    94             return leaveVOID(unaryNode);

    95         case DECPREFIX:

    96         case DECPOSTFIX:

    97         case INCPREFIX:

    98         case INCPOSTFIX:

    99             return leaveDECINC(unaryNode);

   100         default:

   101             return super.leaveUnaryNode(unaryNode);

   102         }

   103     }

   104 

   105     @Override

   106     public final boolean enterBinaryNode(final BinaryNode binaryNode) {

   107         switch (binaryNode.tokenType()) {

   108         case ADD:

   109             return enterADD(binaryNode);

   110         case AND:

   111             return enterAND(binaryNode);

   112         case ASSIGN:

   113             return enterASSIGN(binaryNode);

   114         case ASSIGN_ADD:

   115             return enterASSIGN_ADD(binaryNode);

   116         case ASSIGN_BIT_AND:

   117             return enterASSIGN_BIT_AND(binaryNode);

   118         case ASSIGN_BIT_OR:

   119             return enterASSIGN_BIT_OR(binaryNode);

   120         case ASSIGN_BIT_XOR:

   121             return enterASSIGN_BIT_XOR(binaryNode);

   122         case ASSIGN_DIV:

   123             return enterASSIGN_DIV(binaryNode);

   124         case ASSIGN_MOD:

   125             return enterASSIGN_MOD(binaryNode);

   126         case ASSIGN_MUL:

   127             return enterASSIGN_MUL(binaryNode);

   128         case ASSIGN_SAR:

   129             return enterASSIGN_SAR(binaryNode);

   130         case ASSIGN_SHL:

   131             return enterASSIGN_SHL(binaryNode);

   132         case ASSIGN_SHR:

   133             return enterASSIGN_SHR(binaryNode);

   134         case ASSIGN_SUB:

   135             return enterASSIGN_SUB(binaryNode);

   136         case ARROW:

   137             return enterARROW(binaryNode);

   138         case BIT_AND:

   139             return enterBIT_AND(binaryNode);

   140         case BIT_OR:

   141             return enterBIT_OR(binaryNode);

   142         case BIT_XOR:

   143             return enterBIT_XOR(binaryNode);

   144         case COMMARIGHT:

   145             return enterCOMMARIGHT(binaryNode);

   146         case COMMALEFT:

   147             return enterCOMMALEFT(binaryNode);

   148         case DIV:

   149             return enterDIV(binaryNode);

   150         case EQ:

   151             return enterEQ(binaryNode);

   152         case EQ_STRICT:

   153             return enterEQ_STRICT(binaryNode);

   154         case GE:

   155             return enterGE(binaryNode);

   156         case GT:

   157             return enterGT(binaryNode);

   158         case IN:

   159             return enterIN(binaryNode);

   160         case INSTANCEOF:

   161             return enterINSTANCEOF(binaryNode);

   162         case LE:

   163             return enterLE(binaryNode);

   164         case LT:

   165             return enterLT(binaryNode);

   166         case MOD:

   167             return enterMOD(binaryNode);

   168         case MUL:

   169             return enterMUL(binaryNode);

   170         case NE:

   171             return enterNE(binaryNode);

   172         case NE_STRICT:

   173             return enterNE_STRICT(binaryNode);

   174         case OR:

   175             return enterOR(binaryNode);

   176         case SAR:

   177             return enterSAR(binaryNode);

   178         case SHL:

   179             return enterSHL(binaryNode);

   180         case SHR:

   181             return enterSHR(binaryNode);

   182         case SUB:

   183             return enterSUB(binaryNode);

   184         default:

   185             return super.enterBinaryNode(binaryNode);

   186         }

   187     }

   188 

   189     @Override

   190     public final Node leaveBinaryNode(final BinaryNode binaryNode) {

   191         switch (binaryNode.tokenType()) {

   192         case ADD:

   193             return leaveADD(binaryNode);

   194         case AND:

   195             return leaveAND(binaryNode);

   196         case ASSIGN:

   197             return leaveASSIGN(binaryNode);

   198         case ASSIGN_ADD:

   199             return leaveASSIGN_ADD(binaryNode);

   200         case ASSIGN_BIT_AND:

   201             return leaveASSIGN_BIT_AND(binaryNode);

   202         case ASSIGN_BIT_OR:

   203             return leaveASSIGN_BIT_OR(binaryNode);

   204         case ASSIGN_BIT_XOR:

   205             return leaveASSIGN_BIT_XOR(binaryNode);

   206         case ASSIGN_DIV:

   207             return leaveASSIGN_DIV(binaryNode);

   208         case ASSIGN_MOD:

   209             return leaveASSIGN_MOD(binaryNode);

   210         case ASSIGN_MUL:

   211             return leaveASSIGN_MUL(binaryNode);

   212         case ASSIGN_SAR:

   213             return leaveASSIGN_SAR(binaryNode);

   214         case ASSIGN_SHL:

   215             return leaveASSIGN_SHL(binaryNode);

   216         case ASSIGN_SHR:

   217             return leaveASSIGN_SHR(binaryNode);

   218         case ASSIGN_SUB:

   219             return leaveASSIGN_SUB(binaryNode);

   220         case ARROW:

   221             return leaveARROW(binaryNode);

   222         case BIT_AND:

   223             return leaveBIT_AND(binaryNode);

   224         case BIT_OR:

   225             return leaveBIT_OR(binaryNode);

   226         case BIT_XOR:

   227             return leaveBIT_XOR(binaryNode);

   228         case COMMARIGHT:

   229             return leaveCOMMARIGHT(binaryNode);

   230         case COMMALEFT:

   231             return leaveCOMMALEFT(binaryNode);

   232         case DIV:

   233             return leaveDIV(binaryNode);

   234         case EQ:

   235             return leaveEQ(binaryNode);

   236         case EQ_STRICT:

   237             return leaveEQ_STRICT(binaryNode);

   238         case GE:

   239             return leaveGE(binaryNode);

   240         case GT:

   241             return leaveGT(binaryNode);

   242         case IN:

   243             return leaveIN(binaryNode);

   244         case INSTANCEOF:

   245             return leaveINSTANCEOF(binaryNode);

   246         case LE:

   247             return leaveLE(binaryNode);

   248         case LT:

   249             return leaveLT(binaryNode);

   250         case MOD:

   251             return leaveMOD(binaryNode);

   252         case MUL:

   253             return leaveMUL(binaryNode);

   254         case NE:

   255             return leaveNE(binaryNode);

   256         case NE_STRICT:

   257             return leaveNE_STRICT(binaryNode);

   258         case OR:

   259             return leaveOR(binaryNode);

   260         case SAR:

   261             return leaveSAR(binaryNode);

   262         case SHL:

   263             return leaveSHL(binaryNode);

   264         case SHR:

   265             return leaveSHR(binaryNode);

   266         case SUB:

   267             return leaveSUB(binaryNode);

   268         default:

   269             return super.leaveBinaryNode(binaryNode);

   270         }

   271     }

   272 

   273     /*

   274      * Unary entries and exists.

   275      */

   276 

   277     /**

   278      * Unary enter - callback for entering a unary +

   279      *

   280      * @param  unaryNode the node

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

   282      */

   283     public boolean enterPOS(final UnaryNode unaryNode) {

   284         return enterDefault(unaryNode);

   285     }

   286 

   287     /**

   288      * Unary leave - callback for leaving a unary +

   289      *

   290      * @param  unaryNode the node

   291      * @return processed node, which will replace the original one, or the original node

   292      */

   293      public Node leavePOS(final UnaryNode unaryNode) {

   294         return leaveDefault(unaryNode);

   295     }

   296 

   297     /**

   298      * Unary enter - callback for entering a ~ operator

   299      *

   300      * @param  unaryNode the node

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

   302      */

   303     public boolean enterBIT_NOT(final UnaryNode unaryNode) {

   304         return enterDefault(unaryNode);

   305     }

   306 

   307     /**

   308      * Unary leave - callback for leaving a unary ~

   309      *

   310      * @param  unaryNode the node

   311      * @return processed node, which will replace the original one, or the original node

   312      */

   313     public Node leaveBIT_NOT(final UnaryNode unaryNode) {

   314         return leaveDefault(unaryNode);

   315     }

   316 

   317     /**

   318      * Unary enter - callback for entering a ++ or -- operator

   319      *

   320      * @param  unaryNode the node

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

   322      */

   323     public boolean enterDECINC(final UnaryNode unaryNode) {

   324         return enterDefault(unaryNode);

   325     }

   326 

   327     /**

   328      * Unary leave - callback for leaving a ++ or -- operator

   329      *

   330      * @param  unaryNode the node

   331      * @return processed node, which will replace the original one, or the original node

   332      */

   333      public Node leaveDECINC(final UnaryNode unaryNode) {

   334         return leaveDefault(unaryNode);

   335     }

   336 

   337     /**

   338      * Unary enter - callback for entering a delete operator

   339      *

   340      * @param  unaryNode the node

   341      * @return processed node

   342      */

   343     public boolean enterDELETE(final UnaryNode unaryNode) {

   344         return enterDefault(unaryNode);

   345     }

   346 

   347     /**

   348      * Unary leave - callback for leaving a delete operator

   349      *

   350      * @param  unaryNode the node

   351      * @return processed node, which will replace the original one, or the original node

   352      */

   353      public Node leaveDELETE(final UnaryNode unaryNode) {

   354         return leaveDefault(unaryNode);

   355     }

   356 

   357     /**

   358      * Unary enter - callback for entering a new operator

   359      *

   360      * @param  unaryNode the node

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

   362      */

   363     public boolean enterNEW(final UnaryNode unaryNode) {

   364         return enterDefault(unaryNode);

   365     }

   366 

   367     /**

   368      * Unary leave - callback for leaving a new operator

   369      *

   370      * @param  unaryNode the node

   371      * @return processed node, which will replace the original one, or the original node

   372      */

   373      public Node leaveNEW(final UnaryNode unaryNode) {

   374         return leaveDefault(unaryNode);

   375     }

   376 

   377     /**

   378      * Unary enter - callback for entering a ! operator

   379      *

   380      * @param  unaryNode the node

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

   382      */

   383     public boolean enterNOT(final UnaryNode unaryNode) {

   384         return enterDefault(unaryNode);

   385     }

   386 

   387     /**

   388      * Unary leave - callback for leaving a ! operator

   389      *

   390      * @param  unaryNode the node

   391      * @return processed node, which will replace the original one, or the original node

   392      */

   393      public Node leaveNOT(final UnaryNode unaryNode) {

   394         return leaveDefault(unaryNode);

   395     }

   396 

   397     /**

   398      * Unary enter - callback for entering a unary -

   399      *

   400      * @param  unaryNode the node

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

   402      */

   403     public boolean enterNEG(final UnaryNode unaryNode) {

   404         return enterDefault(unaryNode);

   405     }

   406 

   407     /**

   408      * Unary leave - callback for leaving a unary -

   409      *

   410      * @param  unaryNode the node

   411      * @return processed node, which will replace the original one, or the original node

   412      */

   413     public Node leaveNEG(final UnaryNode unaryNode) {

   414         return leaveDefault(unaryNode);

   415     }

   416 

   417     /**

   418      * Unary enter - callback for entering a typeof

   419      *

   420      * @param  unaryNode the node

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

   422      */

   423     public boolean enterTYPEOF(final UnaryNode unaryNode) {

   424         return enterDefault(unaryNode);

   425     }

   426 

   427     /**

   428      * Unary leave - callback for leaving a typeof operator

   429      *

   430      * @param  unaryNode the node

   431      * @return processed node, which will replace the original one, or the original node

   432      */

   433      public Node leaveTYPEOF(final UnaryNode unaryNode) {

   434         return leaveDefault(unaryNode);

   435     }

   436 

   437     /**

   438      * Unary enter - callback for entering a void

   439      *

   440      * @param  unaryNode the node

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

   442      */

   443     public boolean enterVOID(final UnaryNode unaryNode) {

   444         return enterDefault(unaryNode);

   445     }

   446 

   447     /**

   448      * Unary leave - callback for leaving a void

   449      *

   450      * @param  unaryNode the node

   451      * @return processed node, which will replace the original one, or the original node

   452      */

   453      public Node leaveVOID(final UnaryNode unaryNode) {

   454         return leaveDefault(unaryNode);

   455     }

   456 

   457     /**

   458      * Binary enter - callback for entering + operator

   459      *

   460      * @param  binaryNode the node

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

   462      */

   463     public boolean enterADD(final BinaryNode binaryNode) {

   464         return enterDefault(binaryNode);

   465     }

   466 

   467     /**

   468      * Binary leave - callback for leaving a + operator

   469      *

   470      * @param  binaryNode the node

   471      * @return processed node, which will replace the original one, or the original node

   472      */

   473      public Node leaveADD(final BinaryNode binaryNode) {

   474         return leaveDefault(binaryNode);

   475     }

   476 

   477     /**

   478      * Binary enter - callback for entering {@literal &&} operator

   479      *

   480      * @param  binaryNode the node

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

   482      */

   483     public boolean enterAND(final BinaryNode binaryNode) {

   484         return enterDefault(binaryNode);

   485     }

   486 

   487     /**

   488      * Binary leave - callback for leaving a {@literal &&} operator

   489      *

   490      * @param  binaryNode the node

   491      * @return processed node, which will replace the original one, or the original node

   492      */

   493     public Node leaveAND(final BinaryNode binaryNode) {

   494         return leaveDefault(binaryNode);

   495     }

   496 

   497     /**

   498      * Binary enter - callback for entering an assignment

   499      *

   500      * @param  binaryNode the node

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

   502      */

   503     public boolean enterASSIGN(final BinaryNode binaryNode) {

   504         return enterDefault(binaryNode);

   505     }

   506 

   507     /**

   508      * Binary leave - callback for leaving an assignment

   509      *

   510      * @param  binaryNode the node

   511      * @return processed node, which will replace the original one, or the original node

   512      */

   513     public Node leaveASSIGN(final BinaryNode binaryNode) {

   514         return leaveDefault(binaryNode);

   515     }

   516 

   517     /**

   518      * Binary enter - callback for entering += operator

   519      *

   520      * @param  binaryNode the node

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

   522      */

   523     public boolean enterASSIGN_ADD(final BinaryNode binaryNode) {

   524         return enterDefault(binaryNode);

   525     }

   526 

   527     /**

   528      * Binary leave - callback for leaving a += operator

   529      *

   530      * @param  binaryNode the node

   531      * @return processed node, which will replace the original one, or the original node

   532      */

   533     public Node leaveASSIGN_ADD(final BinaryNode binaryNode) {

   534         return leaveDefault(binaryNode);

   535     }

   536 

   537     /**

   538      * Binary enter - callback for entering {@literal &=} operator

   539      *

   540      * @param  binaryNode the node

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

   542      */

   543     public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) {

   544         return enterDefault(binaryNode);

   545     }

   546 

   547     /**

   548      * Binary leave - callback for leaving a {@literal &=} operator

   549      *

   550      * @param  binaryNode the node

   551      * @return processed node, which will replace the original one, or the original node

   552      */

   553     public Node leaveASSIGN_BIT_AND(final BinaryNode binaryNode) {

   554         return leaveDefault(binaryNode);

   555     }

   556 

   557     /**

   558      * Binary enter - callback for entering |= operator

   559      *

   560      * @param  binaryNode the node

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

   562      */

   563     public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) {

   564         return enterDefault(binaryNode);

   565     }

   566 

   567     /**

   568      * Binary leave - callback for leaving a |= operator

   569      *

   570      * @param  binaryNode the node

   571      * @return processed node, which will replace the original one, or the original node

   572      */

   573     public Node leaveASSIGN_BIT_OR(final BinaryNode binaryNode) {

   574         return leaveDefault(binaryNode);

   575     }

   576 

   577     /**

   578      * Binary enter - callback for entering ^= operator

   579      *

   580      * @param  binaryNode the node

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

   582      */

   583     public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {

   584         return enterDefault(binaryNode);

   585     }

   586 

   587     /**

   588      * Binary leave - callback for leaving a ^= operator

   589      *

   590      * @param  binaryNode the node

   591      * @return processed node, which will replace the original one, or the original node

   592      */

   593     public Node leaveASSIGN_BIT_XOR(final BinaryNode binaryNode) {

   594         return leaveDefault(binaryNode);

   595     }

   596 

   597     /**

   598      * Binary enter - callback for entering /= operator

   599      *

   600      * @param  binaryNode the node

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

   602      */

   603     public boolean enterASSIGN_DIV(final BinaryNode binaryNode) {

   604         return enterDefault(binaryNode);

   605     }

   606 

   607     /**

   608      * Binary leave - callback for leaving a /= operator

   609      *

   610      * @param  binaryNode the node

   611      * @return processed node, which will replace the original one, or the original node

   612      */

   613     public Node leaveASSIGN_DIV(final BinaryNode binaryNode) {

   614         return leaveDefault(binaryNode);

   615     }

   616 

   617     /**

   618      * Binary enter - callback for entering %= operator

   619      *

   620      * @param  binaryNode the node

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

   622      */

   623     public boolean enterASSIGN_MOD(final BinaryNode binaryNode) {

   624         return enterDefault(binaryNode);

   625     }

   626 

   627     /**

   628      * Binary leave - callback for leaving a %= operator

   629      *

   630      * @param  binaryNode the node

   631      * @return processed node, which will replace the original one, or the original node

   632      */

   633     public Node leaveASSIGN_MOD(final BinaryNode binaryNode) {

   634         return leaveDefault(binaryNode);

   635     }

   636 

   637     /**

   638      * Binary enter - callback for entering *= operator

   639      *

   640      * @param  binaryNode the node

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

   642      */

   643     public boolean enterASSIGN_MUL(final BinaryNode binaryNode) {

   644         return enterDefault(binaryNode);

   645     }

   646 

   647     /**

   648      * Binary leave - callback for leaving a *= operator

   649      *

   650      * @param  binaryNode the node

   651      * @return processed node, which will replace the original one, or the original node

   652      */

   653     public Node leaveASSIGN_MUL(final BinaryNode binaryNode) {

   654         return leaveDefault(binaryNode);

   655     }

   656 

   657     /**

   658      * Binary enter - callback for entering {@literal >>=} operator

   659      *

   660      * @param  binaryNode the node

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

   662      */

   663     public boolean enterASSIGN_SAR(final BinaryNode binaryNode) {

   664         return enterDefault(binaryNode);

   665     }

   666 

   667     /**

   668      * Binary leave - callback for leaving a {@literal >>=} operator

   669      *

   670      * @param  binaryNode the node

   671      * @return processed node, which will replace the original one, or the original node

   672      */

   673     public Node leaveASSIGN_SAR(final BinaryNode binaryNode) {

   674         return leaveDefault(binaryNode);

   675     }

   676 

   677     /**

   678      * Binary enter - callback for entering a {@literal <<=} operator

   679      *

   680      * @param  binaryNode the node

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

   682      */

   683     public boolean enterASSIGN_SHL(final BinaryNode binaryNode) {

   684         return enterDefault(binaryNode);

   685     }

   686 

   687     /**

   688      * Binary leave - callback for leaving a {@literal <<=} operator

   689      *

   690      * @param  binaryNode the node

   691      * @return processed node, which will replace the original one, or the original node

   692      */

   693     public Node leaveASSIGN_SHL(final BinaryNode binaryNode) {

   694         return leaveDefault(binaryNode);

   695     }

   696 

   697     /**

   698      * Binary enter - callback for entering {@literal >>>=} operator

   699      *

   700      * @param  binaryNode the node

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

   702      */

   703     public boolean enterASSIGN_SHR(final BinaryNode binaryNode) {

   704         return enterDefault(binaryNode);

   705     }

   706 

   707     /**

   708      * Binary leave - callback for leaving a {@literal >>>=} operator

   709      *

   710      * @param  binaryNode the node

   711      * @return processed node, which will replace the original one, or the original node

   712      */

   713     public Node leaveASSIGN_SHR(final BinaryNode binaryNode) {

   714         return leaveDefault(binaryNode);

   715     }

   716 

   717     /**

   718      * Binary enter - callback for entering -= operator

   719      *

   720      * @param  binaryNode the node

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

   722      */

   723     public boolean enterASSIGN_SUB(final BinaryNode binaryNode) {

   724         return enterDefault(binaryNode);

   725     }

   726 

   727     /**

   728      * Binary leave - callback for leaving a -= operator

   729      *

   730      * @param  binaryNode the node

   731      * @return processed node, which will replace the original one, or the original node

   732      */

   733     public Node leaveASSIGN_SUB(final BinaryNode binaryNode) {

   734         return leaveDefault(binaryNode);

   735     }

   736 

   737     /**

   738      * Binary enter - callback for entering a arrow operator

   739      *

   740      * @param  binaryNode the node

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

   742      */

   743     public boolean enterARROW(final BinaryNode binaryNode) {

   744         return enterDefault(binaryNode);

   745     }

   746 

   747     /**

   748      * Binary leave - callback for leaving a arrow operator

   749      *

   750      * @param  binaryNode the node

   751      * @return processed node, which will replace the original one, or the original node

   752      */

   753     public Node leaveARROW(final BinaryNode binaryNode) {

   754         return leaveDefault(binaryNode);

   755     }

   756 

   757     /**

   758      * Binary enter - callback for entering {@literal &} operator

   759      *

   760      * @param  binaryNode the node

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

   762      */

   763     public boolean enterBIT_AND(final BinaryNode binaryNode) {

   764         return enterDefault(binaryNode);

   765     }

   766 

   767     /**

   768      * Binary leave - callback for leaving a {@literal &} operator

   769      *

   770      * @param  binaryNode the node

   771      * @return processed node, which will replace the original one, or the original node

   772      */

   773     public Node leaveBIT_AND(final BinaryNode binaryNode) {

   774         return leaveDefault(binaryNode);

   775     }

   776 

   777     /**

   778      * Binary enter - callback for entering | operator

   779      *

   780      * @param  binaryNode the node

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

   782      */

   783     public boolean enterBIT_OR(final BinaryNode binaryNode) {

   784         return enterDefault(binaryNode);

   785     }

   786 

   787     /**

   788      * Binary leave - callback for leaving a | operator

   789      *

   790      * @param  binaryNode the node

   791      * @return processed node, which will replace the original one, or the original node

   792      */

   793     public Node leaveBIT_OR(final BinaryNode binaryNode) {

   794         return leaveDefault(binaryNode);

   795     }

   796 

   797     /**

   798      * Binary enter - callback for entering ^ operator

   799      *

   800      * @param  binaryNode the node

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

   802      */

   803     public boolean enterBIT_XOR(final BinaryNode binaryNode) {

   804         return enterDefault(binaryNode);

   805     }

   806 

   807     /**

   808      * Binary leave - callback for leaving a  operator

   809      *

   810      * @param  binaryNode the node

   811      * @return processed node, which will replace the original one, or the original node

   812      */

   813     public Node leaveBIT_XOR(final BinaryNode binaryNode) {

   814         return leaveDefault(binaryNode);

   815     }

   816 

   817     /**

   818      * Binary enter - callback for entering comma left operator

   819      * (a, b) where the result is a

   820      *

   821      * @param  binaryNode the node

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

   823      */

   824     public boolean enterCOMMALEFT(final BinaryNode binaryNode) {

   825         return enterDefault(binaryNode);

   826     }

   827 

   828     /**

   829      * Binary leave - callback for leaving a comma left operator

   830      * (a, b) where the result is a

   831      *

   832      * @param  binaryNode the node

   833      * @return processed node, which will replace the original one, or the original node

   834      */

   835     public Node leaveCOMMALEFT(final BinaryNode binaryNode) {

   836         return leaveDefault(binaryNode);

   837     }

   838 

   839     /**

   840      * Binary enter - callback for entering comma right operator

   841      * (a, b) where the result is b

   842      *

   843      * @param  binaryNode the node

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

   845      */

   846     public boolean enterCOMMARIGHT(final BinaryNode binaryNode) {

   847         return enterDefault(binaryNode);

   848     }

   849 

   850     /**

   851      * Binary leave - callback for leaving a comma left operator

   852      * (a, b) where the result is b

   853      *

   854      * @param  binaryNode the node

   855      * @return processed node, which will replace the original one, or the original node

   856      */

   857     public Node leaveCOMMARIGHT(final BinaryNode binaryNode) {

   858         return leaveDefault(binaryNode);

   859     }

   860 

   861     /**

   862      * Binary enter - callback for entering a division

   863      *

   864      * @param  binaryNode the node

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

   866      */

   867     public boolean enterDIV(final BinaryNode binaryNode) {

   868         return enterDefault(binaryNode);

   869     }

   870 

   871     /**

   872      * Binary leave - callback for leaving a division

   873      *

   874      * @param  binaryNode the node

   875      * @return processed node, which will replace the original one, or the original node

   876      */

   877     public Node leaveDIV(final BinaryNode binaryNode) {

   878         return leaveDefault(binaryNode);

   879     }

   880 

   881     /**

   882      * Binary enter - callback for entering == operator

   883      *

   884      * @param  binaryNode the node

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

   886      */

   887     public boolean enterEQ(final BinaryNode binaryNode) {

   888         return enterDefault(binaryNode);

   889     }

   890 

   891     /**

   892      * Binary leave - callback for leaving == operator

   893      *

   894      * @param  binaryNode the node

   895      * @return processed node, which will replace the original one, or the original node

   896      */

   897     public Node leaveEQ(final BinaryNode binaryNode) {

   898         return leaveDefault(binaryNode);

   899     }

   900 

   901     /**

   902      * Binary enter - callback for entering === operator

   903      *

   904      * @param  binaryNode the node

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

   906      */

   907     public boolean enterEQ_STRICT(final BinaryNode binaryNode) {

   908         return enterDefault(binaryNode);

   909     }

   910 

   911     /**

   912      * Binary leave - callback for leaving === operator

   913      *

   914      * @param  binaryNode the node

   915      * @return processed node, which will replace the original one, or the original node

   916      */

   917     public Node leaveEQ_STRICT(final BinaryNode binaryNode) {

   918         return leaveDefault(binaryNode);

   919     }

   920 

   921     /**

   922      * Binary enter - callback for entering {@literal >=} operator

   923      *

   924      * @param  binaryNode the node

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

   926      */

   927     public boolean enterGE(final BinaryNode binaryNode) {

   928         return enterDefault(binaryNode);

   929     }

   930 

   931     /**

   932      * Binary leave - callback for leaving {@literal >=} operator

   933      *

   934      * @param  binaryNode the node

   935      * @return processed node, which will replace the original one, or the original node

   936      */

   937     public Node leaveGE(final BinaryNode binaryNode) {

   938         return leaveDefault(binaryNode);

   939     }

   940 

   941     /**

   942      * Binary enter - callback for entering {@literal >} operator

   943      *

   944      * @param  binaryNode the node

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

   946      */

   947     public boolean enterGT(final BinaryNode binaryNode) {

   948         return enterDefault(binaryNode);

   949     }

   950 

   951     /**

   952      * Binary leave - callback for leaving {@literal >} operator

   953      *

   954      * @param  binaryNode the node

   955      * @return processed node, which will replace the original one, or the original node

   956      */

   957     public Node leaveGT(final BinaryNode binaryNode) {

   958         return leaveDefault(binaryNode);

   959     }

   960 

   961     /**

   962      * Binary enter - callback for entering in operator

   963      *

   964      * @param  binaryNode the node

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

   966      */

   967     public boolean enterIN(final BinaryNode binaryNode) {

   968         return enterDefault(binaryNode);

   969     }

   970 

   971     /**

   972      * Binary leave - callback for leaving in operator

   973      *

   974      * @param  binaryNode the node

   975      * @return processed node, which will replace the original one, or the original node

   976      */

   977     public Node leaveIN(final BinaryNode binaryNode) {

   978         return leaveDefault(binaryNode);

   979     }

   980 

   981     /**

   982      * Binary enter - callback for entering instanceof operator

   983      *

   984      * @param  binaryNode the node

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

   986      */

   987     public boolean enterINSTANCEOF(final BinaryNode binaryNode) {

   988         return enterDefault(binaryNode);

   989     }

   990 

   991     /**

   992      * Binary leave - callback for leaving instanceof operator

   993      *

   994      * @param  binaryNode the node

   995      * @return processed node, which will replace the original one, or the original node

   996      */

   997     public Node leaveINSTANCEOF(final BinaryNode binaryNode) {

   998         return leaveDefault(binaryNode);

   999     }

  1000 

  1001     /**

  1002      * Binary enter - callback for entering {@literal <=} operator

  1003      *

  1004      * @param  binaryNode the node

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

  1006      */

  1007     public boolean enterLE(final BinaryNode binaryNode) {

  1008         return enterDefault(binaryNode);

  1009     }

  1010 

  1011     /**

  1012      * Binary leave - callback for leaving {@literal <=} operator

  1013      *

  1014      * @param  binaryNode the node

  1015      * @return processed node, which will replace the original one, or the original node

  1016      */

  1017     public Node leaveLE(final BinaryNode binaryNode) {

  1018         return leaveDefault(binaryNode);

  1019     }

  1020 

  1021     /**

  1022      * Binary enter - callback for entering {@literal <} operator

  1023      *

  1024      * @param  binaryNode the node

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

  1026      */

  1027     public boolean enterLT(final BinaryNode binaryNode) {

  1028         return enterDefault(binaryNode);

  1029     }

  1030 

  1031     /**

  1032      * Binary leave - callback for leaving {@literal <} operator

  1033      *

  1034      * @param  binaryNode the node

  1035      * @return processed node, which will replace the original one, or the original node

  1036      */

  1037     public Node leaveLT(final BinaryNode binaryNode) {

  1038         return leaveDefault(binaryNode);

  1039     }

  1040     /**

  1041      * Binary enter - callback for entering % operator

  1042      *

  1043      * @param  binaryNode the node

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

  1045      */

  1046     public boolean enterMOD(final BinaryNode binaryNode) {

  1047         return enterDefault(binaryNode);

  1048     }

  1049 

  1050     /**

  1051      * Binary leave - callback for leaving % operator

  1052      *

  1053      * @param  binaryNode the node

  1054      * @return processed node, which will replace the original one, or the original node

  1055      */

  1056     public Node leaveMOD(final BinaryNode binaryNode) {

  1057         return leaveDefault(binaryNode);

  1058     }

  1059 

  1060     /**

  1061      * Binary enter - callback for entering * operator

  1062      *

  1063      * @param  binaryNode the node

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

  1065      */

  1066     public boolean enterMUL(final BinaryNode binaryNode) {

  1067         return enterDefault(binaryNode);

  1068     }

  1069 

  1070     /**

  1071      * Binary leave - callback for leaving * operator

  1072      *

  1073      * @param  binaryNode the node

  1074      * @return processed node, which will replace the original one, or the original node

  1075      */

  1076     public Node leaveMUL(final BinaryNode binaryNode) {

  1077         return leaveDefault(binaryNode);

  1078     }

  1079 

  1080     /**

  1081      * Binary enter - callback for entering != operator

  1082      *

  1083      * @param  binaryNode the node

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

  1085      */

  1086     public boolean enterNE(final BinaryNode binaryNode) {

  1087         return enterDefault(binaryNode);

  1088     }

  1089 

  1090     /**

  1091      * Binary leave - callback for leaving != operator

  1092      *

  1093      * @param  binaryNode the node

  1094      * @return processed node, which will replace the original one, or the original node

  1095      */

  1096     public Node leaveNE(final BinaryNode binaryNode) {

  1097         return leaveDefault(binaryNode);

  1098     }

  1099 

  1100     /**

  1101      * Binary enter - callback for entering a !== operator

  1102      *

  1103      * @param  binaryNode the node

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

  1105      */

  1106     public boolean enterNE_STRICT(final BinaryNode binaryNode) {

  1107         return enterDefault(binaryNode);

  1108     }

  1109 

  1110     /**

  1111      * Binary leave - callback for leaving !== operator

  1112      *

  1113      * @param  binaryNode the node

  1114      * @return processed node, which will replace the original one, or the original node

  1115      */

  1116     public Node leaveNE_STRICT(final BinaryNode binaryNode) {

  1117         return leaveDefault(binaryNode);

  1118     }

  1119 

  1120     /**

  1121      * Binary enter - callback for entering || operator

  1122      *

  1123      * @param  binaryNode the node

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

  1125      */

  1126     public boolean enterOR(final BinaryNode binaryNode) {

  1127         return enterDefault(binaryNode);

  1128     }

  1129 

  1130     /**

  1131      * Binary leave - callback for leaving || operator

  1132      *

  1133      * @param  binaryNode the node

  1134      * @return processed node, which will replace the original one, or the original node