Java Code Examples for jdk.nashorn.internal.ir.FunctionNode#getRootClass()
The following examples show how to use
jdk.nashorn.internal.ir.FunctionNode#getRootClass() .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: Context.java From TencentKona-8 with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 2
| Source File: Context.java From jdk8u60 with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller<ScriptEnvironment> installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = new Compiler(
this,
env,
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 3
| Source File: Context.java From openjdk-jdk8u with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 4
| Source File: Context.java From openjdk-jdk8u-backup with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 5
| Source File: Context.java From openjdk-jdk9 with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict, final boolean isEval) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getDebugFlag(FunctionNode.DEBUG_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getDebugFlag(FunctionNode.DEBUG_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer;
if (!env.useAnonymousClasses(source.getLength()) || env._persistent_cache || !env._lazy_compilation) {
// Persistent code cache and eager compilation preclude use of VM anonymous classes
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
installer = new NamedContextCodeInstaller(this, cs, loader);
} else {
installer = new AnonymousContextCodeInstaller(this, cs,
anonymousHostClasses.getOrCreate(cs, (key) ->
createNewLoader().installClass(
// NOTE: we're defining these constants in AnonymousContextCodeInstaller so they are not
// initialized if we don't use AnonymousContextCodeInstaller. As this method is only ever
// invoked from AnonymousContextCodeInstaller, this is okay.
AnonymousContextCodeInstaller.ANONYMOUS_HOST_CLASS_NAME,
AnonymousContextCodeInstaller.ANONYMOUS_HOST_CLASS_BYTES, cs)));
}
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 6
| Source File: Context.java From hottub with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
Example 7
| Source File: Context.java From jdk8u_nashorn with GNU General Public License v2.0 | 4 votes |
|
private synchronized Class<?> compile(final Source source, final ErrorManager errMan, final boolean strict) {
// start with no errors, no warnings.
errMan.reset();
Class<?> script = findCachedClass(source);
if (script != null) {
final DebugLogger log = getLogger(Compiler.class);
if (log.isEnabled()) {
log.fine(new RuntimeEvent<>(Level.INFO, source), "Code cache hit for ", source, " avoiding recompile.");
}
return script;
}
StoredScript storedScript = null;
FunctionNode functionNode = null;
// Don't use code store if optimistic types is enabled but lazy compilation is not.
// This would store a full script compilation with many wrong optimistic assumptions that would
// do more harm than good on later runs with both optimistic types and lazy compilation enabled.
final boolean useCodeStore = codeStore != null && !env._parse_only && (!env._optimistic_types || env._lazy_compilation);
final String cacheKey = useCodeStore ? CodeStore.getCacheKey("script", null) : null;
if (useCodeStore) {
storedScript = codeStore.load(source, cacheKey);
}
if (storedScript == null) {
if (env._dest_dir != null) {
source.dump(env._dest_dir);
}
functionNode = new Parser(env, source, errMan, strict, getLogger(Parser.class)).parse();
if (errMan.hasErrors()) {
return null;
}
if (env._print_ast || functionNode.getFlag(FunctionNode.IS_PRINT_AST)) {
getErr().println(new ASTWriter(functionNode));
}
if (env._print_parse || functionNode.getFlag(FunctionNode.IS_PRINT_PARSE)) {
getErr().println(new PrintVisitor(functionNode, true, false));
}
}
if (env._parse_only) {
return null;
}
final URL url = source.getURL();
final ScriptLoader loader = env._loader_per_compile ? createNewLoader() : scriptLoader;
final CodeSource cs = new CodeSource(url, (CodeSigner[])null);
final CodeInstaller installer = new ContextCodeInstaller(this, loader, cs);
if (storedScript == null) {
final CompilationPhases phases = Compiler.CompilationPhases.COMPILE_ALL;
final Compiler compiler = Compiler.forInitialCompilation(
installer,
source,
errMan,
strict | functionNode.isStrict());
final FunctionNode compiledFunction = compiler.compile(functionNode, phases);
if (errMan.hasErrors()) {
return null;
}
script = compiledFunction.getRootClass();
compiler.persistClassInfo(cacheKey, compiledFunction);
} else {
Compiler.updateCompilationId(storedScript.getCompilationId());
script = storedScript.installScript(source, installer);
}
cacheClass(source, script);
return script;
}
