Skip to content

P
pyodide
Commit 54b55455 authored by Michael Droettboom's avatar Michael Droettboom
Browse files
Options

Fix #7: Refactor code into separate modules

parent 1de972ef
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 626 additions and 601 deletions
.gitignore
View file @ 54b55455
root/
pyodide.asm.*
build/pyodide.js
build/pyodide.asm.*
*.bc
Makefile
View file @ 54b55455
......@@ -15,18 +15,23 @@ LDFLAGS=$(OPTFLAGS) $(CPYTHON_EMSCRIPTEN_ROOT)/installs/python-$(PYVERSION)/lib/
--memory-init-file 0
all: pyodide.asm.html
all: build/pyodide.asm.html build/pyodide.js
pyodide.asm.html: main.bc root
build/pyodide.asm.html: src/main.bc src/jsproxy.bc src/js2python.bc src/pylocals.bc \
src/python2js.bc src/runpython.bc root
$(CC) -s WASM=1 -s EXPORT_NAME="'pyodide'" --bind -o $@ $(filter %.bc,$^) $(LDFLAGS) \
$(foreach d,$(wildcard root/*),--preload-file $d@/$(notdir $d))
build/pyodide.js: src/pyodide.js
cp $< $@
clean:
-rm -fr root
-rm pyodide.asm.*
-rm *.bc
-rm build/*
-rm src/*.bc
%.bc: %.cpp $(CPYTHON_EMSCRIPTEN_ROOT)/installs/python-$(PYVERSION)/lib/python$(PYMINOR)
......
index.html deleted 100644 → 0
View file @ 1de972ef
<!DOCTYPE html>
<html>
<!-- Quick and dirty tests... Not useful for anything else. -->
<head>
<meta charset="utf-8" />
</head>
<body>
<script src='python.asm.js'></script>
<script>
/* window.pyexec = Module.cwrap('PyRun_SimpleString', 'number', ['string']);*/
var doTest = function(code) {
var x = Module.runPython(code);
console.log("------")
console.log(code)
console.log("Return type " + typeof x)
console.log(JSON.stringify(x))
console.log()
}
var onReady = function() {
doTest("42");
doTest("42.0");
doTest("[0, 1, 32.0]")
doTest("{'foo': 42}")
doTest("'This is a string'")
doTest("def foo():\n return 42\n\nfoo()")
doTest("import sys\nsys.platform")
};
// Wait for the module to be ready before calling any functions.
var interval = setInterval(function () {
if (Module.calledRun) {
window.clearInterval(interval);
onReady();
}
}, 100);
</script>
</body>
</html>
main.cpp deleted 100644 → 0
View file @ 1de972ef
This diff is collapsed.
src/js2python.cpp 0 → 100644
View file @ 54b55455
#include "js2python.hpp"
#include "jsproxy.hpp"
using emscripten::val;
PyObject *jsToPython(val x, val *parent, const char *name) {
val xType = x.typeOf();
if (xType.equals(val("string"))) {
std::wstring x_str = x.as<std::wstring>();
return PyUnicode_FromWideChar(&*x_str.begin(), x_str.size());
} else if (xType.equals(val("number"))) {
double x_double = x.as<double>();
return PyFloat_FromDouble(x_double);
} else if (xType.equals(val("undefined"))) {
Py_INCREF(Py_None);
return Py_None;
} else {
return JsProxy_cnew(x, parent, name);
}
}
src/js2python.hpp 0 → 100644
View file @ 54b55455
#ifndef JS2PYTHON_H
#define JS2PYTHON_H
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
#include <Python.h>
PyObject *jsToPython(emscripten::val x,
emscripten::val *parent = NULL,
const char *name = NULL);
#endif /* JS2PYTHON_H */
src/jsproxy.cpp 0 → 100644
View file @ 54b55455
#include "jsproxy.hpp"
#include "js2python.hpp"
#include "python2js.hpp"
using emscripten::val;
// TODO: Bound methods should probably have their own class, rather than using
// JsProxy for everything
////////////////////////////////////////////////////////////
// JsProxy
//
// This is a Python object that provides ideomatic access to a Javascript object.
typedef struct {
PyObject_HEAD
val *js;
val *parent;
char *name;
} JsProxy;
static void JsProxy_dealloc(JsProxy *self) {
delete self->js;
if (self->parent) {
delete self->parent;
}
if (self->name) {
free(self->name);
}
Py_TYPE(self)->tp_free((PyObject *)self);
}
static PyObject *JsProxy_GetAttr(PyObject *o, PyObject *attr_name) {
JsProxy *self = (JsProxy *)o;
PyObject *str = PyObject_Str(attr_name);
if (str == NULL) {
return NULL;
}
std::string s(PyUnicode_AsUTF8(str));
val v = (*self->js)[s];
Py_DECREF(str);
return jsToPython(v, self->js, s.c_str());
}
static int JsProxy_SetAttr(PyObject *o, PyObject *attr_name, PyObject *value) {
JsProxy *self = (JsProxy *)o;
PyObject *attr_name_py_str = PyObject_Str(attr_name);
if (attr_name_py_str == NULL) {
return NULL;
}
std::string attr_name_str(PyUnicode_AsUTF8(attr_name_py_str));
val value_js = pythonToJs(value);
(*self->js).set(attr_name_str, value_js);
Py_DECREF(attr_name_py_str);
return 0;
}
static PyObject* JsProxy_Call(PyObject *o, PyObject *args, PyObject *kwargs) {
JsProxy *self = (JsProxy *)o;
Py_ssize_t nargs = PyTuple_Size(args);
// TODO: There's probably some way to not have to explicitly expand arguments
// here.
if (self->parent) {
switch (nargs) {
case 0:
return jsToPython((*self->parent).call<val>(self->name));
case 1:
return jsToPython((*self->parent).call<val>(
self->name,
pythonToJs(PyTuple_GET_ITEM(args, 0))));
case 2:
return jsToPython((*self->parent).call<val>(
self->name,
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1))));
case 3:
return jsToPython((*self->parent).call<val>(
self->name,
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1)),
pythonToJs(PyTuple_GET_ITEM(args, 2))));
case 4:
return jsToPython((*self->parent).call<val>(
self->name,
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1)),
pythonToJs(PyTuple_GET_ITEM(args, 2)),
pythonToJs(PyTuple_GET_ITEM(args, 3))));
}
} else {
switch (nargs) {
case 0:
return jsToPython((*self->js)());
case 1:
return jsToPython((*self->js)(
pythonToJs(PyTuple_GET_ITEM(args, 0))));
case 2:
return jsToPython((*self->js)(
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1))));
case 3:
return jsToPython((*self->js)(
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1)),
pythonToJs(PyTuple_GET_ITEM(args, 2))));
case 4:
return jsToPython((*self->js)(
pythonToJs(PyTuple_GET_ITEM(args, 0)),
pythonToJs(PyTuple_GET_ITEM(args, 1)),
pythonToJs(PyTuple_GET_ITEM(args, 2)),
pythonToJs(PyTuple_GET_ITEM(args, 3))));
}
}
// TODO: Handle exception here
return NULL;
}
static PyTypeObject JsProxyType = {
.tp_name = "JsProxy",
.tp_basicsize = sizeof(JsProxy),
.tp_dealloc = (destructor)JsProxy_dealloc,
.tp_call = JsProxy_Call,
.tp_getattro = JsProxy_GetAttr,
.tp_setattro = JsProxy_SetAttr,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_doc = "A proxy to make a Javascript object behave like a Python object"
};
PyObject *JsProxy_cnew(val v, val *parent, const char *name) {
JsProxy *self;
self = (JsProxy *)JsProxyType.tp_alloc(&JsProxyType, 0);
self->js = new val(v);
if (parent) {
self->parent = new val(*parent);
size_t n = strnlen(name, 256);
char *copy = (char *)malloc(n + 1);
strncpy(copy, name, n + 1);
self->name = copy;
} else {
self->parent = NULL;
}
return (PyObject *)self;
}
int JsProxy_Check(PyObject *x) {
return PyObject_TypeCheck(x, &JsProxyType);
}
val JsProxy_AsVal(PyObject *x) {
JsProxy *js_proxy = (JsProxy *)x;
return val(*(js_proxy->js));
}
int JsProxy_Ready() {
return PyType_Ready(&JsProxyType);
}
src/jsproxy.hpp 0 → 100644
View file @ 54b55455
#ifndef JSPROXY_H
#define JSPROXY_H
#include <Python.h>
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
PyObject *JsProxy_cnew(emscripten::val v, emscripten::val *parent, const char *name);
int JsProxy_Check(PyObject *x);
emscripten::val JsProxy_AsVal(PyObject *x);
int JsProxy_Ready();
#endif /* JSPROXY_H */
src/main.cpp 0 → 100644
View file @ 54b55455
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
#include <Python.h>
#include <node.h> // from CPython
#include "jsproxy.hpp"
#include "js2python.hpp"
#include "pylocals.hpp"
#include "python2js.hpp"
#include "runpython.hpp"
using emscripten::val;
////////////////////////////////////////////////////////////
// Forward declarations
////////////////////////////////////////////////////////////
// Conversions
EMSCRIPTEN_BINDINGS(python) {
emscripten::function("runPython", &runPython);
emscripten::class_<PyObject>("PyObject");
}
extern "C" {
int main(int argc, char** argv) {
setenv("PYTHONHOME", "/", 0);
Py_InitializeEx(0);
if (JsProxy_Ready() ||
pythonToJs_Ready() ||
PyLocals_Ready()) {
return 1;
}
emscripten_exit_with_live_runtime();
return 0;
}
}
src/pylocals.cpp 0 → 100644
View file @ 54b55455
#include "pylocals.hpp"
#include "js2python.hpp"
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
using emscripten::val;
////////////////////////////////////////////////////////////
// PyLocals
//
// This is an object designed to be used as a "locals" namespace dictionary.
// It first looks for things in its own internal dictionary, and failing that,
// looks in the Javascript global namespace. This is a way of merging the
// Python and Javascript namespaces without fullying copying either one.
PyObject *locals = NULL;
PyObject *globals = NULL;
PyObject *original_globals = NULL;
typedef struct {
PyObject_HEAD
PyObject *locals;
} PyLocals;
static void PyLocals_dealloc(PyLocals *self) {
Py_DECREF(self->locals);
Py_TYPE(self)->tp_free((PyObject *)self);
}
static Py_ssize_t PyLocals_length(PyObject *o) {
PyLocals *self = (PyLocals *)o;
return PyDict_Size(self->locals);
}
PyObject* PyLocals_get(PyObject *o, PyObject *key) {
PyLocals *self = (PyLocals *)o;
{
PyObject *str = PyObject_Str(key);
if (str == NULL) {
return NULL;
}
char *c = PyUnicode_AsUTF8(str);
Py_DECREF(str);
}
PyObject *py_val = PyDict_GetItem(self->locals, key);
if (py_val != NULL) {
Py_INCREF(py_val);
return py_val;
}
PyObject *str = PyObject_Str(key);
if (str == NULL) {
return NULL;
}
char *c = PyUnicode_AsUTF8(str);
val v = val::global(c);
Py_DECREF(str);
return jsToPython(v);
}
int PyLocals_set(PyObject *o, PyObject *k, PyObject *v) {
PyLocals *self = (PyLocals *)o;
if (v == NULL) {
// TODO: This might not actually be here to delete...
return PyDict_DelItem(self->locals, k);
} else {
return PyDict_SetItem(self->locals, k, v);
}
}
static PyMappingMethods PyLocals_as_mapping = {
PyLocals_length,
PyLocals_get,
PyLocals_set
};
static PyTypeObject PyLocalsType = {
.tp_name = "PyLocals",
.tp_basicsize = sizeof(PyLocals),
.tp_dealloc = (destructor)PyLocals_dealloc,
.tp_as_mapping = &PyLocals_as_mapping,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_doc = "A proxy that looks in a dict first, otherwise in the global JS namespace"
};
static PyObject *PyLocals_cnew(PyObject *d)
{
PyLocals *self;
self = (PyLocals *)PyLocalsType.tp_alloc(&PyLocalsType, 0);
if (self != NULL) {
Py_INCREF(d);
self->locals = d;
}
return (PyObject *)self;
}
int PyLocals_Ready() {
if (PyType_Ready(&PyLocalsType) < 0)
return 1;
PyObject *m = PyImport_AddModule("__main__");
if (m == NULL)
return 1;
globals = PyModule_GetDict(m);
m = PyImport_AddModule("builtins");
PyDict_Update(globals, PyModule_GetDict(m));
original_globals = PyDict_Copy(globals);
locals = PyLocals_cnew(globals);
if (locals == NULL)
return 1;
return 0;
}
src/pylocals.hpp 0 → 100644
View file @ 54b55455
#ifndef PYLOCALS_H
#define PYLOCALS_H
#include <Python.h>
int PyLocals_Ready();
extern PyObject *locals;
extern PyObject *globals;
extern PyObject *original_globals;
#endif /* PYLOCALS_H */
src/python2js.cpp 0 → 100644
View file @ 54b55455
#include "python2js.hpp"
#include "jsproxy.hpp"
using emscripten::val;
static val *undefined;
val pythonExcToJS() {
PyObject *type;
PyObject *value;
PyObject *traceback;
PyObject *str;
PyErr_Fetch(&type, &value, &traceback);
str = PyObject_Str(value);
// TODO: Return a JS Error object rather than a string here...?
val result = pythonToJs(str);
Py_DECREF(str);
Py_DECREF(type);
Py_DECREF(value);
Py_DECREF(traceback);
return result;
}
val pythonToJs(PyObject *x) {
// TODO: bool, None
if (x == Py_None) {
return val(*undefined);
} else if (x == Py_True) {
return val(true);
} else if (x == Py_False) {
return val(false);
} else if (PyLong_Check(x)) {
long x_long = PyLong_AsLongLong(x);
if (x_long == -1 && PyErr_Occurred()) {
return pythonExcToJS();
}
return val(x_long);
} else if (PyFloat_Check(x)) {
double x_double = PyFloat_AsDouble(x);
if (x_double == -1.0 && PyErr_Occurred()) {
return pythonExcToJS();
}
return val(x_double);
} else if (PyUnicode_Check(x)) {
// TODO: Not clear whether this is UTF-16 or UCS2
// TODO: This is doing two copies. Can we reduce?
Py_ssize_t length;
wchar_t *chars = PyUnicode_AsWideCharString(x, &length);
if (chars == NULL) {
return pythonExcToJS();
}
std::wstring x_str(chars, length);
PyMem_Free(chars);
return val(x_str);
} else if (PyBytes_Check(x)) {
// TODO: This is doing two copies. Can we reduce?
char *x_buff;
Py_ssize_t length;
PyBytes_AsStringAndSize(x, &x_buff, &length);
std::string x_str(x_buff, length);
return val(x_str);
} else if (JsProxy_Check(x)) {
return JsProxy_AsVal(x);
} else if (PySequence_Check(x)) {
val array = val::global("Array");
val x_array = array.new_();
size_t length = PySequence_Size(x);
for (size_t i = 0; i < length; ++i) {
PyObject *item = PySequence_GetItem(x, i);
if (item == NULL) {
return pythonExcToJS();
}
x_array.call<int>("push", pythonToJs(item));
Py_DECREF(item);
}
return x_array;
} else if (PyDict_Check(x)) {
val object = val::global("Object");
val x_object = object.new_();
PyObject *k, *v;
Py_ssize_t pos = 0;
while (PyDict_Next(x, &pos, &k, &v)) {
x_object.set(pythonToJs(k), pythonToJs(v));
}
return x_object;
} else {
return val(x);
}
}
int pythonToJs_Ready() {
undefined = new val(val::global("undefined"));
return 0;
}
src/python2js.hpp 0 → 100644
View file @ 54b55455
#ifndef PYTHON2JS_H
#define PYTHON2JS_H
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
#include <Python.h>
emscripten::val pythonExcToJS();
emscripten::val pythonToJs(PyObject *x);
int pythonToJs_Ready();
#endif /* PYTHON2JS_H */
src/runpython.cpp 0 → 100644
View file @ 54b55455
#include "runpython.hpp"
#include <codecvt>
#include <locale>
#include <Python.h>
#include <node.h> // from Python
#include "pylocals.hpp"
#include "python2js.hpp"
using emscripten::val;
static bool is_whitespace(char x) {
switch (x) {
case ' ':
case '\n':
case '\r':
case '\t':
return true;
default:
return false;
}
}
val runPython(std::wstring code) {
std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
std::string code_utf8 = conv.to_bytes(code);
std::string::iterator last_line = code_utf8.end();
PyCompilerFlags cf;
cf.cf_flags = PyCF_SOURCE_IS_UTF8;
PyEval_MergeCompilerFlags(&cf);
if (code_utf8.size() == 0) {
return pythonToJs(Py_None);
}
// Find the last non-whitespace-only line since that will provide the result
// TODO: This way to find the last line will probably break in many ways
last_line--;
for (; last_line != code_utf8.begin() && is_whitespace(*last_line); last_line--) {}
for (; last_line != code_utf8.begin() && *last_line != '\n'; last_line--) {}
int do_eval_line = 1;
_node *co;
co = PyParser_SimpleParseStringFlags(&*last_line, Py_eval_input, cf.cf_flags);
if (co == NULL) {
do_eval_line = 0;
PyErr_Clear();
}
PyNode_Free(co);
PyObject *ret;
if (do_eval_line == 0 || last_line != code_utf8.begin()) {
if (do_eval_line) {
*last_line = 0;
last_line++;
}
ret = PyRun_StringFlags(&*code_utf8.begin(), Py_file_input, globals, locals, &cf);
if (ret == NULL) {
return pythonExcToJS();
}
Py_DECREF(ret);
}
switch (do_eval_line) {
case 0:
Py_INCREF(Py_None);
ret = Py_None;
break;
case 1:
ret = PyRun_StringFlags(&*last_line, Py_eval_input, globals, locals, &cf);
break;
case 2:
ret = PyRun_StringFlags(&*last_line, Py_file_input, globals, locals, &cf);
break;
}
if (ret == NULL) {
return pythonExcToJS();
}
// Now copy all the variables over to the Javascript side
{
val js_globals = val::global("window");
PyObject *k, *v;
Py_ssize_t pos = 0;
while (PyDict_Next(globals, &pos, &k, &v)) {
if (!PyDict_Contains(original_globals, k)) {
js_globals.set(pythonToJs(k), pythonToJs(v));
}
}
}
val result = pythonToJs(ret);
Py_DECREF(ret);
return result;
}
src/runpython.hpp 0 → 100644
View file @ 54b55455
#ifndef RUNPYTHON_H
#define RUNPYTHON_H
#include <string>
#include <emscripten.h>
#include <emscripten/bind.h>
#include <emscripten/val.h>
emscripten::val runPython(std::wstring code);
#endif /* RUNPYTHON_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7