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 */ NodeOperatorVisitor(final T lc)43 public NodeOperatorVisitor(final T lc) { 44 super(lc); 45 } 46 47 @Override enterUnaryNode(final UnaryNode unaryNode)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 leaveUnaryNode(final UnaryNode unaryNode)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 enterBinaryNode(final BinaryNode binaryNode)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 DIV: 147 return enterDIV(binaryNode); 148 case EQ: 149 return enterEQ(binaryNode); 150 case EQ_STRICT: 151 return enterEQ_STRICT(binaryNode); 152 case GE: 153 return enterGE(binaryNode); 154 case GT: 155 return enterGT(binaryNode); 156 case IN: 157 return enterIN(binaryNode); 158 case INSTANCEOF: 159 return enterINSTANCEOF(binaryNode); 160 case LE: 161 return enterLE(binaryNode); 162 case LT: 163 return enterLT(binaryNode); 164 case MOD: 165 return enterMOD(binaryNode); 166 case MUL: 167 return enterMUL(binaryNode); 168 case NE: 169 return enterNE(binaryNode); 170 case NE_STRICT: 171 return enterNE_STRICT(binaryNode); 172 case OR: 173 return enterOR(binaryNode); 174 case SAR: 175 return enterSAR(binaryNode); 176 case SHL: 177 return enterSHL(binaryNode); 178 case SHR: 179 return enterSHR(binaryNode); 180 case SUB: 181 return enterSUB(binaryNode); 182 default: 183 return super.enterBinaryNode(binaryNode); 184 } 185 } 186 187 @Override leaveBinaryNode(final BinaryNode binaryNode)188 public final Node leaveBinaryNode(final BinaryNode binaryNode) { 189 switch (binaryNode.tokenType()) { 190 case ADD: 191 return leaveADD(binaryNode); 192 case AND: 193 return leaveAND(binaryNode); 194 case ASSIGN: 195 return leaveASSIGN(binaryNode); 196 case ASSIGN_ADD: 197 return leaveASSIGN_ADD(binaryNode); 198 case ASSIGN_BIT_AND: 199 return leaveASSIGN_BIT_AND(binaryNode); 200 case ASSIGN_BIT_OR: 201 return leaveASSIGN_BIT_OR(binaryNode); 202 case ASSIGN_BIT_XOR: 203 return leaveASSIGN_BIT_XOR(binaryNode); 204 case ASSIGN_DIV: 205 return leaveASSIGN_DIV(binaryNode); 206 case ASSIGN_MOD: 207 return leaveASSIGN_MOD(binaryNode); 208 case ASSIGN_MUL: 209 return leaveASSIGN_MUL(binaryNode); 210 case ASSIGN_SAR: 211 return leaveASSIGN_SAR(binaryNode); 212 case ASSIGN_SHL: 213 return leaveASSIGN_SHL(binaryNode); 214 case ASSIGN_SHR: 215 return leaveASSIGN_SHR(binaryNode); 216 case ASSIGN_SUB: 217 return leaveASSIGN_SUB(binaryNode); 218 case ARROW: 219 return leaveARROW(binaryNode); 220 case BIT_AND: 221 return leaveBIT_AND(binaryNode); 222 case BIT_OR: 223 return leaveBIT_OR(binaryNode); 224 case BIT_XOR: 225 return leaveBIT_XOR(binaryNode); 226 case COMMARIGHT: 227 return leaveCOMMARIGHT(binaryNode); 228 case DIV: 229 return leaveDIV(binaryNode); 230 case EQ: 231 return leaveEQ(binaryNode); 232 case EQ_STRICT: 233 return leaveEQ_STRICT(binaryNode); 234 case GE: 235 return leaveGE(binaryNode); 236 case GT: 237 return leaveGT(binaryNode); 238 case IN: 239 return leaveIN(binaryNode); 240 case INSTANCEOF: 241 return leaveINSTANCEOF(binaryNode); 242 case LE: 243 return leaveLE(binaryNode); 244 case LT: 245 return leaveLT(binaryNode); 246 case MOD: 247 return leaveMOD(binaryNode); 248 case MUL: 249 return leaveMUL(binaryNode); 250 case NE: 251 return leaveNE(binaryNode); 252 case NE_STRICT: 253 return leaveNE_STRICT(binaryNode); 254 case OR: 255 return leaveOR(binaryNode); 256 case SAR: 257 return leaveSAR(binaryNode); 258 case SHL: 259 return leaveSHL(binaryNode); 260 case SHR: 261 return leaveSHR(binaryNode); 262 case SUB: 263 return leaveSUB(binaryNode); 264 default: 265 return super.leaveBinaryNode(binaryNode); 266 } 267 } 268 269 /* 270 * Unary entries and exists. 271 */ 272 273 /** 274 * Unary enter - callback for entering a unary + 275 * 276 * @param unaryNode the node 277 * @return true if traversal should continue and node children be traversed, false otherwise 278 */ enterPOS(final UnaryNode unaryNode)279 public boolean enterPOS(final UnaryNode unaryNode) { 280 return enterDefault(unaryNode); 281 } 282 283 /** 284 * Unary leave - callback for leaving a unary + 285 * 286 * @param unaryNode the node 287 * @return processed node, which will replace the original one, or the original node 288 */ leavePOS(final UnaryNode unaryNode)289 public Node leavePOS(final UnaryNode unaryNode) { 290 return leaveDefault(unaryNode); 291 } 292 293 /** 294 * Unary enter - callback for entering a ~ operator 295 * 296 * @param unaryNode the node 297 * @return true if traversal should continue and node children be traversed, false otherwise 298 */ enterBIT_NOT(final UnaryNode unaryNode)299 public boolean enterBIT_NOT(final UnaryNode unaryNode) { 300 return enterDefault(unaryNode); 301 } 302 303 /** 304 * Unary leave - callback for leaving a unary ~ 305 * 306 * @param unaryNode the node 307 * @return processed node, which will replace the original one, or the original node 308 */ leaveBIT_NOT(final UnaryNode unaryNode)309 public Node leaveBIT_NOT(final UnaryNode unaryNode) { 310 return leaveDefault(unaryNode); 311 } 312 313 /** 314 * Unary enter - callback for entering a ++ or -- operator 315 * 316 * @param unaryNode the node 317 * @return true if traversal should continue and node children be traversed, false otherwise 318 */ enterDECINC(final UnaryNode unaryNode)319 public boolean enterDECINC(final UnaryNode unaryNode) { 320 return enterDefault(unaryNode); 321 } 322 323 /** 324 * Unary leave - callback for leaving a ++ or -- operator 325 * 326 * @param unaryNode the node 327 * @return processed node, which will replace the original one, or the original node 328 */ leaveDECINC(final UnaryNode unaryNode)329 public Node leaveDECINC(final UnaryNode unaryNode) { 330 return leaveDefault(unaryNode); 331 } 332 333 /** 334 * Unary enter - callback for entering a delete operator 335 * 336 * @param unaryNode the node 337 * @return processed node 338 */ enterDELETE(final UnaryNode unaryNode)339 public boolean enterDELETE(final UnaryNode unaryNode) { 340 return enterDefault(unaryNode); 341 } 342 343 /** 344 * Unary leave - callback for leaving a delete operator 345 * 346 * @param unaryNode the node 347 * @return processed node, which will replace the original one, or the original node 348 */ leaveDELETE(final UnaryNode unaryNode)349 public Node leaveDELETE(final UnaryNode unaryNode) { 350 return leaveDefault(unaryNode); 351 } 352 353 /** 354 * Unary enter - callback for entering a new operator 355 * 356 * @param unaryNode the node 357 * @return true if traversal should continue and node children be traversed, false otherwise 358 */ enterNEW(final UnaryNode unaryNode)359 public boolean enterNEW(final UnaryNode unaryNode) { 360 return enterDefault(unaryNode); 361 } 362 363 /** 364 * Unary leave - callback for leaving a new operator 365 * 366 * @param unaryNode the node 367 * @return processed node, which will replace the original one, or the original node 368 */ leaveNEW(final UnaryNode unaryNode)369 public Node leaveNEW(final UnaryNode unaryNode) { 370 return leaveDefault(unaryNode); 371 } 372 373 /** 374 * Unary enter - callback for entering a ! operator 375 * 376 * @param unaryNode the node 377 * @return true if traversal should continue and node children be traversed, false otherwise 378 */ enterNOT(final UnaryNode unaryNode)379 public boolean enterNOT(final UnaryNode unaryNode) { 380 return enterDefault(unaryNode); 381 } 382 383 /** 384 * Unary leave - callback for leaving a ! operator 385 * 386 * @param unaryNode the node 387 * @return processed node, which will replace the original one, or the original node 388 */ leaveNOT(final UnaryNode unaryNode)389 public Node leaveNOT(final UnaryNode unaryNode) { 390 return leaveDefault(unaryNode); 391 } 392 393 /** 394 * Unary enter - callback for entering a unary - 395 * 396 * @param unaryNode the node 397 * @return true if traversal should continue and node children be traversed, false otherwise 398 */ enterNEG(final UnaryNode unaryNode)399 public boolean enterNEG(final UnaryNode unaryNode) { 400 return enterDefault(unaryNode); 401 } 402 403 /** 404 * Unary leave - callback for leaving a unary - 405 * 406 * @param unaryNode the node 407 * @return processed node, which will replace the original one, or the original node 408 */ leaveNEG(final UnaryNode unaryNode)409 public Node leaveNEG(final UnaryNode unaryNode) { 410 return leaveDefault(unaryNode); 411 } 412 413 /** 414 * Unary enter - callback for entering a typeof 415 * 416 * @param unaryNode the node 417 * @return true if traversal should continue and node children be traversed, false otherwise 418 */ enterTYPEOF(final UnaryNode unaryNode)419 public boolean enterTYPEOF(final UnaryNode unaryNode) { 420 return enterDefault(unaryNode); 421 } 422 423 /** 424 * Unary leave - callback for leaving a typeof operator 425 * 426 * @param unaryNode the node 427 * @return processed node, which will replace the original one, or the original node 428 */ leaveTYPEOF(final UnaryNode unaryNode)429 public Node leaveTYPEOF(final UnaryNode unaryNode) { 430 return leaveDefault(unaryNode); 431 } 432 433 /** 434 * Unary enter - callback for entering a void 435 * 436 * @param unaryNode the node 437 * @return true if traversal should continue and node children be traversed, false otherwise 438 */ enterVOID(final UnaryNode unaryNode)439 public boolean enterVOID(final UnaryNode unaryNode) { 440 return enterDefault(unaryNode); 441 } 442 443 /** 444 * Unary leave - callback for leaving a void 445 * 446 * @param unaryNode the node 447 * @return processed node, which will replace the original one, or the original node 448 */ leaveVOID(final UnaryNode unaryNode)449 public Node leaveVOID(final UnaryNode unaryNode) { 450 return leaveDefault(unaryNode); 451 } 452 453 /** 454 * Binary enter - callback for entering + operator 455 * 456 * @param binaryNode the node 457 * @return true if traversal should continue and node children be traversed, false otherwise 458 */ enterADD(final BinaryNode binaryNode)459 public boolean enterADD(final BinaryNode binaryNode) { 460 return enterDefault(binaryNode); 461 } 462 463 /** 464 * Binary leave - callback for leaving a + operator 465 * 466 * @param binaryNode the node 467 * @return processed node, which will replace the original one, or the original node 468 */ leaveADD(final BinaryNode binaryNode)469 public Node leaveADD(final BinaryNode binaryNode) { 470 return leaveDefault(binaryNode); 471 } 472 473 /** 474 * Binary enter - callback for entering {@literal &&} operator 475 * 476 * @param binaryNode the node 477 * @return true if traversal should continue and node children be traversed, false otherwise 478 */ enterAND(final BinaryNode binaryNode)479 public boolean enterAND(final BinaryNode binaryNode) { 480 return enterDefault(binaryNode); 481 } 482 483 /** 484 * Binary leave - callback for leaving a {@literal &&} operator 485 * 486 * @param binaryNode the node 487 * @return processed node, which will replace the original one, or the original node 488 */ leaveAND(final BinaryNode binaryNode)489 public Node leaveAND(final BinaryNode binaryNode) { 490 return leaveDefault(binaryNode); 491 } 492 493 /** 494 * Binary enter - callback for entering an assignment 495 * 496 * @param binaryNode the node 497 * @return true if traversal should continue and node children be traversed, false otherwise 498 */ enterASSIGN(final BinaryNode binaryNode)499 public boolean enterASSIGN(final BinaryNode binaryNode) { 500 return enterDefault(binaryNode); 501 } 502 503 /** 504 * Binary leave - callback for leaving an assignment 505 * 506 * @param binaryNode the node 507 * @return processed node, which will replace the original one, or the original node 508 */ leaveASSIGN(final BinaryNode binaryNode)509 public Node leaveASSIGN(final BinaryNode binaryNode) { 510 return leaveDefault(binaryNode); 511 } 512 513 /** 514 * Binary enter - callback for entering += operator 515 * 516 * @param binaryNode the node 517 * @return true if traversal should continue and node children be traversed, false otherwise 518 */ enterASSIGN_ADD(final BinaryNode binaryNode)519 public boolean enterASSIGN_ADD(final BinaryNode binaryNode) { 520 return enterDefault(binaryNode); 521 } 522 523 /** 524 * Binary leave - callback for leaving a += operator 525 * 526 * @param binaryNode the node 527 * @return processed node, which will replace the original one, or the original node 528 */ leaveASSIGN_ADD(final BinaryNode binaryNode)529 public Node leaveASSIGN_ADD(final BinaryNode binaryNode) { 530 return leaveDefault(binaryNode); 531 } 532 533 /** 534 * Binary enter - callback for entering {@literal &=} operator 535 * 536 * @param binaryNode the node 537 * @return true if traversal should continue and node children be traversed, false otherwise 538 */ enterASSIGN_BIT_AND(final BinaryNode binaryNode)539 public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) { 540 return enterDefault(binaryNode); 541 } 542 543 /** 544 * Binary leave - callback for leaving a {@literal &=} operator 545 * 546 * @param binaryNode the node 547 * @return processed node, which will replace the original one, or the original node 548 */ leaveASSIGN_BIT_AND(final BinaryNode binaryNode)549 public Node leaveASSIGN_BIT_AND(final BinaryNode binaryNode) { 550 return leaveDefault(binaryNode); 551 } 552 553 /** 554 * Binary enter - callback for entering |= operator 555 * 556 * @param binaryNode the node 557 * @return true if traversal should continue and node children be traversed, false otherwise 558 */ enterASSIGN_BIT_OR(final BinaryNode binaryNode)559 public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) { 560 return enterDefault(binaryNode); 561 } 562 563 /** 564 * Binary leave - callback for leaving a |= operator 565 * 566 * @param binaryNode the node 567 * @return processed node, which will replace the original one, or the original node 568 */ leaveASSIGN_BIT_OR(final BinaryNode binaryNode)569 public Node leaveASSIGN_BIT_OR(final BinaryNode binaryNode) { 570 return leaveDefault(binaryNode); 571 } 572 573 /** 574 * Binary enter - callback for entering ^= operator 575 * 576 * @param binaryNode the node 577 * @return true if traversal should continue and node children be traversed, false otherwise 578 */ enterASSIGN_BIT_XOR(final BinaryNode binaryNode)579 public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) { 580 return enterDefault(binaryNode); 581 } 582 583 /** 584 * Binary leave - callback for leaving a ^= operator 585 * 586 * @param binaryNode the node 587 * @return processed node, which will replace the original one, or the original node 588 */ leaveASSIGN_BIT_XOR(final BinaryNode binaryNode)589 public Node leaveASSIGN_BIT_XOR(final BinaryNode binaryNode) { 590 return leaveDefault(binaryNode); 591 } 592 593 /** 594 * Binary enter - callback for entering /= operator 595 * 596 * @param binaryNode the node 597 * @return true if traversal should continue and node children be traversed, false otherwise 598 */ enterASSIGN_DIV(final BinaryNode binaryNode)599 public boolean enterASSIGN_DIV(final BinaryNode binaryNode) { 600 return enterDefault(binaryNode); 601 } 602 603 /** 604 * Binary leave - callback for leaving a /= operator 605 * 606 * @param binaryNode the node 607 * @return processed node, which will replace the original one, or the original node 608 */ leaveASSIGN_DIV(final BinaryNode binaryNode)609 public Node leaveASSIGN_DIV(final BinaryNode binaryNode) { 610 return leaveDefault(binaryNode); 611 } 612 613 /** 614 * Binary enter - callback for entering %= operator 615 * 616 * @param binaryNode the node 617 * @return true if traversal should continue and node children be traversed, false otherwise 618 */ enterASSIGN_MOD(final BinaryNode binaryNode)619 public boolean enterASSIGN_MOD(final BinaryNode binaryNode) { 620 return enterDefault(binaryNode); 621 } 622 623 /** 624 * Binary leave - callback for leaving a %= operator 625 * 626 * @param binaryNode the node 627 * @return processed node, which will replace the original one, or the original node 628 */ leaveASSIGN_MOD(final BinaryNode binaryNode)629 public Node leaveASSIGN_MOD(final BinaryNode binaryNode) { 630 return leaveDefault(binaryNode); 631 } 632 633 /** 634 * Binary enter - callback for entering *= operator 635 * 636 * @param binaryNode the node 637 * @return true if traversal should continue and node children be traversed, false otherwise 638 */ enterASSIGN_MUL(final BinaryNode binaryNode)639 public boolean enterASSIGN_MUL(final BinaryNode binaryNode) { 640 return enterDefault(binaryNode); 641 } 642 643 /** 644 * Binary leave - callback for leaving a *= operator 645 * 646 * @param binaryNode the node 647 * @return processed node, which will replace the original one, or the original node 648 */ leaveASSIGN_MUL(final BinaryNode binaryNode)649 public Node leaveASSIGN_MUL(final BinaryNode binaryNode) { 650 return leaveDefault(binaryNode); 651 } 652 653 /** 654 * Binary enter - callback for entering {@literal >>=} operator 655 * 656 * @param binaryNode the node 657 * @return true if traversal should continue and node children be traversed, false otherwise 658 */ enterASSIGN_SAR(final BinaryNode binaryNode)659 public boolean enterASSIGN_SAR(final BinaryNode binaryNode) { 660 return enterDefault(binaryNode); 661 } 662 663 /** 664 * Binary leave - callback for leaving a {@literal >>=} operator 665 * 666 * @param binaryNode the node 667 * @return processed node, which will replace the original one, or the original node 668 */ leaveASSIGN_SAR(final BinaryNode binaryNode)669 public Node leaveASSIGN_SAR(final BinaryNode binaryNode) { 670 return leaveDefault(binaryNode); 671 } 672 673 /** 674 * Binary enter - callback for entering a {@literal <<=} operator 675 * 676 * @param binaryNode the node 677 * @return true if traversal should continue and node children be traversed, false otherwise 678 */ enterASSIGN_SHL(final BinaryNode binaryNode)679 public boolean enterASSIGN_SHL(final BinaryNode binaryNode) { 680 return enterDefault(binaryNode); 681 } 682 683 /** 684 * Binary leave - callback for leaving a {@literal <<=} operator 685 * 686 * @param binaryNode the node 687 * @return processed node, which will replace the original one, or the original node 688 */ leaveASSIGN_SHL(final BinaryNode binaryNode)689 public Node leaveASSIGN_SHL(final BinaryNode binaryNode) { 690 return leaveDefault(binaryNode); 691 } 692 693 /** 694 * Binary enter - callback for entering {@literal >>>=} operator 695 * 696 * @param binaryNode the node 697 * @return true if traversal should continue and node children be traversed, false otherwise 698 */ enterASSIGN_SHR(final BinaryNode binaryNode)699 public boolean enterASSIGN_SHR(final BinaryNode binaryNode) { 700 return enterDefault(binaryNode); 701 } 702 703 /** 704 * Binary leave - callback for leaving a {@literal >>>=} operator 705 * 706 * @param binaryNode the node 707 * @return processed node, which will replace the original one, or the original node 708 */ leaveASSIGN_SHR(final BinaryNode binaryNode)709 public Node leaveASSIGN_SHR(final BinaryNode binaryNode) { 710 return leaveDefault(binaryNode); 711 } 712 713 /** 714 * Binary enter - callback for entering -= operator 715 * 716 * @param binaryNode the node 717 * @return true if traversal should continue and node children be traversed, false otherwise 718 */ enterASSIGN_SUB(final BinaryNode binaryNode)719 public boolean enterASSIGN_SUB(final BinaryNode binaryNode) { 720 return enterDefault(binaryNode); 721 } 722 723 /** 724 * Binary leave - callback for leaving a -= operator 725 * 726 * @param binaryNode the node 727 * @return processed node, which will replace the original one, or the original node 728 */ leaveASSIGN_SUB(final BinaryNode binaryNode)729 public Node leaveASSIGN_SUB(final BinaryNode binaryNode) { 730 return leaveDefault(binaryNode); 731 } 732 733 /** 734 * Binary enter - callback for entering a arrow operator 735 * 736 * @param binaryNode the node 737 * @return true if traversal should continue and node children be traversed, false otherwise 738 */ enterARROW(final BinaryNode binaryNode)739 public boolean enterARROW(final BinaryNode binaryNode) { 740 return enterDefault(binaryNode); 741 } 742 743 /** 744 * Binary leave - callback for leaving a arrow operator 745 * 746 * @param binaryNode the node 747 * @return processed node, which will replace the original one, or the original node 748 */ leaveARROW(final BinaryNode binaryNode)749 public Node leaveARROW(final BinaryNode binaryNode) { 750 return leaveDefault(binaryNode); 751 } 752 753 /** 754 * Binary enter - callback for entering {@literal &} operator 755 * 756 * @param binaryNode the node 757 * @return true if traversal should continue and node children be traversed, false otherwise 758 */ enterBIT_AND(final BinaryNode binaryNode)759 public boolean enterBIT_AND(final BinaryNode binaryNode) { 760 return enterDefault(binaryNode); 761 } 762 763 /** 764 * Binary leave - callback for leaving a {@literal &} operator 765 * 766 * @param binaryNode the node 767 * @return processed node, which will replace the original one, or the original node 768 */ leaveBIT_AND(final BinaryNode binaryNode)769 public Node leaveBIT_AND(final BinaryNode binaryNode) { 770 return leaveDefault(binaryNode); 771 } 772 773 /** 774 * Binary enter - callback for entering | operator 775 * 776 * @param binaryNode the node 777 * @return true if traversal should continue and node children be traversed, false otherwise 778 */ enterBIT_OR(final BinaryNode binaryNode)779 public boolean enterBIT_OR(final BinaryNode binaryNode) { 780 return enterDefault(binaryNode); 781 } 782 783 /** 784 * Binary leave - callback for leaving a | operator 785 * 786 * @param binaryNode the node 787 * @return processed node, which will replace the original one, or the original node 788 */ leaveBIT_OR(final BinaryNode binaryNode)789 public Node leaveBIT_OR(final BinaryNode binaryNode) { 790 return leaveDefault(binaryNode); 791 } 792 793 /** 794 * Binary enter - callback for entering ^ operator 795 * 796 * @param binaryNode the node 797 * @return true if traversal should continue and node children be traversed, false otherwise 798 */ enterBIT_XOR(final BinaryNode binaryNode)799 public boolean enterBIT_XOR(final BinaryNode binaryNode) { 800 return enterDefault(binaryNode); 801 } 802 803 /** 804 * Binary leave - callback for leaving a operator 805 * 806 * @param binaryNode the node 807 * @return processed node, which will replace the original one, or the original node 808 */ leaveBIT_XOR(final BinaryNode binaryNode)809 public Node leaveBIT_XOR(final BinaryNode binaryNode) { 810 return leaveDefault(binaryNode); 811 } 812 813 /** 814 * Binary enter - callback for entering comma right operator 815 * (a, b) where the result is b 816 * 817 * @param binaryNode the node 818 * @return true if traversal should continue and node children be traversed, false otherwise 819 */ enterCOMMARIGHT(final BinaryNode binaryNode)820 public boolean enterCOMMARIGHT(final BinaryNode binaryNode) { 821 return enterDefault(binaryNode); 822 } 823 824 /** 825 * Binary leave - callback for leaving a comma left operator 826 * (a, b) where the result is b 827 * 828 * @param binaryNode the node 829 * @return processed node, which will replace the original one, or the original node 830 */ leaveCOMMARIGHT(final BinaryNode binaryNode)831 public Node leaveCOMMARIGHT(final BinaryNode binaryNode) { 832 return leaveDefault(binaryNode); 833 } 834 835 /** 836 * Binary enter - callback for entering a division 837 * 838 * @param binaryNode the node 839 * @return true if traversal should continue and node children be traversed, false otherwise 840 */ enterDIV(final BinaryNode binaryNode)841 public boolean enterDIV(final BinaryNode binaryNode) { 842 return enterDefault(binaryNode); 843 } 844 845 /** 846 * Binary leave - callback for leaving a division 847 * 848 * @param binaryNode the node 849 * @return processed node, which will replace the original one, or the original node 850 */ leaveDIV(final BinaryNode binaryNode)851 public Node leaveDIV(final BinaryNode binaryNode) { 852 return leaveDefault(binaryNode); 853 } 854 855 /** 856 * Binary enter - callback for entering == operator 857 * 858 * @param binaryNode the node 859 * @return true if traversal should continue and node children be traversed, false otherwise 860 */ enterEQ(final BinaryNode binaryNode)861 public boolean enterEQ(final BinaryNode binaryNode) { 862 return enterDefault(binaryNode); 863 } 864 865 /** 866 * Binary leave - callback for leaving == operator 867 * 868 * @param binaryNode the node 869 * @return processed node, which will replace the original one, or the original node 870 */ leaveEQ(final BinaryNode binaryNode)871 public Node leaveEQ(final BinaryNode binaryNode) { 872 return leaveDefault(binaryNode); 873 } 874 875 /** 876 * Binary enter - callback for entering === operator 877 * 878 * @param binaryNode the node 879 * @return true if traversal should continue and node children be traversed, false otherwise 880 */ enterEQ_STRICT(final BinaryNode binaryNode)881 public boolean enterEQ_STRICT(final BinaryNode binaryNode) { 882 return enterDefault(binaryNode); 883 } 884 885 /** 886 * Binary leave - callback for leaving === operator 887 * 888 * @param binaryNode the node 889 * @return processed node, which will replace the original one, or the original node 890 */ leaveEQ_STRICT(final BinaryNode binaryNode)891 public Node leaveEQ_STRICT(final BinaryNode binaryNode) { 892 return leaveDefault(binaryNode); 893 } 894 895 /** 896 * Binary enter - callback for entering {@literal >=} operator 897 * 898 * @param binaryNode the node 899 * @return true if traversal should continue and node children be traversed, false otherwise 900 */ enterGE(final BinaryNode binaryNode)901 public boolean enterGE(final BinaryNode binaryNode) { 902 return enterDefault(binaryNode); 903 } 904 905 /** 906 * Binary leave - callback for leaving {@literal >=} operator 907 * 908 * @param binaryNode the node 909 * @return processed node, which will replace the original one, or the original node 910 */ leaveGE(final BinaryNode binaryNode)911 public Node leaveGE(final BinaryNode binaryNode) { 912 return leaveDefault(binaryNode); 913 } 914 915 /** 916 * Binary enter - callback for entering {@literal >} operator 917 * 918 * @param binaryNode the node 919 * @return true if traversal should continue and node children be traversed, false otherwise 920 */ enterGT(final BinaryNode binaryNode)921 public boolean enterGT(final BinaryNode binaryNode) { 922 return enterDefault(binaryNode); 923 } 924 925 /** 926 * Binary leave - callback for leaving {@literal >} operator 927 * 928 * @param binaryNode the node 929 * @return processed node, which will replace the original one, or the original node 930 */ leaveGT(final BinaryNode binaryNode)931 public Node leaveGT(final BinaryNode binaryNode) { 932 return leaveDefault(binaryNode); 933 } 934 935 /** 936 * Binary enter - callback for entering in operator 937 * 938 * @param binaryNode the node 939 * @return true if traversal should continue and node children be traversed, false otherwise 940 */ enterIN(final BinaryNode binaryNode)941 public boolean enterIN(final BinaryNode binaryNode) { 942 return enterDefault(binaryNode); 943 } 944 945 /** 946 * Binary leave - callback for leaving in operator 947 * 948 * @param binaryNode the node 949 * @return processed node, which will replace the original one, or the original node 950 */ leaveIN(final BinaryNode binaryNode)951 public Node leaveIN(final BinaryNode binaryNode) { 952 return leaveDefault(binaryNode); 953 } 954 955 /** 956 * Binary enter - callback for entering instanceof operator 957 * 958 * @param binaryNode the node 959 * @return true if traversal should continue and node children be traversed, false otherwise 960 */ enterINSTANCEOF(final BinaryNode binaryNode)961 public boolean enterINSTANCEOF(final BinaryNode binaryNode) { 962 return enterDefault(binaryNode); 963 } 964 965 /** 966 * Binary leave - callback for leaving instanceof operator 967 * 968 * @param binaryNode the node 969 * @return processed node, which will replace the original one, or the original node 970 */ leaveINSTANCEOF(final BinaryNode binaryNode)971 public Node leaveINSTANCEOF(final BinaryNode binaryNode) { 972 return leaveDefault(binaryNode); 973 } 974 975 /** 976 * Binary enter - callback for entering {@literal <=} operator 977 * 978 * @param binaryNode the node 979 * @return true if traversal should continue and node children be traversed, false otherwise 980 */ enterLE(final BinaryNode binaryNode)981 public boolean enterLE(final BinaryNode binaryNode) { 982 return enterDefault(binaryNode); 983 } 984 985 /** 986 * Binary leave - callback for leaving {@literal <=} operator 987 * 988 * @param binaryNode the node 989 * @return processed node, which will replace the original one, or the original node 990 */ leaveLE(final BinaryNode binaryNode)991 public Node leaveLE(final BinaryNode binaryNode) { 992 return leaveDefault(binaryNode); 993 } 994 995 /** 996 * Binary enter - callback for entering {@literal <} operator 997 * 998 * @param binaryNode the node 999 * @return true if traversal should continue and node children be traversed, false otherwise 1000 */ enterLT(final BinaryNode binaryNode)1001 public boolean enterLT(final BinaryNode binaryNode) { 1002 return enterDefault(binaryNode); 1003 } 1004 1005 /** 1006 * Binary leave - callback for leaving {@literal <} operator 1007 * 1008 * @param binaryNode the node 1009 * @return processed node, which will replace the original one, or the original node 1010 */ leaveLT(final BinaryNode binaryNode)1011 public Node leaveLT(final BinaryNode binaryNode) { 1012 return leaveDefault(binaryNode); 1013 } 1014 /** 1015 * Binary enter - callback for entering % operator 1016 * 1017 * @param binaryNode the node 1018 * @return true if traversal should continue and node children be traversed, false otherwise 1019 */ enterMOD(final BinaryNode binaryNode)1020 public boolean enterMOD(final BinaryNode binaryNode) { 1021 return enterDefault(binaryNode); 1022 } 1023 1024 /** 1025 * Binary leave - callback for leaving % operator 1026 * 1027 * @param binaryNode the node 1028 * @return processed node, which will replace the original one, or the original node 1029 */ leaveMOD(final BinaryNode binaryNode)1030 public Node leaveMOD(final BinaryNode binaryNode) { 1031 return leaveDefault(binaryNode); 1032 } 1033 1034 /** 1035 * Binary enter - callback for entering * operator 1036 * 1037 * @param binaryNode the node 1038 * @return true if traversal should continue and node children be traversed, false otherwise 1039 */ enterMUL(final BinaryNode binaryNode)1040 public boolean enterMUL(final BinaryNode binaryNode) { 1041 return enterDefault(binaryNode); 1042 } 1043 1044 /** 1045 * Binary leave - callback for leaving * operator 1046 * 1047 * @param binaryNode the node 1048 * @return processed node, which will replace the original one, or the original node 1049 */ leaveMUL(final BinaryNode binaryNode)1050 public Node leaveMUL(final BinaryNode binaryNode) { 1051 return leaveDefault(binaryNode); 1052 } 1053 1054 /** 1055 * Binary enter - callback for entering != operator 1056 * 1057 * @param binaryNode the node 1058 * @return true if traversal should continue and node children be traversed, false otherwise 1059 */ enterNE(final BinaryNode binaryNode)1060 public boolean enterNE(final BinaryNode binaryNode) { 1061 return enterDefault(binaryNode); 1062 } 1063 1064 /** 1065 * Binary leave - callback for leaving != operator 1066 * 1067 * @param binaryNode the node 1068 * @return processed node, which will replace the original one, or the original node 1069 */ leaveNE(final BinaryNode binaryNode)1070 public Node leaveNE(final BinaryNode binaryNode) { 1071 return leaveDefault(binaryNode); 1072 } 1073 1074 /** 1075 * Binary enter - callback for entering a !== operator 1076 * 1077 * @param binaryNode the node 1078 * @return true if traversal should continue and node children be traversed, false otherwise 1079 */ enterNE_STRICT(final BinaryNode binaryNode)1080 public boolean enterNE_STRICT(final BinaryNode binaryNode) { 1081 return enterDefault(binaryNode); 1082 } 1083 1084 /** 1085 * Binary leave - callback for leaving !== operator 1086 * 1087 * @param binaryNode the node 1088 * @return processed node, which will replace the original one, or the original node 1089 */ leaveNE_STRICT(final BinaryNode binaryNode)1090 public Node leaveNE_STRICT(final BinaryNode binaryNode) { 1091 return leaveDefault(binaryNode); 1092 } 1093 1094 /** 1095 * Binary enter - callback for entering || operator 1096 * 1097 * @param binaryNode the node 1098 * @return true if traversal should continue and node children be traversed, false otherwise 1099 */ enterOR(final BinaryNode binaryNode)1100 public boolean enterOR(final BinaryNode binaryNode) { 1101 return enterDefault(binaryNode); 1102 } 1103 1104 /** 1105 * Binary leave - callback for leaving || operator 1106 * 1107 * @param binaryNode the node 1108 * @return processed node, which will replace the original one, or the original node 1109 */ leaveOR(final BinaryNode binaryNode)1110 public Node leaveOR(final BinaryNode binaryNode) { 1111 return leaveDefault(binaryNode); 1112 } 1113 1114 /** 1115 * Binary enter - callback for entering {@literal >>} operator 1116 * 1117 * @param binaryNode the node 1118 * @return true if traversal should continue and node children be traversed, false otherwise 1119 */ enterSAR(final BinaryNode binaryNode)1120 public boolean enterSAR(final BinaryNode binaryNode) { 1121 return enterDefault(binaryNode); 1122 } 1123 1124 /** 1125 * Binary leave - callback for leaving {@literal >>} operator 1126 * 1127 * @param binaryNode the node 1128 * @return processed node, which will replace the original one, or the original node 1129 */ leaveSAR(final BinaryNode binaryNode)1130 public Node leaveSAR(final BinaryNode binaryNode) { 1131 return leaveDefault(binaryNode); 1132 } 1133 1134 /** 1135 * Binary enter - callback for entering {@literal <<} operator 1136 * 1137 * @param binaryNode the node 1138 * @return true if traversal should continue and node children be traversed, false otherwise 1139 */ enterSHL(final BinaryNode binaryNode)1140 public boolean enterSHL(final BinaryNode binaryNode) { 1141 return enterDefault(binaryNode); 1142 } 1143 1144 /** 1145 * Binary leave - callback for leaving {@literal <<} operator 1146 * 1147 * @param binaryNode the node 1148 * @return processed node, which will replace the original one, or the original node 1149 */ leaveSHL(final BinaryNode binaryNode)1150 public Node leaveSHL(final BinaryNode binaryNode) { 1151 return leaveDefault(binaryNode); 1152 } 1153 /** 1154 * Binary enter - callback for entering {@literal >>>} operator 1155 * 1156 * @param binaryNode the node 1157 * @return true if traversal should continue and node children be traversed, false otherwise 1158 */ enterSHR(final BinaryNode binaryNode)1159 public boolean enterSHR(final BinaryNode binaryNode) { 1160 return enterDefault(binaryNode); 1161 } 1162 1163 /** 1164 * Binary leave - callback for leaving {@literal >>>} operator 1165 * 1166 * @param binaryNode the node 1167 * @return processed node, which will replace the original one, or the original node 1168 */ leaveSHR(final BinaryNode binaryNode)1169 public Node leaveSHR(final BinaryNode binaryNode) { 1170 return leaveDefault(binaryNode); 1171 } 1172 1173 /** 1174 * Binary enter - callback for entering - operator 1175 * 1176 * @param binaryNode the node 1177 * @return true if traversal should continue and node children be traversed, false otherwise 1178 */ enterSUB(final BinaryNode binaryNode)1179 public boolean enterSUB(final BinaryNode binaryNode) { 1180 return enterDefault(binaryNode); 1181 } 1182 1183 /** 1184 * Binary leave - callback for leaving - operator 1185 * 1186 * @param binaryNode the node 1187 * @return processed node, which will replace the original one, or the original node 1188 */ leaveSUB(final BinaryNode binaryNode)1189 public Node leaveSUB(final BinaryNode binaryNode) { 1190 return leaveDefault(binaryNode); 1191 } 1192 } 1193