Java Options类代码示例

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@Test
public void evalTest() {
    final Options options = new Options("");
    final ErrorManager errors = new ErrorManager();
    final Context cx = new Context(options, errors, Thread.currentThread().getContextClassLoader());
    final Global oldGlobal = Context.getGlobal();
    Context.setGlobal(cx.createGlobal());
    try {
        String code = "22 + 10";
        assertTrue(32.0 == ((Number)(eval(cx, "<evalTest>", code))).doubleValue());

        code = "obj = { js: 'nashorn' }; obj.js";
        assertEquals(eval(cx, "<evalTest2>", code), "nashorn");
    } finally {
        Context.setGlobal(oldGlobal);
    }
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@Test
public void compileErrorTest() {
    final Options options = new Options("");
    final ErrorManager errors = new ErrorManager();
    final Context cx = new Context(options, errors, Thread.currentThread().getContextClassLoader());
    final Global oldGlobal = Context.getGlobal();
    Context.setGlobal(cx.createGlobal());
    try {
        final ScriptFunction script = cx.compileScript(sourceFor("<evalCompileErrorTest>", "*/"), Context.getGlobal());
        if (script != null) {
            fail("Invalid script compiled without errors");
        }
        if (errors.getNumberOfErrors() != 1) {
            fail("Wrong number of errors: " + errors.getNumberOfErrors());
        }
    } finally {
        Context.setGlobal(oldGlobal);
    }
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@BeforeClass
public void setupTest() {
    final Options options = new Options("nashorn");
    options.set("compile.only", true);
    options.set("print.ast", true);
    options.set("print.parse", true);
    options.set("scripting", true);
    options.set("const.as.var", true);
    options.set("verify.code", true);

    final ErrorManager errors = new ErrorManager() {
        @Override
        public void error(final String msg) {
            log(msg);
        }
    };

    final StringWriter sw = new StringWriter();
    final PrintWriter pw = new PrintWriter(sw);
    this.context = new Context(options, errors, pw, pw, Thread.currentThread().getContextClassLoader());
    this.global = context.createGlobal();
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
private static Context makeContext(InputStream in, OutputStream out, OutputStream err, String[] args) {

        PrintStream pout = out instanceof PrintStream?(PrintStream)out:new PrintStream(out);
        PrintStream perr = err instanceof PrintStream?(PrintStream)err:new PrintStream(err);
        PrintWriter wout = new PrintWriter(pout, true);
        PrintWriter werr = new PrintWriter(perr, true);
        ErrorManager errors = new ErrorManager(werr);
        Options options = new Options("nashorn", werr);
        if(args != null) {
            try {
                options.process(args);
            } catch (IllegalArgumentException var27) {
                werr.println(bundle.getString("shell.usage"));
                options.displayHelp(var27);
                return null;
            }
        }
        return new Context(options, errors, wout, werr, Thread.currentThread().getContextClassLoader());
    }
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@BeforeClass
public void setupTest() {
    final Options options = new Options("nashorn");
    options.set("anon.functions", true);
    options.set("compile.only", true);
    options.set("print.ast", true);
    options.set("print.parse", true);
    options.set("scripting", true);
    options.set("const.as.var", true);
    options.set("verify.code", true);

    final ErrorManager errors = new ErrorManager() {
        @Override
        public void error(final String msg) {
            log(msg);
        }
    };

    final StringWriter sw = new StringWriter();
    final PrintWriter pw = new PrintWriter(sw);
    this.context = new Context(options, errors, pw, pw, Thread.currentThread().getContextClassLoader());
    this.global = context.createGlobal();
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
/**
 * Creates the AST serializer executor service used for in-memory serialization of split functions' ASTs.
 * It is created with an unbounded queue (so it can queue any number of pending tasks). Its core and max
 * threads is the same, but they are all allowed to time out so when there's no work, they can all go
 * away. The threads will be daemons, and they will time out if idle for a minute. Their priority is also
 * slightly lower than normal priority as we'd prefer the CPU to keep running the program; serializing
 * split function is a memory conservation measure (it allows us to release the AST), it can wait a bit.
 * @return an executor service with above described characteristics.
 */
private static ExecutorService createAstSerializerExecutorService() {
    final int threads = Math.max(1, Options.getIntProperty("nashorn.serialize.threads", Runtime.getRuntime().availableProcessors() / 2));
    final ThreadPoolExecutor service = new ThreadPoolExecutor(threads, threads, 1L, TimeUnit.MINUTES, new LinkedBlockingDeque<Runnable>(),
            new ThreadFactory() {
                @Override
                public Thread newThread(final Runnable r) {
                    final Thread t = new Thread(r, "Nashorn AST Serializer");
                    t.setDaemon(true);
                    t.setPriority(Thread.NORM_PRIORITY - 1);
                    return t;
                }
            });
    service.allowCoreThreadTimeOut(true);
    return service;
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @throws LanguageAdapterException
 *         In case of an initialization error
 */
public NashornAdapter() throws LanguageAdapterException
{
	super( "Nashorn", Version.version(), "JavaScript", new NashornScriptEngineFactory().getLanguageVersion(), Arrays.asList( "js", "javascript", "nashorn" ), "js", Arrays.asList( "javascript", "js", "nashorn" ),
		"nashorn" );

	try
	{
		System.setProperty( "nashorn.persistent.code.cache", getCacheDir().getCanonicalPath() );
	}
	catch( IOException x )
	{
		throw new LanguageAdapterException( NashornAdapter.class, "Could not access cache directory: " + getCacheDir(), x );
	}

	PrintWriter out = new PrintWriter( new ExecutionContextWriter(), true );
	PrintWriter err = new PrintWriter( new ExecutionContextErrorWriter(), true );

	// See: jdk.nashorn.internal.runtime.ScriptEnvironment
	Options options = new Options( "nashorn", err );
	options.set( "print.no.newline", true );
	options.set( "persistent.code.cache", true );
	ErrorManager errors = new ErrorManager( err );

	context = new Context( options, errors, out, err, getClass().getClassLoader() );
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@Test
public void evalTest() {
    final Options options = new Options("");
    final ErrorManager errors = new ErrorManager();
    final Context cx = new Context(options, errors, Thread.currentThread().getContextClassLoader());
    final ScriptObject oldGlobal = Context.getGlobal();
    Context.setGlobal(cx.createGlobal());
    try {
        String code = "22 + 10";
        assertTrue(32.0 == ((Number)(eval(cx, "<evalTest>", code))).doubleValue());

        code = "obj = { js: 'nashorn' }; obj.js";
        assertEquals(eval(cx, "<evalTest2>", code), "nashorn");
    } finally {
        Context.setGlobal(oldGlobal);
    }
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@BeforeClass
public void setupTest() {
    final Options options = new Options("nashorn");
    options.set("anon.functions", true);
    options.set("compile.only", true);
    options.set("print.ast", true);
    options.set("print.parse", true);
    options.set("scripting", true);

    final ErrorManager errors = new ErrorManager() {
        @Override
        public void error(final String msg) {
            log(msg);
        }
    };

    final StringWriter sw = new StringWriter();
    final PrintWriter pw = new PrintWriter(sw);
    this.context = new Context(options, errors, pw, pw, Thread.currentThread().getContextClassLoader());
    this.global = context.createGlobal();
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
private static File createBaseCacheDir() {
    if(MAX_FILES == 0 || Options.getBooleanProperty("nashorn.typeInfo.disabled")) {
        return null;
    }
    try {
        return createBaseCacheDirPrivileged();
    } catch(final Exception e) {
        reportError("Failed to create cache dir", e);
        return null;
    }
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
private static int getMaxFiles() {
    final String str = Options.getStringProperty("nashorn.typeInfo.maxFiles", null);
    if (str == null) {
        return DEFAULT_MAX_FILES;
    } else if ("unlimited".equals(str)) {
        return UNLIMITED_FILES;
    }
    return Math.max(0, Integer.parseInt(str));
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
ParserImpl(final String... args) throws IllegalArgumentException {
    Objects.requireNonNull(args);

    // handle the parser specific "--es6-module" option
    boolean seenModuleOption = false;
    for (int idx = 0; idx < args.length; idx++) {
        final String opt = args[idx];
        if (opt.equals("--es6-module")) {
            seenModuleOption = true;
            /*
             * Nashorn parser does not understand parser API specific
             * option. This option implies --language=es6. So, we change
             * the option to --language=es6. Note that if user specified
             * --language=es6 explicitly, that is okay. Nashorn tolerates
             * repeated options!
             */
            args[idx] = "--language=es6";
            break;
        }
    }
    this.moduleMode = seenModuleOption;

    // append "--parse-only to signal to the Nashorn that it
    // is being used in "parse only" mode.
    final String[] newArgs = Arrays.copyOf(args, args.length + 1, String[].class);
    newArgs[args.length] = "--parse-only";
    final Options options = new Options("nashorn");
    options.process(newArgs);
    this.env = new ScriptEnvironment(options,
            new PrintWriter(System.out), new PrintWriter(System.err));
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
/**
 * Creates the AST serializer executor service used for in-memory serialization of split functions' ASTs.
 * It is created with an unbounded queue (so it can queue any number of pending tasks). Its core and max
 * threads is the same, but they are all allowed to time out so when there's no work, they can all go
 * away. The threads will be daemons, and they will time out if idle for a minute. Their priority is also
 * slightly lower than normal priority as we'd prefer the CPU to keep running the program; serializing
 * split function is a memory conservation measure (it allows us to release the AST), it can wait a bit.
 * @return an executor service with above described characteristics.
 */
private static ExecutorService createAstSerializerExecutorService() {
    final int threads = Math.max(1, Options.getIntProperty("nashorn.serialize.threads", Runtime.getRuntime().availableProcessors() / 2));
    final ThreadPoolExecutor service = new ThreadPoolExecutor(threads, threads, 1, TimeUnit.MINUTES, new LinkedBlockingDeque<>(),
        (r) -> {
            final Thread t = new Thread(r, "Nashorn AST Serializer");
            t.setDaemon(true);
            t.setPriority(Thread.NORM_PRIORITY - 1);
            return t;
        });
    service.allowCoreThreadTimeOut(true);
    return service;
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@BeforeClass
public void setupTest() {
    final Options options = new Options("nashorn");
    options.set("parse.only", true);
    options.set("scripting", true);
    options.set("const.as.var", true);

    final ErrorManager errors = new ErrorManager();
    this.context = new Context(options, errors, Thread.currentThread().getContextClassLoader());
}
 

import jdk.nashorn.internal.runtime.options.Options; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() {
    // We must have a Context for the DynamicLinker that Bootstrap.getLinkerServices() will use
    oldGlobal = Context.getGlobal();
    cx = new Context(new Options(""), new ErrorManager(), null);
    Context.setGlobal(cx.createGlobal());
}