Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
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/Symbol.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; import java.io.IOException; import java.io.ObjectInputStream; import java.io.PrintWriter; import java.io.Serializable; import java.util.HashSet; import java.util.Set; import java.util.StringTokenizer; import jdk.nashorn.internal.codegen.types.Type; import jdk.nashorn.internal.runtime.Context; import jdk.nashorn.internal.runtime.Debug; import jdk.nashorn.internal.runtime.options.Options; /** * Symbol is a symbolic address for a value ("variable" if you wish). Identifiers in JavaScript source, as well as * certain synthetic variables created by the compiler are represented by Symbol objects. Symbols can address either * local variable slots in bytecode ("slotted symbol"), or properties in scope objects ("scoped symbol"). A symbol can * also end up being defined but then not used during symbol assignment calculations; such symbol will be neither * scoped, nor slotted; it represents a dead variable (it might be written to, but is never read). Finally, a symbol can * be both slotted and in scope. This special case can only occur with bytecode method parameters. They all come in as * slotted, but if they are used by a nested function (or eval) then they will be copied into the scope object, and used * from there onwards. Two further special cases are parameters stored in {@code NativeArguments} objects and parameters * stored in {@code Object[]} parameter to variable-arity functions. Those use the {@code #getFieldIndex()} property to * refer to their location. */ public final class Symbol implements Comparable<Symbol>, Cloneable, Serializable { private static final long serialVersionUID = 1L; /** Is this Global */ public static final int IS_GLOBAL = 1; /** Is this a variable */ public static final int IS_VAR = 2; /** Is this a parameter */ public static final int IS_PARAM = 3; /** Mask for kind flags */ public static final int KINDMASK = (1 << 2) - 1; // Kinds are represented by lower two bits /** Is this symbol in scope */ public static final int IS_SCOPE = 1 << 2; /** Is this a this symbol */ public static final int IS_THIS = 1 << 3; /** Is this a let */ public static final int IS_LET = 1 << 4; /** Is this a const */ public static final int IS_CONST = 1 << 5; /** Is this an internal symbol, never represented explicitly in source code */ public static final int IS_INTERNAL = 1 << 6; /** Is this a function self-reference symbol */ public static final int IS_FUNCTION_SELF = 1 << 7; /** Is this a function declaration? */ public static final int IS_FUNCTION_DECLARATION = 1 << 8; /** Is this a program level symbol? */ public static final int IS_PROGRAM_LEVEL = 1 << 9; /** Are this symbols' values stored in local variable slots? */ public static final int HAS_SLOT = 1 << 10; /** Is this symbol known to store an int value ? */ public static final int HAS_INT_VALUE = 1 << 11; /** Is this symbol known to store a double value ? */ public static final int HAS_DOUBLE_VALUE = 1 << 12; /** Is this symbol known to store an object value ? */ public static final int HAS_OBJECT_VALUE = 1 << 13; /** Is this symbol seen a declaration? Used for block scoped LET and CONST symbols only. */ public static final int HAS_BEEN_DECLARED = 1 << 14; /** Null or name identifying symbol. */ private final String name; /** Symbol flags. */ private int flags; /** First bytecode method local variable slot for storing the value(s) of this variable. -1 indicates the variable * is not stored in local variable slots or it is not yet known. */ private transient int firstSlot = -1; /** Field number in scope or property; array index in varargs when not using arguments object. */ private transient int fieldIndex = -1; /** Number of times this symbol is used in code */ private int useCount; /** Debugging option - dump info and stack trace when symbols with given names are manipulated */ private static final Set<String> TRACE_SYMBOLS; private static final Set<String> TRACE_SYMBOLS_STACKTRACE; static { final String stacktrace = Options.getStringProperty("nashorn.compiler.symbol.stacktrace", null); final String trace; if (stacktrace != null) { trace = stacktrace; //stacktrace always implies trace as well TRACE_SYMBOLS_STACKTRACE = new HashSet<>(); for (final StringTokenizer st = new StringTokenizer(stacktrace, ","); st.hasMoreTokens(); ) { TRACE_SYMBOLS_STACKTRACE.add(st.nextToken()); } } else { trace = Options.getStringProperty("nashorn.compiler.symbol.trace", null); TRACE_SYMBOLS_STACKTRACE = null; } if (trace != null) { TRACE_SYMBOLS = new HashSet<>(); for (final StringTokenizer st = new StringTokenizer(trace, ","); st.hasMoreTokens(); ) { TRACE_SYMBOLS.add(st.nextToken()); } } else { TRACE_SYMBOLS = null; } } /** * Constructor * * @param name name of symbol * @param flags symbol flags */ public Symbol(final String name, final int flags) { this.name = name; this.flags = flags; if(shouldTrace()) { trace("CREATE SYMBOL " + name); } } @Override public Symbol clone() { try { return (Symbol)super.clone(); } catch (final CloneNotSupportedException e) { throw new AssertionError(e); } } private static String align(final String string, final int max) { final StringBuilder sb = new StringBuilder(); sb.append(string.substring(0, Math.min(string.length(), max))); while (sb.length() < max) { sb.append(' '); } return sb.toString(); } /** * Debugging . * * @param stream Stream to print to. */ void print(final PrintWriter stream) { final StringBuilder sb = new StringBuilder(); sb.append(align(name, 20)). append(": "). append(", "). append(align(firstSlot == -1 ? "none" : "" + firstSlot, 10)); switch (flags & KINDMASK) { case IS_GLOBAL: sb.append(" global"); break; case IS_VAR: if (isConst()) { sb.append(" const"); } else if (isLet()) { sb.append(" let"); } else { sb.append(" var"); } break; case IS_PARAM: sb.append(" param"); break; default: break; } if (isScope()) { sb.append(" scope"); } if (isInternal()) { sb.append(" internal"); } if (isThis()) { sb.append(" this"); } if (isProgramLevel()) { sb.append(" program"); } sb.append('\n'); stream.print(sb.toString()); } /** * Compare the the symbol kind with another. * * @param other Other symbol's flags. * @return True if symbol has less kind. */ public boolean less(final int other) { return (flags & KINDMASK) < (other & KINDMASK); } /** * Allocate a slot for this symbol. * * @param needsSlot True if symbol needs a slot. * @return the symbol */ public Symbol setNeedsSlot(final boolean needsSlot) { if(needsSlot) { assert !isScope(); flags |= HAS_SLOT; } else { flags &= ~HAS_SLOT; } return this; } /** * Return the number of slots required for the symbol. * * @return Number of slots. */ public int slotCount() { return ((flags & HAS_INT_VALUE) == 0 ? 0 : 1) + ((flags & HAS_DOUBLE_VALUE) == 0 ? 0 : 2) + ((flags & HAS_OBJECT_VALUE) == 0 ? 0 : 1); } private boolean isSlotted() { return firstSlot != -1 && ((flags & HAS_SLOT) != 0); } @Override public String toString() { final StringBuilder sb = new StringBuilder(); sb.append(name). append(' '); if (hasSlot()) { sb.append(' '). append('('). append("slot="). append(firstSlot).append(' '); if((flags & HAS_INT_VALUE) != 0) { sb.append('I'); } if((flags & HAS_DOUBLE_VALUE) != 0) { sb.append('D'); } if((flags & HAS_OBJECT_VALUE) != 0) { sb.append('O'); } sb.append(')'); } if (isScope()) { if(isGlobal()) { sb.append(" G"); } else { sb.append(" S"); } } return sb.toString(); } @Override public int compareTo(final Symbol other) { return name.compareTo(other.name); } /** * Does this symbol have an allocated bytecode slot? Note that having an allocated bytecode slot doesn't necessarily * mean the symbol's value will be stored in it. Namely, a function parameter can have a bytecode slot, but if it is * in scope, then the bytecode slot will not be used. See {@link #isBytecodeLocal()}. * * @return true if this symbol has a local bytecode slot */ public boolean hasSlot() { return (flags & HAS_SLOT) != 0; } /** * Is this symbol a local variable stored in bytecode local variable slots? This is true for a slotted variable that * is not in scope. (E.g. a parameter that is in scope is slotted, but it will not be a local variable). * @return true if this symbol is using bytecode local slots for its storage. */ public boolean isBytecodeLocal() { return hasSlot() && !isScope(); } /** * Returns true if this symbol is dead (it is a local variable that is statically proven to never be read in any type). * @return true if this symbol is dead */ public boolean isDead() { return (flags & (HAS_SLOT | IS_SCOPE)) == 0; } /** * Check if this is a symbol in scope. Scope symbols cannot, for obvious reasons * be stored in byte code slots on the local frame * * @return true if this is scoped */ public boolean isScope() { assert (flags & KINDMASK) != IS_GLOBAL || (flags & IS_SCOPE) == IS_SCOPE : "global without scope flag"; return (flags & IS_SCOPE) != 0; } /** * Check if this symbol is a function declaration * @return true if a function declaration */ public boolean isFunctionDeclaration() { return (flags & IS_FUNCTION_DECLARATION) != 0; } /** * Flag this symbol as scope as described in {@link Symbol#isScope()} * @return the symbol */ public Symbol setIsScope() { if (!isScope()) { if(shouldTrace()) { trace("SET IS SCOPE"); } flags |= IS_SCOPE; if(!isParam()) { flags &= ~HAS_SLOT; } } return this; } /** * Mark this symbol as a function declaration. */ public void setIsFunctionDeclaration() { if (!isFunctionDeclaration()) { if(shouldTrace()) { trace("SET IS FUNCTION DECLARATION"); } flags |= IS_FUNCTION_DECLARATION; } } /** * Check if this symbol is a variable * @return true if variable */ public boolean isVar() { return (flags & KINDMASK) == IS_VAR; } /** * Check if this symbol is a global (undeclared) variable * @return true if global */ public boolean isGlobal() { return (flags & KINDMASK) == IS_GLOBAL; } /** * Check if this symbol is a function parameter * @return true if parameter */ public boolean isParam() { return (flags & KINDMASK) == IS_PARAM; } /** * Check if this is a program (script) level definition * @return true if program level */ public boolean isProgramLevel() { return (flags & IS_PROGRAM_LEVEL) != 0; } /** * Check if this symbol is a constant * @return true if a constant */ public boolean isConst() { return (flags & IS_CONST) != 0; } /** * Check if this is an internal symbol, without an explicit JavaScript source * code equivalent * @return true if internal */ public boolean isInternal() { return (flags & IS_INTERNAL) != 0; } /** * Check if this symbol represents {@code this} * @return true if this */ public boolean isThis() { return (flags & IS_THIS) != 0; } /** * Check if this symbol is a let * @return true if let */ public boolean isLet() { return (flags & IS_LET) != 0; } /** * Flag this symbol as a function's self-referencing symbol. * @return true if this symbol as a function's self-referencing symbol. */ public boolean isFunctionSelf() { return (flags & IS_FUNCTION_SELF) != 0; } /** * Is this a block scoped symbol * @return true if block scoped */ public boolean isBlockScoped() { return isLet() || isConst(); } /** * Has this symbol been declared * @return true if declared */ public boolean hasBeenDeclared() { return (flags & HAS_BEEN_DECLARED) != 0; } /** * Mark this symbol as declared */ public void setHasBeenDeclared() { if (!hasBeenDeclared()) { flags |= HAS_BEEN_DECLARED; } } /** * Get the index of the field used to store this symbol, should it be an AccessorProperty * and get allocated in a JO-prefixed ScriptObject subclass. * * @return field index */ public int getFieldIndex() { assert fieldIndex != -1 : "fieldIndex must be initialized " + fieldIndex; return fieldIndex; } /** * Set the index of the field used to store this symbol, should it be an AccessorProperty * and get allocated in a JO-prefixed ScriptObject subclass. * * @param fieldIndex field index - a positive integer * @return the symbol */ public Symbol setFieldIndex(final int fieldIndex) { if (this.fieldIndex != fieldIndex) { this.fieldIndex = fieldIndex; } return this; } /** * Get the symbol flags * @return flags */ public int getFlags() { return flags; } /** * Set the symbol flags * @param flags flags * @return the symbol */ public Symbol setFlags(final int flags) { if (this.flags != flags) { this.flags = flags; } return this; } /** * Set a single symbol flag * @param flag flag to set * @return the symbol */ public Symbol setFlag(final int flag) { if ((this.flags & flag) == 0) { this.flags |= flag; } return this; } /** * Clears a single symbol flag * @param flag flag to set * @return the symbol */ public Symbol clearFlag(final int flag) { if ((this.flags & flag) != 0) { this.flags &= ~flag; } return this; } /** * Get the name of this symbol * @return symbol name */ public String getName() { return name; } /** * Get the index of the first bytecode slot for this symbol * @return byte code slot */ public int getFirstSlot() { assert isSlotted(); return firstSlot; } /** * Get the index of the bytecode slot for this symbol for storing a value of the specified type. * @param type the requested type * @return byte code slot */ public int getSlot(final Type type) { assert isSlotted(); int typeSlot = firstSlot; if(type.isBoolean() || type.isInteger()) { assert (flags & HAS_INT_VALUE) != 0; return typeSlot; } typeSlot += ((flags & HAS_INT_VALUE) == 0 ? 0 : 1); if(type.isNumber()) { assert (flags & HAS_DOUBLE_VALUE) != 0; return typeSlot; } assert type.isObject(); assert (flags & HAS_OBJECT_VALUE) != 0 : name; return typeSlot + ((flags & HAS_DOUBLE_VALUE) == 0 ? 0 : 2); } /** * Returns true if this symbol has a local variable slot for storing a value of specific type. * @param type the type * @return true if this symbol has a local variable slot for storing a value of specific type. */ public boolean hasSlotFor(final Type type) { if(type.isBoolean() || type.isInteger()) { return (flags & HAS_INT_VALUE) != 0; } else if(type.isNumber()) { return (flags & HAS_DOUBLE_VALUE) != 0; } assert type.isObject(); return (flags & HAS_OBJECT_VALUE) != 0; } /** * Marks this symbol as having a local variable slot for storing a value of specific type. * @param type the type */ public void setHasSlotFor(final Type type) { if(type.isBoolean() || type.isInteger()) { setFlag(HAS_INT_VALUE); } else if(type.isNumber()) { setFlag(HAS_DOUBLE_VALUE); } else { assert type.isObject(); setFlag(HAS_OBJECT_VALUE); } } /** * Increase the symbol's use count by one. */ public void increaseUseCount() { if (isScope()) { // Avoid dirtying a cache line; we only need the use count for scoped symbols useCount++; } } /** * Get the symbol's use count * @return the number of times the symbol is used in code. */ public int getUseCount() { return useCount; } /** * Set the bytecode slot for this symbol * @param firstSlot valid bytecode slot * @return the symbol */ public Symbol setFirstSlot(final int firstSlot) { assert firstSlot >= 0 && firstSlot <= 65535; if (firstSlot != this.firstSlot) { if(shouldTrace()) { trace("SET SLOT " + firstSlot); } this.firstSlot = firstSlot; } return this; } /** * From a lexical context, set this symbol as needing scope, which * will set flags for the defining block that will be written when * block is popped from the lexical context stack, used by codegen * when flags need to be tagged, but block is in the * middle of evaluation and cannot be modified. * * @param lc lexical context * @param symbol symbol * @return the symbol */ public static Symbol setSymbolIsScope(final LexicalContext lc, final Symbol symbol) { symbol.setIsScope(); if (!symbol.isGlobal()) { lc.setBlockNeedsScope(lc.getDefiningBlock(symbol)); } return symbol; } private boolean shouldTrace() { return TRACE_SYMBOLS != null && (TRACE_SYMBOLS.isEmpty() || TRACE_SYMBOLS.contains(name)); } private void trace(final String desc) { Context.err(Debug.id(this) + " SYMBOL: '" + name + "' " + desc); if (TRACE_SYMBOLS_STACKTRACE != null && (TRACE_SYMBOLS_STACKTRACE.isEmpty() || TRACE_SYMBOLS_STACKTRACE.contains(name))) { new Throwable().printStackTrace(Context.getCurrentErr()); } } private void readObject(final ObjectInputStream in) throws ClassNotFoundException, IOException { in.defaultReadObject(); firstSlot = -1; fieldIndex = -1; } }
⏎ jdk/nashorn/internal/ir/Symbol.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, 83691👍, 0💬
Popular Posts:
How to merge two JAR files with "jar" commands? I am tired of specifying multiple JAR files in the c...
JDK 11 jdk.javadoc.jmod is the JMOD file for JDK 11 Java Document tool, which can be invoked by the ...
itextpdf.jar is a component in iText 5 Java library to provide core functionalities. iText Java libr...
Jaxen, Release 1.1.1, is an open source XPath library written in Java. It is adaptable to many diffe...
How to perform XML Schema validation with sax\Writer.java provided in the Apache Xerces package? You...