JDK 11 jdk.scripting.nashorn.jmod - Scripting Nashorn Module
JDK 11 jdk.scripting.nashorn.jmod is the JMOD file for JDK 11 Scripting Nashorn module.
JDK 11 Scripting Nashorn module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.scripting.nashorn.jmod.
JDK 11 Scripting Nashorn module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Scripting Nashorn module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.scripting.nashorn.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/nashorn/internal/ir/visitor/NodeOperatorVisitor.java
/*
* Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package jdk.nashorn.internal.ir.visitor;
import jdk.nashorn.internal.ir.BinaryNode;
import jdk.nashorn.internal.ir.LexicalContext;
import jdk.nashorn.internal.ir.Node;
import jdk.nashorn.internal.ir.UnaryNode;
/**
* Like NodeVisitor but navigating further into operators.
* @param <T> Lexical context class for this NodeOperatorVisitor
*/
public abstract class NodeOperatorVisitor<T extends LexicalContext> extends NodeVisitor<T> {
/**
* Constructor
*
* @param lc a custom lexical context
*/
public NodeOperatorVisitor(final T lc) {
super(lc);
}
@Override
public boolean enterUnaryNode(final UnaryNode unaryNode) {
switch (unaryNode.tokenType()) {
case POS:
return enterPOS(unaryNode);
case BIT_NOT:
return enterBIT_NOT(unaryNode);
case DELETE:
return enterDELETE(unaryNode);
case NEW:
return enterNEW(unaryNode);
case NOT:
return enterNOT(unaryNode);
case NEG:
return enterNEG(unaryNode);
case TYPEOF:
return enterTYPEOF(unaryNode);
case VOID:
return enterVOID(unaryNode);
case DECPREFIX:
case DECPOSTFIX:
case INCPREFIX:
case INCPOSTFIX:
return enterDECINC(unaryNode);
default:
return super.enterUnaryNode(unaryNode);
}
}
@Override
public final Node leaveUnaryNode(final UnaryNode unaryNode) {
switch (unaryNode.tokenType()) {
case POS:
return leavePOS(unaryNode);
case BIT_NOT:
return leaveBIT_NOT(unaryNode);
case DELETE:
return leaveDELETE(unaryNode);
case NEW:
return leaveNEW(unaryNode);
case NOT:
return leaveNOT(unaryNode);
case NEG:
return leaveNEG(unaryNode);
case TYPEOF:
return leaveTYPEOF(unaryNode);
case VOID:
return leaveVOID(unaryNode);
case DECPREFIX:
case DECPOSTFIX:
case INCPREFIX:
case INCPOSTFIX:
return leaveDECINC(unaryNode);
default:
return super.leaveUnaryNode(unaryNode);
}
}
@Override
public final boolean enterBinaryNode(final BinaryNode binaryNode) {
switch (binaryNode.tokenType()) {
case ADD:
return enterADD(binaryNode);
case AND:
return enterAND(binaryNode);
case ASSIGN:
return enterASSIGN(binaryNode);
case ASSIGN_ADD:
return enterASSIGN_ADD(binaryNode);
case ASSIGN_BIT_AND:
return enterASSIGN_BIT_AND(binaryNode);
case ASSIGN_BIT_OR:
return enterASSIGN_BIT_OR(binaryNode);
case ASSIGN_BIT_XOR:
return enterASSIGN_BIT_XOR(binaryNode);
case ASSIGN_DIV:
return enterASSIGN_DIV(binaryNode);
case ASSIGN_MOD:
return enterASSIGN_MOD(binaryNode);
case ASSIGN_MUL:
return enterASSIGN_MUL(binaryNode);
case ASSIGN_SAR:
return enterASSIGN_SAR(binaryNode);
case ASSIGN_SHL:
return enterASSIGN_SHL(binaryNode);
case ASSIGN_SHR:
return enterASSIGN_SHR(binaryNode);
case ASSIGN_SUB:
return enterASSIGN_SUB(binaryNode);
case ARROW:
return enterARROW(binaryNode);
case BIT_AND:
return enterBIT_AND(binaryNode);
case BIT_OR:
return enterBIT_OR(binaryNode);
case BIT_XOR:
return enterBIT_XOR(binaryNode);
case COMMARIGHT:
return enterCOMMARIGHT(binaryNode);
case DIV:
return enterDIV(binaryNode);
case EQ:
return enterEQ(binaryNode);
case EQ_STRICT:
return enterEQ_STRICT(binaryNode);
case GE:
return enterGE(binaryNode);
case GT:
return enterGT(binaryNode);
case IN:
return enterIN(binaryNode);
case INSTANCEOF:
return enterINSTANCEOF(binaryNode);
case LE:
return enterLE(binaryNode);
case LT:
return enterLT(binaryNode);
case MOD:
return enterMOD(binaryNode);
case MUL:
return enterMUL(binaryNode);
case NE:
return enterNE(binaryNode);
case NE_STRICT:
return enterNE_STRICT(binaryNode);
case OR:
return enterOR(binaryNode);
case SAR:
return enterSAR(binaryNode);
case SHL:
return enterSHL(binaryNode);
case SHR:
return enterSHR(binaryNode);
case SUB:
return enterSUB(binaryNode);
default:
return super.enterBinaryNode(binaryNode);
}
}
@Override
public final Node leaveBinaryNode(final BinaryNode binaryNode) {
switch (binaryNode.tokenType()) {
case ADD:
return leaveADD(binaryNode);
case AND:
return leaveAND(binaryNode);
case ASSIGN:
return leaveASSIGN(binaryNode);
case ASSIGN_ADD:
return leaveASSIGN_ADD(binaryNode);
case ASSIGN_BIT_AND:
return leaveASSIGN_BIT_AND(binaryNode);
case ASSIGN_BIT_OR:
return leaveASSIGN_BIT_OR(binaryNode);
case ASSIGN_BIT_XOR:
return leaveASSIGN_BIT_XOR(binaryNode);
case ASSIGN_DIV:
return leaveASSIGN_DIV(binaryNode);
case ASSIGN_MOD:
return leaveASSIGN_MOD(binaryNode);
case ASSIGN_MUL:
return leaveASSIGN_MUL(binaryNode);
case ASSIGN_SAR:
return leaveASSIGN_SAR(binaryNode);
case ASSIGN_SHL:
return leaveASSIGN_SHL(binaryNode);
case ASSIGN_SHR:
return leaveASSIGN_SHR(binaryNode);
case ASSIGN_SUB:
return leaveASSIGN_SUB(binaryNode);
case ARROW:
return leaveARROW(binaryNode);
case BIT_AND:
return leaveBIT_AND(binaryNode);
case BIT_OR:
return leaveBIT_OR(binaryNode);
case BIT_XOR:
return leaveBIT_XOR(binaryNode);
case COMMARIGHT:
return leaveCOMMARIGHT(binaryNode);
case DIV:
return leaveDIV(binaryNode);
case EQ:
return leaveEQ(binaryNode);
case EQ_STRICT:
return leaveEQ_STRICT(binaryNode);
case GE:
return leaveGE(binaryNode);
case GT:
return leaveGT(binaryNode);
case IN:
return leaveIN(binaryNode);
case INSTANCEOF:
return leaveINSTANCEOF(binaryNode);
case LE:
return leaveLE(binaryNode);
case LT:
return leaveLT(binaryNode);
case MOD:
return leaveMOD(binaryNode);
case MUL:
return leaveMUL(binaryNode);
case NE:
return leaveNE(binaryNode);
case NE_STRICT:
return leaveNE_STRICT(binaryNode);
case OR:
return leaveOR(binaryNode);
case SAR:
return leaveSAR(binaryNode);
case SHL:
return leaveSHL(binaryNode);
case SHR:
return leaveSHR(binaryNode);
case SUB:
return leaveSUB(binaryNode);
default:
return super.leaveBinaryNode(binaryNode);
}
}
/*
* Unary entries and exists.
*/
/**
* Unary enter - callback for entering a unary +
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterPOS(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a unary +
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leavePOS(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a ~ operator
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterBIT_NOT(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a unary ~
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveBIT_NOT(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a ++ or -- operator
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterDECINC(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a ++ or -- operator
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveDECINC(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a delete operator
*
* @param unaryNode the node
* @return processed node
*/
public boolean enterDELETE(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a delete operator
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveDELETE(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a new operator
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterNEW(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a new operator
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveNEW(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a ! operator
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterNOT(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a ! operator
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveNOT(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a unary -
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterNEG(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a unary -
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveNEG(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a typeof
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterTYPEOF(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a typeof operator
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveTYPEOF(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Unary enter - callback for entering a void
*
* @param unaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterVOID(final UnaryNode unaryNode) {
return enterDefault(unaryNode);
}
/**
* Unary leave - callback for leaving a void
*
* @param unaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveVOID(final UnaryNode unaryNode) {
return leaveDefault(unaryNode);
}
/**
* Binary enter - callback for entering + operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterADD(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a + operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveADD(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal &&} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterAND(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal &&} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveAND(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering an assignment
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving an assignment
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering += operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_ADD(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a += operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_ADD(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal &=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_BIT_AND(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal &=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_BIT_AND(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering |= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_BIT_OR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a |= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_BIT_OR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering ^= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_BIT_XOR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a ^= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_BIT_XOR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering /= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_DIV(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a /= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_DIV(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering %= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_MOD(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a %= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_MOD(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering *= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_MUL(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a *= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_MUL(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >>=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_SAR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal >>=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_SAR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering a {@literal <<=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_SHL(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal <<=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_SHL(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >>>=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_SHR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal >>>=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_SHR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering -= operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterASSIGN_SUB(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a -= operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveASSIGN_SUB(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering a arrow operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterARROW(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a arrow operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveARROW(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal &} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterBIT_AND(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a {@literal &} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveBIT_AND(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering | operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterBIT_OR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a | operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveBIT_OR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering ^ operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterBIT_XOR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveBIT_XOR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering comma right operator
* (a, b) where the result is b
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterCOMMARIGHT(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a comma left operator
* (a, b) where the result is b
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveCOMMARIGHT(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering a division
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterDIV(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving a division
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveDIV(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering == operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterEQ(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving == operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveEQ(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering === operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterEQ_STRICT(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving === operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveEQ_STRICT(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterGE(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal >=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveGE(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterGT(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal >} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveGT(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering in operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterIN(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving in operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveIN(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering instanceof operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterINSTANCEOF(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving instanceof operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveINSTANCEOF(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal <=} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterLE(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal <=} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveLE(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal <} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterLT(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal <} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveLT(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering % operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterMOD(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving % operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveMOD(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering * operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterMUL(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving * operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveMUL(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering != operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterNE(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving != operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveNE(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering a !== operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterNE_STRICT(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving !== operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveNE_STRICT(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering || operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterOR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving || operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveOR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >>} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterSAR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal >>} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveSAR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal <<} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterSHL(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal <<} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveSHL(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering {@literal >>>} operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterSHR(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving {@literal >>>} operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveSHR(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
/**
* Binary enter - callback for entering - operator
*
* @param binaryNode the node
* @return true if traversal should continue and node children be traversed, false otherwise
*/
public boolean enterSUB(final BinaryNode binaryNode) {
return enterDefault(binaryNode);
}
/**
* Binary leave - callback for leaving - operator
*
* @param binaryNode the node
* @return processed node, which will replace the original one, or the original node
*/
public Node leaveSUB(final BinaryNode binaryNode) {
return leaveDefault(binaryNode);
}
}
⏎ jdk/nashorn/internal/ir/visitor/NodeOperatorVisitor.java
Or download all of them as a single archive file:
File name: jdk.scripting.nashorn-11.0.1-src.zip File size: 1390965 bytes Release date: 2018-11-04 Download
⇒ JDK 11 jdk.scripting.nashorn.shell.jmod - Scripting Nashorn Shell Module
2020-04-25, 108191👍, 0💬
Related Topics: