import org.python.core.PyCode; //导入依赖的package包/类
public void execute( ExecutionContext executionContext ) throws ParsingException, ExecutionException
{
	PythonInterpreter pythonInterpreter = adapter.getPythonInterpreter( executionContext, executable );

	try
	{
		PyCode pythonCode = this.pythonCode;
		if( pythonCode != null )
			pythonInterpreter.exec( pythonCode );
		else
			// We're using a stream because PythonInterpreter does not
			// expose a string-based method that also accepts a filename.
			pythonInterpreter.execfile( new ByteArrayInputStream( sourceCode.getBytes() ), executable.getDocumentName() );
	}
	catch( Exception x )
	{
		throw JythonAdapter.createExecutionException( executable.getDocumentName(), startLineNumber, x );
	}
	finally
	{
		JythonAdapter.flush( pythonInterpreter, executionContext );
	}
}
 

import org.python.core.PyCode; //导入依赖的package包/类
private void populateSelection() {
	List<Table> tables = new ArrayList<Table>();
	Worksheet worksheet = workspace.getWorksheet(worksheetId);
	CloneTableUtils.getDatatable(worksheet.getDataTable(), workspace.getFactory().getHTable(hTableId), tables, SuperSelectionManager.DEFAULT_SELECTION);
	String selectionId = Thread.currentThread().getId() + this.superSelectionName;
	PythonRepository repo = PythonRepository.getInstance();
	PythonInterpreter interpreter = repo.interpreter;
	repo.initializeInterperter(interpreter);
	PyCode code = null;
	try {
		code = getCompiledCode(pythonCode, interpreter, selectionId);
		interpreter.getLocals().__setitem__("selection", interpreter.get("selection"+selectionId));
		
	
		for (Table t : tables) {
			for (Row r : t.getRows(0, t.getNumRows(), SuperSelectionManager.DEFAULT_SELECTION)) {
				if (code == null)
					selectedRowsCache.put(r, onError);
				else
					selectedRowsCache.put(r, evaluatePythonExpression(r, code, interpreter));
			}
		}
	} catch(Exception e) {
		logger.error("Unable to populate selection");
	}
}
 

import org.python.core.PyCode; //导入依赖的package包/类
private PyCode getCompiledCode(String pythonCode, PythonInterpreter interpreter, String selectionId) throws IOException {

		String trimmedSelectionCode = pythonCode.trim();
		Worksheet worksheet = workspace.getWorksheet(worksheetId);
		if (trimmedSelectionCode.isEmpty()) {
			trimmedSelectionCode = "return False";
		}
		String selectionMethodStmt = PythonTransformationHelper
				.getPythonSelectionMethodDefinitionState(worksheet,
						trimmedSelectionCode,selectionId);


		logger.debug("Executing PySelection\n" + selectionMethodStmt);

		// Prepare the Python interpreter
		PythonRepository repo = PythonRepository.getInstance();

		repo.compileAndAddToRepositoryAndExec(interpreter, selectionMethodStmt);
		PyObject locals = interpreter.getLocals();
		locals.__setitem__("workspaceid", new PyString(workspace.getId()));
		locals.__setitem__("selectionName", new PyString(superSelectionName));
		locals.__setitem__("command", Py.java2py(this));
		return repo.getSelectionCode();
	}
 

import org.python.core.PyCode; //导入依赖的package包/类
private void initialize()
{
	scripts = new ConcurrentHashMap<String, PyCode>();

	
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getImportStatements());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getRowIndexDefStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getGetValueDefStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getGetValueFromNestedColumnByIndexDefStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getIsEmptyDefStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getHasSelectedRowsStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getVDefStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getTransformStatement());
	compileAndAddToRepository(interpreter, PythonTransformationHelper.getSelectionStatement());
	initializeInterperter(interpreter);
}
 

import org.python.core.PyCode; //导入依赖的package包/类
public PythonScriptExecutorPool(GameScriptingEngine gameScriptingEngine, int poolSize) {
	this.gameScriptingEngine = gameScriptingEngine;
	executors = new ArrayBlockingQueue<ScriptExecutor<PyCode>>(poolSize);

	for (int i = 0; i < poolSize; i++) {
		executors.offer(new PythonScriptExecutor(this));
	}
}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public int preCompileScript(String scriptContent) throws InsufficientCompilersException {
	ScriptExecutor<PyCode> executor = executors.poll();
	if (executor == null) {
		throw new InsufficientCompilersException();
	}
	GameScript<PyCode> script = executor.compile(scriptContent);
	executor.release();
	scripts.put(script.getId(), script);
	return script.getId();
}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public ScriptExecutionTask<?> execute(int scriptId, ScriptBindings scriptBindings,
		ScriptInvocationListener invocationListener) {
	ScriptExecutor<PyCode> executor = allocateExecutor();
	if (executor == null) {
		throw new ScriptExecutorUnavailableException(scriptId);
	}
	return new ScriptExecutionTask<PyCode>(gameScriptingEngine, executor, scripts.get(scriptId), scriptBindings,
			invocationListener);
}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public void release(ScriptExecutor<PyCode> executor) {
	try {
		executors.put(executor);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}
 

import org.python.core.PyCode; //导入依赖的package包/类
private ScriptExecutor<PyCode> allocateExecutor() {
	try {
		return executors.take();
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	return null;
}
 

import org.python.core.PyCode; //导入依赖的package包/类
/** Parse and compile script file
 *
 *  @param path Path to add to search path, or <code>null</code>
 *  @param name Name of script (file name, URL)
 *  @param stream Stream for the script content
 *  @return {@link Script}
 *  @throws Exception on error
 */
public Script compile(final String path, final String name, final InputStream stream) throws Exception
{
    if (path != null)
        addToPythonPath(path);
    final long start = System.currentTimeMillis();
    final PyCode code = python.compile(new InputStreamReader(stream), name);
    final long end = System.currentTimeMillis();
    logger.log(Level.FINE, "Time to compile {0}: {1} ms", new Object[] { name, (end - start) });
    return new JythonScript(this, name, code);
}
 

import org.python.core.PyCode; //导入依赖的package包/类
/** Parse and compile script file
 *
 *  @param support {@link JythonScriptSupport} that will execute this script
 *  @param name Name of script (file name, URL)
 *  @param code Compiled code
 */
public JythonScript(final JythonScriptSupport support, final String name, final PyCode code)
{
    this.support = support;
    this.name = name;
    this.code = code;
}
 

import org.python.core.PyCode; //导入依赖的package包/类
private void testInterpreter(final PythonInterpreter python) throws Exception
{
    // Run on new threads to get fresh thread-locals
    final ExecutorService new_executor = Executors.newCachedThreadPool();

    final String script = "import sys\nresult = sys.path";
    final Callable<String> test_run = () ->
    {
        // System.out.println("Executing on " + Thread.currentThread().getName());
        final PyCode code = python.compile(script);
        python.exec(code);
        return python.get("result").toString();
    };

    final List<Future<String>> futures = new ArrayList<>();
    final long end = System.currentTimeMillis() + 1000L;
    while (System.currentTimeMillis() < end)
    {
        for (int i=0; i<50; ++i)
            futures.add(new_executor.submit(test_run));
        for (Future<String> future : futures)
        {
            final String result = future.get();
            //System.out.println(result);
            assertThat(result, containsString("always"));
            assertThat(result, containsString("special"));
        }
        futures.clear();
    }
    new_executor.shutdown();
}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public PythonScript parseScript(Reader reader) {
    try (PythonInterpreter interp = new PythonInterpreter()) {
        PyCode compiledCode = interp.compile(reader);
        PythonScript activeScript = new PythonScript(compiledCode);
        return activeScript;
    }
}
 

import org.python.core.PyCode; //导入依赖的package包/类
private boolean evaluatePythonExpression(Row r, PyCode code, PythonInterpreter interpreter) {
	evalColumns.clear();
	try {
		ArrayList<Node> nodes = new ArrayList<Node>(r.getNodes());
		Node node = nodes.get(0);
		interpreter.getLocals().__setitem__("nodeid", new PyString(node.getId()));
		PyObject output = interpreter.eval(code);
		return PythonTransformationHelper.getPyObjectValueAsBoolean(output);
	}catch(Exception e) {
		return onError;
	}

}
 

import org.python.core.PyCode; //导入依赖的package包/类
public PyCode compileAndAddToRepositoryAndExec(PythonInterpreter interpreter, String statement)
{
	PyCode py  = null;
	if(!scripts.containsKey(statement))
	{
		py = compileAndAddToRepository(interpreter,statement);
		
	}
	else
		py = scripts.get(statement);
	interpreter.exec(py);
	return py;
}
 

import org.python.core.PyCode; //导入依赖的package包/类
public PyCode compileAndAddToRepository(PythonInterpreter interpreter,
		String statement) {
	PyCode py  = null;
	if(!scripts.containsKey(statement))
	{
		py = compile(interpreter, statement);
		scripts.putIfAbsent(statement, py);
	}
	return scripts.get(statement);
}
 

import org.python.core.PyCode; //导入依赖的package包/类
public synchronized void resetLibrary()
{
	libraryScripts = new ConcurrentHashMap<String, PyCode>();
	fileNameTolastTimeRead = new ConcurrentHashMap<String,Long>();		
	libraryHasBeenLoaded = false;

}
 

import org.python.core.PyCode; //导入依赖的package包/类
/**
 * Runs the given PyCode, optionally in a thread.
 * @param code The already compiled PyCode object.
 * @param path The path to the script file.
 * @param async Boolean indicating whether to run the script in a separate thread or not. If 
 * true, the execution is asynchronous and the call returns immediately.
 */
public void runJythonScript(final PyCode code, String path, boolean async) {
    if (currentScripts.size() < maxScripts) {
        Thread run = new ScriptRunnable(code, path);

        if (async) {
            run.start();
        } else {
            run.run();
        }
    } else {
        EventManager.instance.post(Events.POST_NOTIFICATION, I18n.bundle.format("notif.script.max", maxScripts));
    }
}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public void notify(Events event, Object... data) {
    switch (event) {
    case RUN_SCRIPT_PYCODE:
        PyCode code = (PyCode) data[0];
        String path = (String) data[1];
        boolean async = true;
        if (data.length > 1)
            async = (Boolean) data[2];
        runJythonScript(code, path, async);
        break;
    case RUN_SCRIPT_PATH:
        path = (String) data[0];
        FileHandle file = Gdx.files.internal(path);
        String string = file.readString();
        async = true;
        if (data.length > 1)
            async = (Boolean) data[1];
        runJythonScript(string, path, async);
        break;
    case CANCEL_SCRIPT_CMD:
        String pathToCancel = currentScripts.keySet().iterator().next();
        cancelScript(pathToCancel);
        break;
    }

}
 

import org.python.core.PyCode; //导入依赖的package包/类
@Override
public GameScript<PyCode> compile(String script) {
	return new GlobalGameScript<PyCode>(pythonInterpreter.compile(script));
}