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 ADD:
  51             return enterADD(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 SUB:
  61             return enterSUB(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 ADD:
  80             return leaveADD(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 SUB:
  90             return leaveSUB(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 enterADD(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 leaveADD(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 enterSUB(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 leaveSUB(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
1135      */
1136     public Node leaveOR(final BinaryNode binaryNode) {
1137         return leaveDefault(binaryNode);
1138     }
1139 
1140     /**
1141      * Binary enter - callback for entering {@literal >>} operator
1142      *
1143      * @param  binaryNode the node
1144      * @return true if traversal should continue and node children be traversed, false otherwise
1145      */
1146     public boolean enterSAR(final BinaryNode binaryNode) {
1147         return enterDefault(binaryNode);
1148     }
1149 
1150     /**
1151      * Binary leave - callback for leaving {@literal >>} operator
1152      *
1153      * @param  binaryNode the node
1154      * @return processed node, which will replace the original one, or the original node
1155      */
1156     public Node leaveSAR(final BinaryNode binaryNode) {
1157         return leaveDefault(binaryNode);
1158     }
1159 
1160     /**
1161      * Binary enter - callback for entering {@literal <<} operator
1162      *
1163      * @param  binaryNode the node
1164      * @return true if traversal should continue and node children be traversed, false otherwise
1165      */
1166     public boolean enterSHL(final BinaryNode binaryNode) {
1167         return enterDefault(binaryNode);
1168     }
1169 
1170     /**
1171      * Binary leave - callback for leaving {@literal <<} operator
1172      *
1173      * @param  binaryNode the node
1174      * @return processed node, which will replace the original one, or the original node
1175      */
1176     public Node leaveSHL(final BinaryNode binaryNode) {
1177         return leaveDefault(binaryNode);
1178     }
1179     /**
1180      * Binary enter - callback for entering {@literal >>>} operator
1181      *
1182      * @param  binaryNode the node
1183      * @return true if traversal should continue and node children be traversed, false otherwise
1184      */
1185     public boolean enterSHR(final BinaryNode binaryNode) {
1186         return enterDefault(binaryNode);
1187     }
1188 
1189     /**
1190      * Binary leave - callback for leaving {@literal >>>} operator
1191      *
1192      * @param  binaryNode the node
1193      * @return processed node, which will replace the original one, or the original node
1194      */
1195     public Node leaveSHR(final BinaryNode binaryNode) {
1196         return leaveDefault(binaryNode);
1197     }
1198 
1199     /**
1200      * Binary enter - callback for entering - operator
1201      *
1202      * @param  binaryNode the node
1203      * @return true if traversal should continue and node children be traversed, false otherwise
1204      */
1205     public boolean enterSUB(final BinaryNode binaryNode) {
1206         return enterDefault(binaryNode);
1207     }
1208 
1209     /**
1210      * Binary leave - callback for leaving - operator
1211      *
1212      * @param  binaryNode the node
1213      * @return processed node, which will replace the original one, or the original node
1214      */
1215     public Node leaveSUB(final BinaryNode binaryNode) {
1216         return leaveDefault(binaryNode);
1217     }
1218 }