Skip to content

P
Pyston
Commit 798c4da8 authored by Kevin Modzelewski's avatar Kevin Modzelewski
Browse files
Options

Move doc+name from the function ctor to code ctor 

since this is where it's supposed to live.  The function ctor
copies these fields from the code object.
parent 2affae97
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1082 additions and 787 deletions
Makefile
View file @ 798c4da8
...@@ -922,8 +922,9 @@ wdbg_%: ...@@ -922,8 +922,9 @@ wdbg_%:
.PHONY: head_% .PHONY: head_%
HEAD := 40 HEAD := 40
HEAD_SKIP := 6
head_%: head_%:
@ bash -c "set -o pipefail; script -e -q -c '$(MAKE) $(dir $@)$(patsubst head_%,%,$(notdir $@))' /dev/null | head -n$(HEAD)" @ bash -c "set -o pipefail; script -e -q -c '$(MAKE) $(dir $@)$(patsubst head_%,%,$(notdir $@))' /dev/null | tail -n+$(HEAD_SKIP) | head -n$(HEAD)"
head: head_pyston_dbg head: head_pyston_dbg
.PHONY: hwatch_% .PHONY: hwatch_%
hwatch_%: hwatch_%:
......
src/runtime/bool.cpp
View file @ 798c4da8
...@@ -93,17 +93,20 @@ void setupBool() { ...@@ -93,17 +93,20 @@ void setupBool() {
static PyNumberMethods bool_as_number; static PyNumberMethods bool_as_number;
bool_cls->tp_as_number = &bool_as_number; bool_cls->tp_as_number = &bool_as_number;
bool_cls->giveAttr("__nonzero__", new BoxedFunction(BoxedCode::create((void*)boolNonzero, BOXED_BOOL, 1))); bool_cls->giveAttr("__nonzero__",
bool_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)boolRepr<CXX>, STR, 1))); new BoxedFunction(BoxedCode::create((void*)boolNonzero, BOXED_BOOL, 1, "bool.__nonzero__")));
bool_cls->giveAttr("__hash__", new BoxedFunction(BoxedCode::create((void*)boolHash, BOXED_INT, 1))); bool_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)boolRepr<CXX>, STR, 1, "bool.__repr__")));
bool_cls->giveAttr("__hash__",
new BoxedFunction(BoxedCode::create((void*)boolHash, BOXED_INT, 1, "bool.__hash__")));
bool_cls->giveAttr("__new__", bool_cls->giveAttr(
new BoxedFunction(BoxedCode::create((void*)boolNew, UNKNOWN, 2, false, false), { Py_None })); "__new__",
new BoxedFunction(BoxedCode::create((void*)boolNew, UNKNOWN, 2, false, false, "bool.__new__"), { Py_None }));
// TODO: type specialize // TODO: type specialize
bool_cls->giveAttr("__and__", new BoxedFunction(BoxedCode::create((void*)boolAnd, UNKNOWN, 2))); bool_cls->giveAttr("__and__", new BoxedFunction(BoxedCode::create((void*)boolAnd, UNKNOWN, 2, "bool.__and__")));
bool_cls->giveAttr("__or__", new BoxedFunction(BoxedCode::create((void*)boolOr, UNKNOWN, 2))); bool_cls->giveAttr("__or__", new BoxedFunction(BoxedCode::create((void*)boolOr, UNKNOWN, 2, "bool.__or__")));
bool_cls->giveAttr("__xor__", new BoxedFunction(BoxedCode::create((void*)boolXor, UNKNOWN, 2))); bool_cls->giveAttr("__xor__", new BoxedFunction(BoxedCode::create((void*)boolXor, UNKNOWN, 2, "bool.__xor__")));
bool_cls->freeze(); bool_cls->freeze();
bool_cls->tp_hash = (hashfunc)bool_hash; bool_cls->tp_hash = (hashfunc)bool_hash;
......
src/runtime/builtin_modules/builtins.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/builtin_modules/pyston.cpp
View file @ 798c4da8
...@@ -67,12 +67,12 @@ void setupPyston() { ...@@ -67,12 +67,12 @@ void setupPyston() {
pyston_module = createModule(autoDecref(boxString("__pyston__"))); pyston_module = createModule(autoDecref(boxString("__pyston__")));
pyston_module->giveAttr( pyston_module->giveAttr(
"setOption", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)setOption, UNKNOWN, 2), "setOption")); "setOption", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)setOption, UNKNOWN, 2, "setOption")));
pyston_module->giveAttr( pyston_module->giveAttr(
"clearStats", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)clearStats, NONE, 0), "clearStats")); "clearStats", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)clearStats, NONE, 0, "clearStats")));
pyston_module->giveAttr("dumpStats", pyston_module->giveAttr("dumpStats",
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)dumpStats, NONE, 1, false, false), new BoxedBuiltinFunctionOrMethod(
"dumpStats", { Py_False })); BoxedCode::create((void*)dumpStats, NONE, 1, false, false, "dumpStats"), { Py_False }));
} }
} }
src/runtime/builtin_modules/sys.cpp
View file @ 798c4da8
...@@ -814,14 +814,13 @@ void setupSys() { ...@@ -814,14 +814,13 @@ void setupSys() {
sys_module->giveAttr("argv", new BoxedList()); sys_module->giveAttr("argv", new BoxedList());
sys_module->giveAttr("exc_info", sys_module->giveAttr("exc_info", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysExcInfo, BOXED_TUPLE,
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysExcInfo, BOXED_TUPLE, 0), 0, "exc_info", exc_info_doc)));
"exc_info", exc_info_doc)); sys_module->giveAttr("exc_clear", new BoxedBuiltinFunctionOrMethod(
sys_module->giveAttr("exc_clear", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysExcClear, NONE, 0), BoxedCode::create((void*)sysExcClear, NONE, 0, "exc_clear", exc_clear_doc)));
"exc_clear", exc_clear_doc)); sys_module->giveAttr(
sys_module->giveAttr("exit", "exit", new BoxedBuiltinFunctionOrMethod(
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysExit, NONE, 1, false, false), BoxedCode::create((void*)sysExit, NONE, 1, false, false, "exit", exit_doc), { Py_None }, NULL));
"exit", { Py_None }, NULL, exit_doc));
sys_module->giveAttr("warnoptions", new BoxedList()); sys_module->giveAttr("warnoptions", new BoxedList());
sys_module->giveAttrBorrowed("py3kwarning", Py_False); sys_module->giveAttrBorrowed("py3kwarning", Py_False);
...@@ -831,20 +830,22 @@ void setupSys() { ...@@ -831,20 +830,22 @@ void setupSys() {
sys_module->giveAttr("executable", boxString(Py_GetProgramFullPath())); sys_module->giveAttr("executable", boxString(Py_GetProgramFullPath()));
sys_module->giveAttr("_getframe", sys_module->giveAttr(
new BoxedFunction(BoxedCode::create((void*)sysGetFrame, UNKNOWN, 1, false, false), { NULL })); "_getframe",
sys_module->giveAttr("_current_frames", new BoxedFunction(BoxedCode::create((void*)sysCurrentFrames, UNKNOWN, 0))); new BoxedFunction(BoxedCode::create((void*)sysGetFrame, UNKNOWN, 1, false, false, "_getframe"), { NULL }));
sys_module->giveAttr("_current_frames",
new BoxedFunction(BoxedCode::create((void*)sysCurrentFrames, UNKNOWN, 0, "_current_frames")));
sys_module->giveAttr("getdefaultencoding", sys_module->giveAttr("getdefaultencoding",
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysGetDefaultEncoding, STR, 0), new BoxedBuiltinFunctionOrMethod(BoxedCode::create(
"getdefaultencoding", getdefaultencoding_doc)); (void*)sysGetDefaultEncoding, STR, 0, "getdefaultencoding", getdefaultencoding_doc)));
sys_module->giveAttr("getfilesystemencoding", sys_module->giveAttr("getfilesystemencoding", new BoxedBuiltinFunctionOrMethod(BoxedCode::create(
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysGetFilesystemEncoding, STR, 0), (void*)sysGetFilesystemEncoding, STR, 0, "getfilesystemencoding",
"getfilesystemencoding", getfilesystemencoding_doc)); getfilesystemencoding_doc)));
sys_module->giveAttr("getrecursionlimit", sys_module->giveAttr("getrecursionlimit",
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)sysGetRecursionLimit, UNKNOWN, 0), new BoxedBuiltinFunctionOrMethod(BoxedCode::create(
"getrecursionlimit", getrecursionlimit_doc)); (void*)sysGetRecursionLimit, UNKNOWN, 0, "getrecursionlimit", getrecursionlimit_doc)));
// As we don't support compile() etc yet force 'dont_write_bytecode' to true. // As we don't support compile() etc yet force 'dont_write_bytecode' to true.
sys_module->giveAttrBorrowed("dont_write_bytecode", Py_True); sys_module->giveAttrBorrowed("dont_write_bytecode", Py_True);
......
src/runtime/builtin_modules/thread.cpp
View file @ 798c4da8
...@@ -218,33 +218,35 @@ void setupThread() { ...@@ -218,33 +218,35 @@ void setupThread() {
thread_module->giveAttr( thread_module->giveAttr(
"start_new_thread", "start_new_thread",
new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)startNewThread, BOXED_INT, 3, false, false), new BoxedBuiltinFunctionOrMethod(
"start_new_thread", { NULL })); BoxedCode::create((void*)startNewThread, BOXED_INT, 3, false, false, "start_new_thread"), { NULL }));
thread_module->giveAttr("allocate_lock", new BoxedBuiltinFunctionOrMethod( thread_module->giveAttr("allocate_lock", new BoxedBuiltinFunctionOrMethod(
BoxedCode::create((void*)allocateLock, UNKNOWN, 0), "allocate_lock")); BoxedCode::create((void*)allocateLock, UNKNOWN, 0, "allocate_lock")));
thread_module->giveAttr( thread_module->giveAttr(
"get_ident", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)getIdent, BOXED_INT, 0), "get_ident")); "get_ident", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)getIdent, BOXED_INT, 0, "get_ident")));
thread_module->giveAttr("stack_size", new BoxedBuiltinFunctionOrMethod( thread_module->giveAttr("stack_size", new BoxedBuiltinFunctionOrMethod(
BoxedCode::create((void*)stackSize, BOXED_INT, 0), "stack_size")); BoxedCode::create((void*)stackSize, BOXED_INT, 0, "stack_size")));
thread_module->giveAttr( thread_module->giveAttr(
"_count", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)threadCount, BOXED_INT, 0), "_count")); "_count", new BoxedBuiltinFunctionOrMethod(BoxedCode::create((void*)threadCount, BOXED_INT, 0, "_count")));
thread_lock_cls = BoxedClass::create(type_cls, object_cls, 0, 0, sizeof(BoxedThreadLock), false, "lock", true, thread_lock_cls = BoxedClass::create(type_cls, object_cls, 0, 0, sizeof(BoxedThreadLock), false, "lock", true,
BoxedThreadLock::dealloc, NULL, false); BoxedThreadLock::dealloc, NULL, false);
thread_lock_cls->instances_are_nonzero = true; thread_lock_cls->instances_are_nonzero = true;
thread_lock_cls->giveAttr("__module__", boxString("thread")); thread_lock_cls->giveAttr("__module__", boxString("thread"));
thread_lock_cls->giveAttr( thread_lock_cls->giveAttr("acquire",
"acquire", new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::acquire, BOXED_BOOL, 2, false, false), new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::acquire, BOXED_BOOL, 2, false,
{ autoDecref(boxInt(1)) })); false, "thread_lock.acquire"),
thread_lock_cls->giveAttr("release", { autoDecref(boxInt(1)) }));
new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::release, NONE, 1))); thread_lock_cls->giveAttr("release", new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::release, NONE, 1,
"thread_lock.release")));
thread_lock_cls->giveAttrBorrowed("acquire_lock", thread_lock_cls->getattr(getStaticString("acquire"))); thread_lock_cls->giveAttrBorrowed("acquire_lock", thread_lock_cls->getattr(getStaticString("acquire")));
thread_lock_cls->giveAttrBorrowed("release_lock", thread_lock_cls->getattr(getStaticString("release"))); thread_lock_cls->giveAttrBorrowed("release_lock", thread_lock_cls->getattr(getStaticString("release")));
thread_lock_cls->giveAttrBorrowed("__enter__", thread_lock_cls->getattr(getStaticString("acquire"))); thread_lock_cls->giveAttrBorrowed("__enter__", thread_lock_cls->getattr(getStaticString("acquire")));
thread_lock_cls->giveAttr("__exit__", new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::exit, NONE, 4))); thread_lock_cls->giveAttr("__exit__", new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::exit, NONE, 4,
thread_lock_cls->giveAttr("locked", "thread_lock.__exit__")));
new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::locked, BOXED_BOOL, 1))); thread_lock_cls->giveAttr("locked", new BoxedFunction(BoxedCode::create((void*)BoxedThreadLock::locked, BOXED_BOOL,
1, "thread_lock.locked")));
thread_lock_cls->giveAttrBorrowed("locked_lock", thread_lock_cls->getattr(getStaticString("locked"))); thread_lock_cls->giveAttrBorrowed("locked_lock", thread_lock_cls->getattr(getStaticString("locked")));
thread_lock_cls->freeze(); thread_lock_cls->freeze();
......
src/runtime/capi.cpp
View file @ 798c4da8
...@@ -1769,10 +1769,11 @@ extern "C" int PyNumber_CoerceEx(PyObject** pv, PyObject** pw) noexcept { ...@@ -1769,10 +1769,11 @@ extern "C" int PyNumber_CoerceEx(PyObject** pv, PyObject** pw) noexcept {
} }
void setupCAPI() { void setupCAPI() {
capifunc_cls->giveAttr("__repr__", capifunc_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)BoxedCApiFunction::__repr__<CXX>,
new BoxedFunction(BoxedCode::create((void*)BoxedCApiFunction::__repr__<CXX>, UNKNOWN, 1))); UNKNOWN, 1, "capifunc.__repr__")));
auto capi_call = new BoxedFunction(BoxedCode::create((void*)BoxedCApiFunction::__call__, UNKNOWN, 1, true, true)); auto capi_call = new BoxedFunction(
BoxedCode::create((void*)BoxedCApiFunction::__call__, UNKNOWN, 1, true, true, "capifunc.__call__"));
capifunc_cls->giveAttr("__call__", capi_call); capifunc_cls->giveAttr("__call__", capi_call);
capifunc_cls->tpp_call.capi_val = BoxedCApiFunction::tppCall<CAPI>; capifunc_cls->tpp_call.capi_val = BoxedCApiFunction::tppCall<CAPI>;
capifunc_cls->tpp_call.cxx_val = BoxedCApiFunction::tppCall<CXX>; capifunc_cls->tpp_call.cxx_val = BoxedCApiFunction::tppCall<CXX>;
......
src/runtime/classobj.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/code.cpp
View file @ 798c4da8
...@@ -129,13 +129,15 @@ BoxedCode::BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, int fi ...@@ -129,13 +129,15 @@ BoxedCode::BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, int fi
internal_callable(NULL, NULL) { internal_callable(NULL, NULL) {
} }
BoxedCode::BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, const ParamNames& param_names) BoxedCode::BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, const char* name, const char* doc,
const ParamNames& param_names)
: source(nullptr), : source(nullptr),
// TODO what to do with these? // TODO what to do with this?
filename(nullptr), filename(nullptr),
name(nullptr), name(boxString(name)),
// TODO what to do with this?
firstlineno(-1), firstlineno(-1),
_doc(nullptr), _doc(doc[0] == '\0' ? incref(Py_None) : boxString(doc)),
param_names(param_names), param_names(param_names),
takes_varargs(takes_varargs), takes_varargs(takes_varargs),
......
src/runtime/complex.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/descr.cpp
View file @ 798c4da8
...@@ -593,15 +593,22 @@ void setupDescr() { ...@@ -593,15 +593,22 @@ void setupDescr() {
property_cls->instances_are_nonzero = true; property_cls->instances_are_nonzero = true;
property_cls->giveAttr( property_cls->giveAttr(
"__init__", new BoxedFunction(BoxedCode::create((void*)propertyInit, UNKNOWN, 5, false, false, "__init__",
ParamNames({ "", "fget", "fset", "fdel", "doc" }, "", "")), new BoxedFunction(BoxedCode::create((void*)propertyInit, UNKNOWN, 5, false, false, "property.__init__", "",
{ Py_None, Py_None, Py_None, NULL })); ParamNames({ "", "fget", "fset", "fdel", "doc" }, "", "")),
property_cls->giveAttr("__get__", new BoxedFunction(BoxedCode::create((void*)propertyGet, UNKNOWN, 3))); { Py_None, Py_None, Py_None, NULL }));
property_cls->giveAttr("__set__", new BoxedFunction(BoxedCode::create((void*)propertySet, UNKNOWN, 3))); property_cls->giveAttr("__get__",
property_cls->giveAttr("__delete__", new BoxedFunction(BoxedCode::create((void*)propertyDel, UNKNOWN, 2))); new BoxedFunction(BoxedCode::create((void*)propertyGet, UNKNOWN, 3, "property.__get__")));
property_cls->giveAttr("getter", new BoxedFunction(BoxedCode::create((void*)propertyGetter, UNKNOWN, 2))); property_cls->giveAttr("__set__",
property_cls->giveAttr("setter", new BoxedFunction(BoxedCode::create((void*)propertySetter, UNKNOWN, 2))); new BoxedFunction(BoxedCode::create((void*)propertySet, UNKNOWN, 3, "property.__set__")));
property_cls->giveAttr("deleter", new BoxedFunction(BoxedCode::create((void*)propertyDeleter, UNKNOWN, 2))); property_cls->giveAttr("__delete__",
new BoxedFunction(BoxedCode::create((void*)propertyDel, UNKNOWN, 2, "property.__delete__")));
property_cls->giveAttr("getter",
new BoxedFunction(BoxedCode::create((void*)propertyGetter, UNKNOWN, 2, "property.getter")));
property_cls->giveAttr("setter",
new BoxedFunction(BoxedCode::create((void*)propertySetter, UNKNOWN, 2, "property.setter")));
property_cls->giveAttr(
"deleter", new BoxedFunction(BoxedCode::create((void*)propertyDeleter, UNKNOWN, 2, "property.deleter")));
property_cls->giveAttrMember("fget", T_OBJECT, offsetof(BoxedProperty, prop_get)); property_cls->giveAttrMember("fget", T_OBJECT, offsetof(BoxedProperty, prop_get));
property_cls->giveAttrMember("fset", T_OBJECT, offsetof(BoxedProperty, prop_set)); property_cls->giveAttrMember("fset", T_OBJECT, offsetof(BoxedProperty, prop_set));
property_cls->giveAttrMember("fdel", T_OBJECT, offsetof(BoxedProperty, prop_del)); property_cls->giveAttrMember("fdel", T_OBJECT, offsetof(BoxedProperty, prop_del));
...@@ -609,20 +616,22 @@ void setupDescr() { ...@@ -609,20 +616,22 @@ void setupDescr() {
property_cls->freeze(); property_cls->freeze();
staticmethod_cls->giveAttrMember("__func__", T_OBJECT, offsetof(BoxedStaticmethod, sm_callable)); staticmethod_cls->giveAttrMember("__func__", T_OBJECT, offsetof(BoxedStaticmethod, sm_callable));
staticmethod_cls->giveAttr("__init__", staticmethod_cls->giveAttr("__init__", new BoxedFunction(BoxedCode::create((void*)staticmethodInit, UNKNOWN, 5,
new BoxedFunction(BoxedCode::create((void*)staticmethodInit, UNKNOWN, 5, false, false), false, false, "staticmethod.__init__"),
{ Py_None, Py_None, Py_None, Py_None })); { Py_None, Py_None, Py_None, Py_None }));
staticmethod_cls->giveAttr( staticmethod_cls->giveAttr("__get__", new BoxedFunction(BoxedCode::create((void*)staticmethodGet, UNKNOWN, 3, false,
"__get__", new BoxedFunction(BoxedCode::create((void*)staticmethodGet, UNKNOWN, 3, false, false), { Py_None })); false, "staticmethod.__get__"),
{ Py_None }));
staticmethod_cls->freeze(); staticmethod_cls->freeze();
classmethod_cls->giveAttrMember("__func__", T_OBJECT, offsetof(BoxedClassmethod, cm_callable)); classmethod_cls->giveAttrMember("__func__", T_OBJECT, offsetof(BoxedClassmethod, cm_callable));
classmethod_cls->giveAttr("__init__", classmethod_cls->giveAttr("__init__", new BoxedFunction(BoxedCode::create((void*)classmethodInit, UNKNOWN, 5, false,
new BoxedFunction(BoxedCode::create((void*)classmethodInit, UNKNOWN, 5, false, false), false, "classmethod.__init__"),
{ Py_None, Py_None, Py_None, Py_None })); { Py_None, Py_None, Py_None, Py_None }));
classmethod_cls->giveAttr( classmethod_cls->giveAttr("__get__", new BoxedFunction(BoxedCode::create((void*)classmethodGet, UNKNOWN, 3, false,
"__get__", new BoxedFunction(BoxedCode::create((void*)classmethodGet, UNKNOWN, 3, false, false), { Py_None })); false, "classmethod.__get__"),
{ Py_None }));
classmethod_cls->freeze(); classmethod_cls->freeze();
PyType_Ready(&PyGetSetDescr_Type); PyType_Ready(&PyGetSetDescr_Type);
......
src/runtime/dict.cpp
View file @ 798c4da8
...@@ -1137,72 +1137,88 @@ void setupDict() { ...@@ -1137,72 +1137,88 @@ void setupDict() {
dict_cls->tp_compare = (cmpfunc)dict_compare; dict_cls->tp_compare = (cmpfunc)dict_compare;
dict_cls->tp_richcompare = dict_richcompare; dict_cls->tp_richcompare = dict_richcompare;
dict_cls->giveAttr("__len__", new BoxedFunction(BoxedCode::create((void*)dictLen, BOXED_INT, 1))); dict_cls->giveAttr("__len__", new BoxedFunction(BoxedCode::create((void*)dictLen, BOXED_INT, 1, "dict.__len__")));
dict_cls->giveAttr("__new__", new BoxedFunction(BoxedCode::create((void*)dictNew, UNKNOWN, 1, true, true))); dict_cls->giveAttr("__new__",
dict_cls->giveAttr("__init__", new BoxedFunction(BoxedCode::create((void*)dictInit, NONE, 1, true, true))); new BoxedFunction(BoxedCode::create((void*)dictNew, UNKNOWN, 1, true, true, "dict.__new__")));
dict_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)dictRepr, STR, 1))); dict_cls->giveAttr("__init__",
new BoxedFunction(BoxedCode::create((void*)dictInit, NONE, 1, true, true, "dict.__init__")));
dict_cls->giveAttr("__eq__", new BoxedFunction(BoxedCode::create((void*)dictEq, UNKNOWN, 2))); dict_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)dictRepr, STR, 1, "dict.__repr__")));
dict_cls->giveAttr("__ne__", new BoxedFunction(BoxedCode::create((void*)dictNe, UNKNOWN, 2)));
dict_cls->giveAttr("__eq__", new BoxedFunction(BoxedCode::create((void*)dictEq, UNKNOWN, 2, "dict.__eq__")));
dict_cls->giveAttr("__ne__", new BoxedFunction(BoxedCode::create((void*)dictNe, UNKNOWN, 2, "dict.__ne__")));
dict_cls->giveAttr("__hash__", incref(Py_None)); dict_cls->giveAttr("__hash__", incref(Py_None));
dict_cls->giveAttr("__iter__", dict_cls->giveAttr("__iter__", new BoxedFunction(BoxedCode::create(
new BoxedFunction(BoxedCode::create((void*)dictIterKeys, typeFromClass(dictiterkey_cls), 1))); (void*)dictIterKeys, typeFromClass(dictiterkey_cls), 1, "dict.__iter__")));
dict_cls->giveAttr("update", new BoxedFunction(BoxedCode::create((void*)dictUpdate, NONE, 1, true, true))); dict_cls->giveAttr("update",
new BoxedFunction(BoxedCode::create((void*)dictUpdate, NONE, 1, true, true, "dict.update")));
dict_cls->giveAttr("clear", new BoxedFunction(BoxedCode::create((void*)dictClear, NONE, 1))); dict_cls->giveAttr("clear", new BoxedFunction(BoxedCode::create((void*)dictClear, NONE, 1, "dict.clear")));
dict_cls->giveAttr("copy", new BoxedFunction(BoxedCode::create((void*)dictCopy, DICT, 1))); dict_cls->giveAttr("copy", new BoxedFunction(BoxedCode::create((void*)dictCopy, DICT, 1, "dict.copy")));
dict_cls->giveAttr("has_key", new BoxedFunction(BoxedCode::create((void*)dictContains, BOXED_BOOL, 2))); dict_cls->giveAttr("has_key",
dict_cls->giveAttr("items", new BoxedFunction(BoxedCode::create((void*)dictItems, LIST, 1))); new BoxedFunction(BoxedCode::create((void*)dictContains, BOXED_BOOL, 2, "dict.has_key")));
dict_cls->giveAttr("iteritems", dict_cls->giveAttr("items", new BoxedFunction(BoxedCode::create((void*)dictItems, LIST, 1, "dict.items")));
new BoxedFunction(BoxedCode::create((void*)dictIterItems, typeFromClass(dictiteritem_cls), 1))); dict_cls->giveAttr("iteritems", new BoxedFunction(BoxedCode::create(
(void*)dictIterItems, typeFromClass(dictiteritem_cls), 1, "dict.iteritems")));
dict_cls->giveAttr("values", new BoxedFunction(BoxedCode::create((void*)dictValues, LIST, 1))); dict_cls->giveAttr("values", new BoxedFunction(BoxedCode::create((void*)dictValues, LIST, 1, "dict.values")));
dict_cls->giveAttr( dict_cls->giveAttr("itervalues",
"itervalues", new BoxedFunction(BoxedCode::create((void*)dictIterValues, typeFromClass(dictitervalue_cls), 1))); new BoxedFunction(BoxedCode::create((void*)dictIterValues, typeFromClass(dictitervalue_cls), 1,
"dict.itervalues")));
dict_cls->giveAttr("keys", new BoxedFunction(BoxedCode::create((void*)dictKeys, LIST, 1))); dict_cls->giveAttr("keys", new BoxedFunction(BoxedCode::create((void*)dictKeys, LIST, 1, "dict.keys")));
dict_cls->giveAttrBorrowed("iterkeys", dict_cls->getattr(autoDecref(internStringMortal("__iter__")))); dict_cls->giveAttrBorrowed("iterkeys", dict_cls->getattr(autoDecref(internStringMortal("__iter__"))));
dict_cls->giveAttr("pop", new BoxedFunction(BoxedCode::create((void*)dictPop, UNKNOWN, 3, false, false), { NULL })); dict_cls->giveAttr(
dict_cls->giveAttr("popitem", new BoxedFunction(BoxedCode::create((void*)dictPopitem, BOXED_TUPLE, 1))); "pop", new BoxedFunction(BoxedCode::create((void*)dictPop, UNKNOWN, 3, false, false, "dict.pop"), { NULL }));
dict_cls->giveAttr("popitem",
new BoxedFunction(BoxedCode::create((void*)dictPopitem, BOXED_TUPLE, 1, "dict.popitem")));
auto* fromkeys_func = new BoxedFunction(BoxedCode::create((void*)dictFromkeys, DICT, 3, false, false), { Py_None }); auto* fromkeys_func = new BoxedFunction(
BoxedCode::create((void*)dictFromkeys, DICT, 3, false, false, "dict.fromkeys"), { Py_None });
dict_cls->giveAttr("fromkeys", boxInstanceMethod(dict_cls, fromkeys_func, dict_cls)); dict_cls->giveAttr("fromkeys", boxInstanceMethod(dict_cls, fromkeys_func, dict_cls));
Py_DECREF(fromkeys_func); Py_DECREF(fromkeys_func);
dict_cls->giveAttr("viewkeys", new BoxedFunction(BoxedCode::create((void*)dictViewKeys, UNKNOWN, 1))); dict_cls->giveAttr("viewkeys",
dict_cls->giveAttr("viewvalues", new BoxedFunction(BoxedCode::create((void*)dictViewValues, UNKNOWN, 1))); new BoxedFunction(BoxedCode::create((void*)dictViewKeys, UNKNOWN, 1, "dict.viewkeys")));
dict_cls->giveAttr("viewitems", new BoxedFunction(BoxedCode::create((void*)dictViewItems, UNKNOWN, 1))); dict_cls->giveAttr("viewvalues",
new BoxedFunction(BoxedCode::create((void*)dictViewValues, UNKNOWN, 1, "dict.viewvalues")));
dict_cls->giveAttr("get", dict_cls->giveAttr("viewitems",
new BoxedFunction(BoxedCode::create((void*)dictGet, UNKNOWN, 3, false, false), { Py_None })); new BoxedFunction(BoxedCode::create((void*)dictViewItems, UNKNOWN, 1, "dict.viewitems")));
dict_cls->giveAttr( dict_cls->giveAttr(
"setdefault", "get", new BoxedFunction(BoxedCode::create((void*)dictGet, UNKNOWN, 3, false, false, "dict.get"), { Py_None }));
new BoxedFunction(BoxedCode::create((void*)dictSetdefault, UNKNOWN, 3, false, false), { Py_None }));
dict_cls->giveAttr("setdefault", new BoxedFunction(BoxedCode::create((void*)dictSetdefault, UNKNOWN, 3, false,
false, "dict.setdefault"),
{ Py_None }));
auto dict_getitem = BoxedCode::create((void*)dictGetitem<CXX>, UNKNOWN, 2, ParamNames::empty(), CXX); auto dict_getitem
= BoxedCode::create((void*)dictGetitem<CXX>, UNKNOWN, 2, "dict.__getitem__", "", ParamNames::empty(), CXX);
dict_getitem->addVersion((void*)dictGetitem<CAPI>, UNKNOWN, CAPI); dict_getitem->addVersion((void*)dictGetitem<CAPI>, UNKNOWN, CAPI);
dict_cls->giveAttr("__getitem__", new BoxedFunction(dict_getitem)); dict_cls->giveAttr("__getitem__", new BoxedFunction(dict_getitem));
dict_cls->giveAttr("__setitem__", new BoxedFunction(BoxedCode::create((void*)dictSetitem, NONE, 3))); dict_cls->giveAttr("__setitem__",
dict_cls->giveAttr("__delitem__", new BoxedFunction(BoxedCode::create((void*)dictDelitem, UNKNOWN, 2))); new BoxedFunction(BoxedCode::create((void*)dictSetitem, NONE, 3, "dict.__setitem__")));
dict_cls->giveAttr("__contains__", new BoxedFunction(BoxedCode::create((void*)dictContains, BOXED_BOOL, 2))); dict_cls->giveAttr("__delitem__",
new BoxedFunction(BoxedCode::create((void*)dictDelitem, UNKNOWN, 2, "dict.__delitem__")));
dict_cls->giveAttr("__contains__",
new BoxedFunction(BoxedCode::create((void*)dictContains, BOXED_BOOL, 2, "dict.__contains__")));
dict_cls->giveAttr("__nonzero__", new BoxedFunction(BoxedCode::create((void*)dictNonzero, BOXED_BOOL, 1))); dict_cls->giveAttr("__nonzero__",
new BoxedFunction(BoxedCode::create((void*)dictNonzero, BOXED_BOOL, 1, "dict.__nonzero__")));
add_operators(dict_cls); add_operators(dict_cls);
dict_cls->freeze(); dict_cls->freeze();
// create the dictonary iterator types // create the dictonary iterator types
for (BoxedClass* iter_type : { dictiterkey_cls, dictitervalue_cls, dictiteritem_cls }) { for (BoxedClass* iter_type : { dictiterkey_cls, dictitervalue_cls, dictiteritem_cls }) {
BoxedCode* hasnext = BoxedCode::create((void*)dictIterHasnextUnboxed, BOOL, 1); BoxedCode* hasnext = BoxedCode::create((void*)dictIterHasnextUnboxed, BOOL, 1, "dict.__hasnext__");
hasnext->addVersion((void*)dictIterHasnext, BOXED_BOOL); hasnext->addVersion((void*)dictIterHasnext, BOXED_BOOL);
iter_type->giveAttr("__hasnext__", new BoxedFunction(hasnext)); iter_type->giveAttr("__hasnext__", new BoxedFunction(hasnext));
iter_type->giveAttr("__iter__", iter_type->giveAttr("__iter__", new BoxedFunction(BoxedCode::create((void*)dictIterIter,
new BoxedFunction(BoxedCode::create((void*)dictIterIter, typeFromClass(iter_type), 1))); typeFromClass(iter_type), 1, "__iter__")));
iter_type->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)dictIterNext, UNKNOWN, 1))); iter_type->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)dictIterNext, UNKNOWN, 1, "next")));
iter_type->freeze(); iter_type->freeze();
iter_type->tp_iter = PyObject_SelfIter; iter_type->tp_iter = PyObject_SelfIter;
iter_type->tp_iternext = dictiter_next; iter_type->tp_iternext = dictiter_next;
......
src/runtime/float.cpp
View file @ 798c4da8
...@@ -877,7 +877,7 @@ static void _addFunc(const char* name, ConcreteCompilerType* rtn_type, void* flo ...@@ -877,7 +877,7 @@ static void _addFunc(const char* name, ConcreteCompilerType* rtn_type, void* flo
v_uu.push_back(UNKNOWN); v_uu.push_back(UNKNOWN);
v_uu.push_back(UNKNOWN); v_uu.push_back(UNKNOWN);
BoxedCode* code = new BoxedCode(2, false, false); BoxedCode* code = new BoxedCode(2, false, false, name);
code->addVersion(float_func, rtn_type, v_ff); code->addVersion(float_func, rtn_type, v_ff);
code->addVersion(int_func, rtn_type, v_fi); code->addVersion(int_func, rtn_type, v_fi);
code->addVersion(boxed_func, UNKNOWN, v_uu); code->addVersion(boxed_func, UNKNOWN, v_uu);
...@@ -890,7 +890,7 @@ static void _addFuncPow(const char* name, ConcreteCompilerType* rtn_type, void* ...@@ -890,7 +890,7 @@ static void _addFuncPow(const char* name, ConcreteCompilerType* rtn_type, void*
std::vector<ConcreteCompilerType*> v_fiu{ BOXED_FLOAT, BOXED_INT, UNKNOWN }; std::vector<ConcreteCompilerType*> v_fiu{ BOXED_FLOAT, BOXED_INT, UNKNOWN };
std::vector<ConcreteCompilerType*> v_fuu{ BOXED_FLOAT, UNKNOWN, UNKNOWN }; std::vector<ConcreteCompilerType*> v_fuu{ BOXED_FLOAT, UNKNOWN, UNKNOWN };
BoxedCode* code = new BoxedCode(3, false, false); BoxedCode* code = new BoxedCode(3, false, false, name);
code->addVersion(float_func, rtn_type, v_ffu); code->addVersion(float_func, rtn_type, v_ffu);
code->addVersion(int_func, rtn_type, v_fiu); code->addVersion(int_func, rtn_type, v_fiu);
code->addVersion(boxed_func, UNKNOWN, v_fuu); code->addVersion(boxed_func, UNKNOWN, v_fuu);
...@@ -949,8 +949,9 @@ void setupFloat() { ...@@ -949,8 +949,9 @@ void setupFloat() {
static PyNumberMethods float_as_number; static PyNumberMethods float_as_number;
float_cls->tp_as_number = &float_as_number; float_cls->tp_as_number = &float_as_number;
float_cls->giveAttr("__getnewargs__", new BoxedFunction(BoxedCode::create((void*)float_getnewargs, UNKNOWN, 1, float_cls->giveAttr("__getnewargs__",
ParamNames::empty(), CAPI))); new BoxedFunction(BoxedCode::create((void*)float_getnewargs, UNKNOWN, 1, "float.__getnewargs__",
"", ParamNames::empty(), CAPI)));
_addFunc("__add__", BOXED_FLOAT, (void*)floatAddFloat, (void*)floatAddInt, (void*)floatAdd); _addFunc("__add__", BOXED_FLOAT, (void*)floatAddFloat, (void*)floatAddInt, (void*)floatAdd);
float_cls->giveAttrBorrowed("__radd__", float_cls->getattr(autoDecref(internStringMortal("__add__")))); float_cls->giveAttrBorrowed("__radd__", float_cls->getattr(autoDecref(internStringMortal("__add__"))));
...@@ -958,9 +959,11 @@ void setupFloat() { ...@@ -958,9 +959,11 @@ void setupFloat() {
_addFunc("__div__", BOXED_FLOAT, (void*)floatDivFloat, (void*)floatDivInt, (void*)floatDiv); _addFunc("__div__", BOXED_FLOAT, (void*)floatDivFloat, (void*)floatDivInt, (void*)floatDiv);
_addFunc("__rdiv__", BOXED_FLOAT, (void*)floatRDivFloat, (void*)floatRDivInt, (void*)floatRDiv); _addFunc("__rdiv__", BOXED_FLOAT, (void*)floatRDivFloat, (void*)floatRDivInt, (void*)floatRDiv);
_addFunc("__floordiv__", BOXED_FLOAT, (void*)floatFloorDivFloat, (void*)floatFloorDivInt, (void*)floatFloorDiv); _addFunc("__floordiv__", BOXED_FLOAT, (void*)floatFloorDivFloat, (void*)floatFloorDivInt, (void*)floatFloorDiv);
float_cls->giveAttr("__rfloordiv__", new BoxedFunction(BoxedCode::create((void*)floatRFloorDiv, UNKNOWN, 2))); float_cls->giveAttr("__rfloordiv__",
new BoxedFunction(BoxedCode::create((void*)floatRFloorDiv, UNKNOWN, 2, "float.__rfloordiv__")));
_addFunc("__truediv__", BOXED_FLOAT, (void*)floatDivFloat, (void*)floatDivInt, (void*)floatTruediv); _addFunc("__truediv__", BOXED_FLOAT, (void*)floatDivFloat, (void*)floatDivInt, (void*)floatTruediv);
float_cls->giveAttr("__rtruediv__", new BoxedFunction(BoxedCode::create((void*)floatRTruediv, UNKNOWN, 2))); float_cls->giveAttr("__rtruediv__",
new BoxedFunction(BoxedCode::create((void*)floatRTruediv, UNKNOWN, 2, "float.__rtruediv__")));
_addFunc("__mod__", BOXED_FLOAT, (void*)floatModFloat, (void*)floatModInt, (void*)floatMod); _addFunc("__mod__", BOXED_FLOAT, (void*)floatModFloat, (void*)floatModInt, (void*)floatMod);
_addFunc("__rmod__", BOXED_FLOAT, (void*)floatRModFloat, (void*)floatRModInt, (void*)floatRMod); _addFunc("__rmod__", BOXED_FLOAT, (void*)floatRModFloat, (void*)floatRModInt, (void*)floatRMod);
...@@ -968,46 +971,60 @@ void setupFloat() { ...@@ -968,46 +971,60 @@ void setupFloat() {
float_cls->giveAttrBorrowed("__rmul__", float_cls->getattr(autoDecref(internStringMortal("__mul__")))); float_cls->giveAttrBorrowed("__rmul__", float_cls->getattr(autoDecref(internStringMortal("__mul__"))));
_addFuncPow("__pow__", BOXED_FLOAT, (void*)floatPowFloat, (void*)floatPowInt, (void*)floatPow); _addFuncPow("__pow__", BOXED_FLOAT, (void*)floatPowFloat, (void*)floatPowInt, (void*)floatPow);
float_cls->giveAttr("__rpow__", new BoxedFunction(BoxedCode::create((void*)floatRPow, UNKNOWN, 2))); float_cls->giveAttr("__rpow__",
new BoxedFunction(BoxedCode::create((void*)floatRPow, UNKNOWN, 2, "float.__rpow__")));
_addFunc("__sub__", BOXED_FLOAT, (void*)floatSubFloat, (void*)floatSubInt, (void*)floatSub); _addFunc("__sub__", BOXED_FLOAT, (void*)floatSubFloat, (void*)floatSubInt, (void*)floatSub);
_addFunc("__rsub__", BOXED_FLOAT, (void*)floatRSubFloat, (void*)floatRSubInt, (void*)floatRSub); _addFunc("__rsub__", BOXED_FLOAT, (void*)floatRSubFloat, (void*)floatRSubInt, (void*)floatRSub);
float_cls->giveAttr("__divmod__", new BoxedFunction(BoxedCode::create((void*)floatDivmod, UNKNOWN, 2))); float_cls->giveAttr("__divmod__",
float_cls->giveAttr("__rdivmod__", new BoxedFunction(BoxedCode::create((void*)floatRDivmod, UNKNOWN, 2))); new BoxedFunction(BoxedCode::create((void*)floatDivmod, UNKNOWN, 2, "float.__divmod__")));
float_cls->giveAttr("__rdivmod__",
new BoxedFunction(BoxedCode::create((void*)floatRDivmod, UNKNOWN, 2, "float.__rdivmod__")));
auto float_new auto float_new = BoxedCode::create((void*)floatNew<CXX>, UNKNOWN, 2, false, false, "float.__new__", "",
= BoxedCode::create((void*)floatNew<CXX>, UNKNOWN, 2, false, false, ParamNames({ "", "x" }, "", ""), CXX); ParamNames({ "", "x" }, "", ""), CXX);
float_new->addVersion((void*)floatNew<CAPI>, UNKNOWN, CAPI); float_new->addVersion((void*)floatNew<CAPI>, UNKNOWN, CAPI);
float_cls->giveAttr("__new__", new BoxedFunction(float_new, { autoDecref(boxFloat(0.0)) })); float_cls->giveAttr("__new__", new BoxedFunction(float_new, { autoDecref(boxFloat(0.0)) }));
float_cls->giveAttr("__eq__", new BoxedFunction(BoxedCode::create((void*)floatEq, UNKNOWN, 2))); float_cls->giveAttr("__eq__", new BoxedFunction(BoxedCode::create((void*)floatEq, UNKNOWN, 2, "float.__eq__")));
float_cls->giveAttr("__ne__", new BoxedFunction(BoxedCode::create((void*)floatNe, UNKNOWN, 2))); float_cls->giveAttr("__ne__", new BoxedFunction(BoxedCode::create((void*)floatNe, UNKNOWN, 2, "float.__ne__")));
float_cls->giveAttr("__le__", new BoxedFunction(BoxedCode::create((void*)floatLe, UNKNOWN, 2))); float_cls->giveAttr("__le__", new BoxedFunction(BoxedCode::create((void*)floatLe, UNKNOWN, 2, "float.__le__")));
float_cls->giveAttr("__lt__", new BoxedFunction(BoxedCode::create((void*)floatLt, UNKNOWN, 2))); float_cls->giveAttr("__lt__", new BoxedFunction(BoxedCode::create((void*)floatLt, UNKNOWN, 2, "float.__lt__")));
float_cls->giveAttr("__ge__", new BoxedFunction(BoxedCode::create((void*)floatGe, UNKNOWN, 2))); float_cls->giveAttr("__ge__", new BoxedFunction(BoxedCode::create((void*)floatGe, UNKNOWN, 2, "float.__ge__")));
float_cls->giveAttr("__gt__", new BoxedFunction(BoxedCode::create((void*)floatGt, UNKNOWN, 2))); float_cls->giveAttr("__gt__", new BoxedFunction(BoxedCode::create((void*)floatGt, UNKNOWN, 2, "float.__gt__")));
float_cls->giveAttr("__neg__", new BoxedFunction(BoxedCode::create((void*)floatNeg, BOXED_FLOAT, 1))); float_cls->giveAttr("__neg__",
float_cls->giveAttr("__pos__", new BoxedFunction(BoxedCode::create((void*)floatPos, BOXED_FLOAT, 1))); new BoxedFunction(BoxedCode::create((void*)floatNeg, BOXED_FLOAT, 1, "float.__neg__")));
float_cls->giveAttr("__abs__", new BoxedFunction(BoxedCode::create((void*)floatAbs, BOXED_FLOAT, 1))); float_cls->giveAttr("__pos__",
new BoxedFunction(BoxedCode::create((void*)floatPos, BOXED_FLOAT, 1, "float.__pos__")));
BoxedCode* nonzero = BoxedCode::create((void*)floatNonzeroUnboxed, BOOL, 1); float_cls->giveAttr("__abs__",
new BoxedFunction(BoxedCode::create((void*)floatAbs, BOXED_FLOAT, 1, "float.__abs__")));
BoxedCode* nonzero = BoxedCode::create((void*)floatNonzeroUnboxed, BOOL, 1, "float.__nonzero__");
nonzero->addVersion((void*)floatNonzero, UNKNOWN); nonzero->addVersion((void*)floatNonzero, UNKNOWN);
float_cls->giveAttr("__nonzero__", new BoxedFunction(nonzero)); float_cls->giveAttr("__nonzero__", new BoxedFunction(nonzero));
// float_cls->giveAttr("__nonzero__", new BoxedFunction(BoxedCode::create((void*)floatNonzero, NULL, 1))); // float_cls->giveAttr("__nonzero__", new BoxedFunction(BoxedCode::create((void*)floatNonzero, NULL, 1,
float_cls->giveAttr("__float__", new BoxedFunction(BoxedCode::create((void*)floatFloat, BOXED_FLOAT, 1))); // "float.__nonzero__")));
float_cls->giveAttr("__str__", new BoxedFunction(BoxedCode::create((void*)floatStr<CXX>, STR, 1))); float_cls->giveAttr("__float__",
float_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)floatRepr<CXX>, STR, 1))); new BoxedFunction(BoxedCode::create((void*)floatFloat, BOXED_FLOAT, 1, "float.__float__")));
float_cls->giveAttr("__coerce__", new BoxedFunction(BoxedCode::create((void*)floatCoerce, UNKNOWN, 2))); float_cls->giveAttr("__str__", new BoxedFunction(BoxedCode::create((void*)floatStr<CXX>, STR, 1, "float.__str__")));
float_cls->giveAttr("__repr__",
float_cls->giveAttr("__trunc__", new BoxedFunction(BoxedCode::create((void*)floatTrunc, UNKNOWN, 1))); new BoxedFunction(BoxedCode::create((void*)floatRepr<CXX>, STR, 1, "float.__repr__")));
float_cls->giveAttr("__int__", new BoxedFunction(BoxedCode::create((void*)floatInt, UNKNOWN, 1))); float_cls->giveAttr("__coerce__",
float_cls->giveAttr("__long__", new BoxedFunction(BoxedCode::create((void*)floatLong, UNKNOWN, 1))); new BoxedFunction(BoxedCode::create((void*)floatCoerce, UNKNOWN, 2, "float.__coerce__")));
float_cls->giveAttr("__hash__", new BoxedFunction(BoxedCode::create((void*)floatHash, BOXED_INT, 1)));
float_cls->giveAttr("__trunc__",
new BoxedFunction(BoxedCode::create((void*)floatTrunc, UNKNOWN, 1, "float.__trunc__")));
float_cls->giveAttr("__int__", new BoxedFunction(BoxedCode::create((void*)floatInt, UNKNOWN, 1, "float.__int__")));
float_cls->giveAttr("__long__",
new BoxedFunction(BoxedCode::create((void*)floatLong, UNKNOWN, 1, "float.__long__")));
float_cls->giveAttr("__hash__",
new BoxedFunction(BoxedCode::create((void*)floatHash, BOXED_INT, 1, "float.__hash__")));
float_cls->giveAttrDescriptor("real", float_conjugate, NULL); float_cls->giveAttrDescriptor("real", float_conjugate, NULL);
float_cls->giveAttrDescriptor("imag", float0, NULL); float_cls->giveAttrDescriptor("imag", float0, NULL);
float_cls->giveAttr("conjugate", new BoxedFunction(BoxedCode::create((void*)float_conjugate, BOXED_FLOAT, 1, float_cls->giveAttr("conjugate",
ParamNames::empty(), CAPI))); new BoxedFunction(BoxedCode::create((void*)float_conjugate, BOXED_FLOAT, 1, "float.conjugate",
"", ParamNames::empty(), CAPI)));
float_cls->giveAttr("__doc__", boxString("float(x) -> floating point number\n" float_cls->giveAttr("__doc__", boxString("float(x) -> floating point number\n"
"\n" "\n"
......
src/runtime/generator.cpp
View file @ 798c4da8
...@@ -715,26 +715,28 @@ void setupGenerator() { ...@@ -715,26 +715,28 @@ void setupGenerator() {
generator_cls = BoxedClass::create(type_cls, object_cls, 0, offsetof(BoxedGenerator, weakreflist), generator_cls = BoxedClass::create(type_cls, object_cls, 0, offsetof(BoxedGenerator, weakreflist),
sizeof(BoxedGenerator), false, "generator", false, (destructor)generator_dealloc, sizeof(BoxedGenerator), false, "generator", false, (destructor)generator_dealloc,
NULL, true, (traverseproc)generator_traverse, NOCLEAR); NULL, true, (traverseproc)generator_traverse, NOCLEAR);
generator_cls->giveAttr( generator_cls->giveAttr("__iter__",
"__iter__", new BoxedFunction(BoxedCode::create((void*)generatorIter, typeFromClass(generator_cls), 1))); new BoxedFunction(BoxedCode::create((void*)generatorIter, typeFromClass(generator_cls), 1,
"generator.__iter__")));
auto generator_close = BoxedCode::create((void*)generatorClose<CXX>, UNKNOWN, 1); auto generator_close = BoxedCode::create((void*)generatorClose<CXX>, UNKNOWN, 1, "generator.close");
generator_close->addVersion((void*)generatorClose<CAPI>, UNKNOWN, CAPI); generator_close->addVersion((void*)generatorClose<CAPI>, UNKNOWN, CAPI);
generator_cls->giveAttr("close", new BoxedFunction(generator_close)); generator_cls->giveAttr("close", new BoxedFunction(generator_close));
auto generator_next = BoxedCode::create((void*)generatorNext<CXX>, UNKNOWN, 1, ParamNames::empty(), CXX); auto generator_next
= BoxedCode::create((void*)generatorNext<CXX>, UNKNOWN, 1, "generatro.next", "", ParamNames::empty(), CXX);
generator_next->addVersion((void*)generatorNext<CAPI>, UNKNOWN, CAPI); generator_next->addVersion((void*)generatorNext<CAPI>, UNKNOWN, CAPI);
generator_cls->giveAttr("next", new BoxedFunction(generator_next)); generator_cls->giveAttr("next", new BoxedFunction(generator_next));
BoxedCode* hasnext = BoxedCode::create((void*)generatorHasnextUnboxed, BOOL, 1); BoxedCode* hasnext = BoxedCode::create((void*)generatorHasnextUnboxed, BOOL, 1, "generator.__hasnext__");
hasnext->addVersion((void*)generatorHasnext, BOXED_BOOL); hasnext->addVersion((void*)generatorHasnext, BOXED_BOOL);
generator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext)); generator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext));
auto generator_send = BoxedCode::create((void*)generatorSend<CXX>, UNKNOWN, 2); auto generator_send = BoxedCode::create((void*)generatorSend<CXX>, UNKNOWN, 2, "generator.send");
generator_send->addVersion((void*)generatorSend<CAPI>, UNKNOWN, CAPI); generator_send->addVersion((void*)generatorSend<CAPI>, UNKNOWN, CAPI);
generator_cls->giveAttr("send", new BoxedFunction(generator_send)); generator_cls->giveAttr("send", new BoxedFunction(generator_send));
auto generator_throw = BoxedCode::create((void*)generatorThrow<CXX>, UNKNOWN, 4, false, false); auto generator_throw = BoxedCode::create((void*)generatorThrow<CXX>, UNKNOWN, 4, false, false, "generator.throw");
generator_throw->addVersion((void*)generatorThrow<CAPI>, UNKNOWN, CAPI); generator_throw->addVersion((void*)generatorThrow<CAPI>, UNKNOWN, CAPI);
generator_cls->giveAttr("throw", new BoxedFunction(generator_throw, { NULL, NULL })); generator_cls->giveAttr("throw", new BoxedFunction(generator_throw, { NULL, NULL }));
......
src/runtime/inline/xrange.cpp
View file @ 798c4da8
...@@ -267,27 +267,35 @@ void setupXrange() { ...@@ -267,27 +267,35 @@ void setupXrange() {
static PySequenceMethods xrange_as_sequence; static PySequenceMethods xrange_as_sequence;
xrange_cls->tp_as_sequence = &xrange_as_sequence; xrange_cls->tp_as_sequence = &xrange_as_sequence;
xrange_cls->giveAttr("__new__", xrange_cls->giveAttr("__new__", new BoxedFunction(BoxedCode::create((void*)xrange, typeFromClass(xrange_cls), 4,
new BoxedFunction(BoxedCode::create((void*)xrange, typeFromClass(xrange_cls), 4, false, false), false, false, "xrange.__new__"),
{ NULL, NULL })); { NULL, NULL }));
xrange_cls->giveAttr( xrange_cls->giveAttr("__iter__", new BoxedFunction(BoxedCode::create(
"__iter__", new BoxedFunction(BoxedCode::create((void*)xrangeIter, typeFromClass(xrange_iterator_cls), 1))); (void*)xrangeIter, typeFromClass(xrange_iterator_cls), 1, "xrange.__iter__")));
xrange_cls->giveAttr("__reversed__", new BoxedFunction(BoxedCode::create((void*)xrangeReversed, xrange_cls->giveAttr("__reversed__",
typeFromClass(xrange_iterator_cls), 1))); new BoxedFunction(BoxedCode::create((void*)xrangeReversed, typeFromClass(xrange_iterator_cls),
1, "xrange.__reversed__")));
xrange_cls->giveAttr("__getitem__", new BoxedFunction(BoxedCode::create((void*)xrangeGetitem, BOXED_INT, 2))); xrange_cls->giveAttr(
"__getitem__", new BoxedFunction(BoxedCode::create((void*)xrangeGetitem, BOXED_INT, 2, "xrange.__getitem__")));
xrange_cls->giveAttr("__len__", new BoxedFunction(BoxedCode::create((void*)xrangeLen, BOXED_INT, 1))); xrange_cls->giveAttr("__len__",
xrange_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)xrangeRepr, STR, 1))); new BoxedFunction(BoxedCode::create((void*)xrangeLen, BOXED_INT, 1, "xrange.__len__")));
xrange_cls->giveAttr("__reduce__", new BoxedFunction(BoxedCode::create((void*)xrangeReduce, BOXED_TUPLE, 1))); xrange_cls->giveAttr("__repr__",
new BoxedFunction(BoxedCode::create((void*)xrangeRepr, STR, 1, "xrange.__repr__")));
xrange_cls->giveAttr(
"__reduce__", new BoxedFunction(BoxedCode::create((void*)xrangeReduce, BOXED_TUPLE, 1, "xrange.__reduce__")));
BoxedCode* hasnext = BoxedCode::create((void*)BoxedXrangeIterator::xrangeIteratorHasnextUnboxed, BOOL, 1); BoxedCode* hasnext
= BoxedCode::create((void*)BoxedXrangeIterator::xrangeIteratorHasnextUnboxed, BOOL, 1, "xrange.__hasnext__");
hasnext->addVersion((void*)BoxedXrangeIterator::xrangeIteratorHasnext, BOXED_BOOL); hasnext->addVersion((void*)BoxedXrangeIterator::xrangeIteratorHasnext, BOXED_BOOL);
xrange_iterator_cls->giveAttr( xrange_iterator_cls->giveAttr(
"__iter__", new BoxedFunction(BoxedCode::create((void*)xrangeIterIter, typeFromClass(xrange_iterator_cls), 1))); "__iter__", new BoxedFunction(BoxedCode::create((void*)xrangeIterIter, typeFromClass(xrange_iterator_cls), 1,
"xrange.__iter__")));
xrange_iterator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext)); xrange_iterator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext));
BoxedCode* next = BoxedCode::create((void*)BoxedXrangeIterator::xrangeIteratorNextUnboxed, UNBOXED_INT, 1); BoxedCode* next
= BoxedCode::create((void*)BoxedXrangeIterator::xrangeIteratorNextUnboxed, UNBOXED_INT, 1, "xrange.next");
next->addVersion((void*)BoxedXrangeIterator::xrangeIteratorNext, BOXED_INT); next->addVersion((void*)BoxedXrangeIterator::xrangeIteratorNext, BOXED_INT);
xrange_iterator_cls->giveAttr("next", new BoxedFunction(next)); xrange_iterator_cls->giveAttr("next", new BoxedFunction(next));
......
src/runtime/int.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/iterobject.cpp
View file @ 798c4da8
...@@ -210,11 +210,12 @@ void setupIter() { ...@@ -210,11 +210,12 @@ void setupIter() {
(destructor)BoxedSeqIter::dealloc, NULL, true, (destructor)BoxedSeqIter::dealloc, NULL, true,
(traverseproc)BoxedSeqIter::traverse, NOCLEAR); (traverseproc)BoxedSeqIter::traverse, NOCLEAR);
seqiter_cls->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)seqiterNext, UNKNOWN, 1))); seqiter_cls->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)seqiterNext, UNKNOWN, 1, "seqiter.next")));
BoxedCode* hasnext = BoxedCode::create((void*)seqiterHasnextUnboxed, BOOL, 1); BoxedCode* hasnext = BoxedCode::create((void*)seqiterHasnextUnboxed, BOOL, 1, "seqiter.__hasnext__");
hasnext->addVersion((void*)seqiterHasnext, BOXED_BOOL); hasnext->addVersion((void*)seqiterHasnext, BOXED_BOOL);
seqiter_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext)); seqiter_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext));
seqiter_cls->giveAttr("__iter__", new BoxedFunction(BoxedCode::create((void*)seqiterIter, UNKNOWN, 1))); seqiter_cls->giveAttr("__iter__",
new BoxedFunction(BoxedCode::create((void*)seqiterIter, UNKNOWN, 1, "seqiter.__iter__")));
seqiter_cls->freeze(); seqiter_cls->freeze();
seqiter_cls->tpp_hasnext = seqiterHasnextUnboxed; seqiter_cls->tpp_hasnext = seqiterHasnextUnboxed;
...@@ -225,10 +226,12 @@ void setupIter() { ...@@ -225,10 +226,12 @@ void setupIter() {
(destructor)BoxedSeqIter::dealloc, NULL, true, (destructor)BoxedSeqIter::dealloc, NULL, true,
(traverseproc)BoxedSeqIter::traverse, NOCLEAR); (traverseproc)BoxedSeqIter::traverse, NOCLEAR);
seqreviter_cls->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)seqiterNext, UNKNOWN, 1))); seqreviter_cls->giveAttr("next",
seqreviter_cls->giveAttr("__hasnext__", new BoxedFunction(BoxedCode::create((void*)seqiterNext, UNKNOWN, 1, "seqreviter.next")));
new BoxedFunction(BoxedCode::create((void*)seqreviterHasnext, BOXED_BOOL, 1))); seqreviter_cls->giveAttr("__hasnext__", new BoxedFunction(BoxedCode::create((void*)seqreviterHasnext, BOXED_BOOL, 1,
seqreviter_cls->giveAttr("__iter__", new BoxedFunction(BoxedCode::create((void*)seqiterIter, UNKNOWN, 1))); "seqreviter.__hasnext__")));
seqreviter_cls->giveAttr(
"__iter__", new BoxedFunction(BoxedCode::create((void*)seqiterIter, UNKNOWN, 1, "seqreviter.__iter__")));
seqreviter_cls->freeze(); seqreviter_cls->freeze();
seqreviter_cls->tp_iter = PyObject_SelfIter; seqreviter_cls->tp_iter = PyObject_SelfIter;
...@@ -238,9 +241,10 @@ void setupIter() { ...@@ -238,9 +241,10 @@ void setupIter() {
false, (destructor)BoxedIterWrapper::dealloc, NULL, true, false, (destructor)BoxedIterWrapper::dealloc, NULL, true,
(traverseproc)BoxedIterWrapper::traverse, NOCLEAR); (traverseproc)BoxedIterWrapper::traverse, NOCLEAR);
iterwrapper_cls->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)iterwrapperNext, UNKNOWN, 1))); iterwrapper_cls->giveAttr(
iterwrapper_cls->giveAttr("__hasnext__", "next", new BoxedFunction(BoxedCode::create((void*)iterwrapperNext, UNKNOWN, 1, "iterwrapper.next")));
new BoxedFunction(BoxedCode::create((void*)iterwrapperHasnext, BOXED_BOOL, 1))); iterwrapper_cls->giveAttr("__hasnext__", new BoxedFunction(BoxedCode::create((void*)iterwrapperHasnext, BOXED_BOOL,
1, "iterwrapper.__hasnext__")));
iterwrapper_cls->freeze(); iterwrapper_cls->freeze();
iterwrapper_cls->tpp_hasnext = iterwrapperHasnextUnboxed; iterwrapper_cls->tpp_hasnext = iterwrapperHasnextUnboxed;
......
src/runtime/list.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/long.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/set.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/str.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/super.cpp
View file @ 798c4da8
...@@ -254,11 +254,13 @@ void setupSuper() { ...@@ -254,11 +254,13 @@ void setupSuper() {
// super_cls->giveAttr("__getattribute__", new BoxedFunction(BoxedCode::create((void*)superGetattribute, // super_cls->giveAttr("__getattribute__", new BoxedFunction(BoxedCode::create((void*)superGetattribute,
// UNKNOWN, 2))); // UNKNOWN, 2)));
super_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)superRepr, STR, 1))); super_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)superRepr, STR, 1, "super.__repr__")));
super_cls->giveAttr("__init__", super_cls->giveAttr(
new BoxedFunction(BoxedCode::create((void*)superInit, UNKNOWN, 3, false, false), { NULL })); "__init__",
super_cls->giveAttr("__get__", new BoxedFunction(BoxedCode::create((void*)superGet<CXX>, UNKNOWN, 3))); new BoxedFunction(BoxedCode::create((void*)superInit, UNKNOWN, 3, false, false, "super.__init__"), { NULL }));
super_cls->giveAttr("__get__",
new BoxedFunction(BoxedCode::create((void*)superGet<CXX>, UNKNOWN, 3, "super.__get__")));
super_cls->giveAttrMember("__thisclass__", T_OBJECT, offsetof(BoxedSuper, type)); super_cls->giveAttrMember("__thisclass__", T_OBJECT, offsetof(BoxedSuper, type));
super_cls->giveAttrMember("__self__", T_OBJECT, offsetof(BoxedSuper, obj)); super_cls->giveAttrMember("__self__", T_OBJECT, offsetof(BoxedSuper, obj));
......
src/runtime/tuple.cpp
View file @ 798c4da8
...@@ -772,8 +772,9 @@ void setupTuple() { ...@@ -772,8 +772,9 @@ void setupTuple() {
"tupleiterator", false, (destructor)BoxedTupleIterator::dealloc, NULL, true, "tupleiterator", false, (destructor)BoxedTupleIterator::dealloc, NULL, true,
(traverseproc)BoxedTupleIterator::traverse, NOCLEAR); (traverseproc)BoxedTupleIterator::traverse, NOCLEAR);
tuple_cls->giveAttr("__new__", new BoxedFunction(BoxedCode::create((void*)tupleNew, UNKNOWN, 1, true, true))); tuple_cls->giveAttr("__new__",
BoxedCode* getitem = new BoxedCode(2, 0, 0); new BoxedFunction(BoxedCode::create((void*)tupleNew, UNKNOWN, 1, true, true, "tuple.__new__")));
BoxedCode* getitem = new BoxedCode(2, 0, 0, "tuple.__getitem__");
getitem->addVersion((void*)tupleGetitemInt, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, BOXED_INT }); getitem->addVersion((void*)tupleGetitemInt, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, BOXED_INT });
getitem->addVersion((void*)tupleGetitemSlice, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, SLICE }); getitem->addVersion((void*)tupleGetitemSlice, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, SLICE });
getitem->addVersion((void*)tupleGetitem<CXX>, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, UNKNOWN }, CXX); getitem->addVersion((void*)tupleGetitem<CXX>, UNKNOWN, std::vector<ConcreteCompilerType*>{ UNKNOWN, UNKNOWN }, CXX);
...@@ -781,30 +782,36 @@ void setupTuple() { ...@@ -781,30 +782,36 @@ void setupTuple() {
CAPI); CAPI);
tuple_cls->giveAttr("__getitem__", new BoxedFunction(getitem)); tuple_cls->giveAttr("__getitem__", new BoxedFunction(getitem));
tuple_cls->giveAttr("__contains__", new BoxedFunction(BoxedCode::create((void*)tupleContains, BOXED_BOOL, 2))); tuple_cls->giveAttr("__contains__", new BoxedFunction(BoxedCode::create((void*)tupleContains, BOXED_BOOL, 2,
tuple_cls->giveAttr("index", new BoxedFunction(BoxedCode::create((void*)tupleIndex, BOXED_INT, 4, false, false), "tuple.__contains__")));
{ autoDecref(boxInt(0)), tuple_cls->giveAttr(
autoDecref(boxInt(std::numeric_limits<Py_ssize_t>::max())) })); "index",
tuple_cls->giveAttr("count", new BoxedFunction(BoxedCode::create((void*)tupleCount, BOXED_INT, 2))); new BoxedFunction(BoxedCode::create((void*)tupleIndex, BOXED_INT, 4, false, false, "tuple.index"),
{ autoDecref(boxInt(0)), autoDecref(boxInt(std::numeric_limits<Py_ssize_t>::max())) }));
tuple_cls->giveAttr("count", new BoxedFunction(BoxedCode::create((void*)tupleCount, BOXED_INT, 2, "tuple.count")));
tuple_cls->giveAttr("__iter__", tuple_cls->giveAttr("__iter__", new BoxedFunction(BoxedCode::create(
new BoxedFunction(BoxedCode::create((void*)tupleIter, typeFromClass(tuple_iterator_cls), 1))); (void*)tupleIter, typeFromClass(tuple_iterator_cls), 1, "tuple.__iter__")));
tuple_cls->tp_richcompare = tuplerichcompare; tuple_cls->tp_richcompare = tuplerichcompare;
tuple_cls->giveAttr("__nonzero__", new BoxedFunction(BoxedCode::create((void*)tupleNonzero, BOXED_BOOL, 1))); tuple_cls->giveAttr("__nonzero__",
new BoxedFunction(BoxedCode::create((void*)tupleNonzero, BOXED_BOOL, 1, "tuple.__nonzero__")));
tuple_cls->giveAttr("__len__", new BoxedFunction(BoxedCode::create((void*)tupleLen, BOXED_INT, 1))); tuple_cls->giveAttr("__len__",
tuple_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)tupleRepr, STR, 1))); new BoxedFunction(BoxedCode::create((void*)tupleLen, BOXED_INT, 1, "tuple.__len__")));
tuple_cls->giveAttr("__repr__", new BoxedFunction(BoxedCode::create((void*)tupleRepr, STR, 1, "tuple.__repr__")));
// Return type is UNKNOWN as it could be NotImplemented. // Return type is UNKNOWN as it could be NotImplemented.
tuple_cls->giveAttr("__add__", new BoxedFunction(BoxedCode::create((void*)tupleAdd, UNKNOWN, 2))); tuple_cls->giveAttr("__add__", new BoxedFunction(BoxedCode::create((void*)tupleAdd, UNKNOWN, 2, "tuple.__add__")));
tuple_cls->giveAttr("__mul__", new BoxedFunction(BoxedCode::create((void*)tupleMul, UNKNOWN, 2))); tuple_cls->giveAttr("__mul__", new BoxedFunction(BoxedCode::create((void*)tupleMul, UNKNOWN, 2, "tuple.__mul__")));
tuple_cls->giveAttr("__rmul__", new BoxedFunction(BoxedCode::create((void*)tupleMul, UNKNOWN, 2))); tuple_cls->giveAttr("__rmul__",
new BoxedFunction(BoxedCode::create((void*)tupleMul, UNKNOWN, 2, "tuple.__rmul__")));
tuple_cls->giveAttr("__getnewargs__", new BoxedFunction(BoxedCode::create((void*)tuple_getnewargs, UNKNOWN, 1, tuple_cls->giveAttr("__getnewargs__",
ParamNames::empty(), CAPI))); new BoxedFunction(BoxedCode::create((void*)tuple_getnewargs, UNKNOWN, 1, "tuple.__getnewargs__",
"", ParamNames::empty(), CAPI)));
tuple_cls->tp_hash = (hashfunc)tuple_hash; tuple_cls->tp_hash = (hashfunc)tuple_hash;
tuple_cls->tp_as_sequence->sq_slice = (ssizessizeargfunc)&tupleslice; tuple_cls->tp_as_sequence->sq_slice = (ssizessizeargfunc)&tupleslice;
...@@ -823,12 +830,14 @@ void setupTuple() { ...@@ -823,12 +830,14 @@ void setupTuple() {
tuple_cls->tp_as_mapping->mp_length = (lenfunc)tuplelength; tuple_cls->tp_as_mapping->mp_length = (lenfunc)tuplelength;
tuple_cls->tp_as_mapping->mp_subscript = (binaryfunc)tupleGetitem<CAPI>; tuple_cls->tp_as_mapping->mp_subscript = (binaryfunc)tupleGetitem<CAPI>;
BoxedCode* hasnext = BoxedCode::create((void*)tupleiterHasnextUnboxed, BOOL, 1); BoxedCode* hasnext = BoxedCode::create((void*)tupleiterHasnextUnboxed, BOOL, 1, "tuple.__hasnext__");
hasnext->addVersion((void*)tupleiterHasnext, BOXED_BOOL); hasnext->addVersion((void*)tupleiterHasnext, BOXED_BOOL);
tuple_iterator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext)); tuple_iterator_cls->giveAttr("__hasnext__", new BoxedFunction(hasnext));
tuple_iterator_cls->giveAttr( tuple_iterator_cls->giveAttr(
"__iter__", new BoxedFunction(BoxedCode::create((void*)tupleIterIter, typeFromClass(tuple_iterator_cls), 1))); "__iter__", new BoxedFunction(BoxedCode::create((void*)tupleIterIter, typeFromClass(tuple_iterator_cls), 1,
tuple_iterator_cls->giveAttr("next", new BoxedFunction(BoxedCode::create((void*)tupleiterNext, UNKNOWN, 1))); "tuple_iterator.__iter__")));
tuple_iterator_cls->giveAttr(
"next", new BoxedFunction(BoxedCode::create((void*)tupleiterNext, UNKNOWN, 1, "tuple_iterator.next")));
tuple_iterator_cls->freeze(); tuple_iterator_cls->freeze();
tuple_iterator_cls->tpp_hasnext = tupleiterHasnextUnboxed; tuple_iterator_cls->tpp_hasnext = tupleiterHasnextUnboxed;
......
src/runtime/types.cpp
View file @ 798c4da8
This diff is collapsed.
src/runtime/types.h
View file @ 798c4da8
...@@ -1111,10 +1111,14 @@ public: ...@@ -1111,10 +1111,14 @@ public:
Box**, const std::vector<BoxedString*>*> InternalCallable; Box**, const std::vector<BoxedString*>*> InternalCallable;
InternalCallable internal_callable; InternalCallable internal_callable;
// Constructor for Python code objects:
BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, int firstlineno, std::unique_ptr<SourceInfo> source, BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, int firstlineno, std::unique_ptr<SourceInfo> source,
ParamNames param_names, BoxedString* filename, BoxedString* name, Box* doc); ParamNames param_names, BoxedString* filename, BoxedString* name, Box* doc);
BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, const ParamNames& param_names = ParamNames::empty());
~BoxedCode(); // Constructor for code objects created by the runtime:
BoxedCode(int num_args, bool takes_varargs, bool takes_kwargs, const char* name, const char* doc = "",
const ParamNames& param_names = ParamNames::empty());
// The dummy constructor for PyCode_New: // The dummy constructor for PyCode_New:
BoxedCode(BoxedString* filename, BoxedString* name, int firstline); BoxedCode(BoxedString* filename, BoxedString* name, int firstline);
...@@ -1141,21 +1145,22 @@ public: ...@@ -1141,21 +1145,22 @@ public:
// Helper function, meant for the C++ runtime, which allocates a BoxedCode object and calls addVersion // Helper function, meant for the C++ runtime, which allocates a BoxedCode object and calls addVersion
// once to it. // once to it.
static BoxedCode* create(void* f, ConcreteCompilerType* rtn_type, int nargs, bool takes_varargs, bool takes_kwargs, static BoxedCode* create(void* f, ConcreteCompilerType* rtn_type, int nargs, bool takes_varargs, bool takes_kwargs,
const char* name, const char* doc = "",
const ParamNames& param_names = ParamNames::empty(), const ParamNames& param_names = ParamNames::empty(),
ExceptionStyle exception_style = CXX) { ExceptionStyle exception_style = CXX) {
assert(!param_names.takes_param_names || nargs == param_names.numNormalArgs()); assert(!param_names.takes_param_names || nargs == param_names.numNormalArgs());
assert(takes_varargs || !param_names.has_vararg_name); assert(takes_varargs || !param_names.has_vararg_name);
assert(takes_kwargs || !param_names.has_kwarg_name); assert(takes_kwargs || !param_names.has_kwarg_name);
BoxedCode* code = new BoxedCode(nargs, takes_varargs, takes_kwargs, param_names); BoxedCode* code = new BoxedCode(nargs, takes_varargs, takes_kwargs, name, doc, param_names);
code->addVersion(f, rtn_type, exception_style); code->addVersion(f, rtn_type, exception_style);
return code; return code;
} }
static BoxedCode* create(void* f, ConcreteCompilerType* rtn_type, int nargs, static BoxedCode* create(void* f, ConcreteCompilerType* rtn_type, int nargs, const char* name, const char* doc = "",
const ParamNames& param_names = ParamNames::empty(), const ParamNames& param_names = ParamNames::empty(),
ExceptionStyle exception_style = CXX) { ExceptionStyle exception_style = CXX) {
return create(f, rtn_type, nargs, false, false, param_names, exception_style); return create(f, rtn_type, nargs, false, false, name, doc, param_names, exception_style);
} }
// tries to free the bjit allocated code. returns true on success // tries to free the bjit allocated code. returns true on success
...@@ -1220,9 +1225,9 @@ public: ...@@ -1220,9 +1225,9 @@ public:
class BoxedBuiltinFunctionOrMethod : public BoxedFunctionBase { class BoxedBuiltinFunctionOrMethod : public BoxedFunctionBase {
public: public:
BoxedBuiltinFunctionOrMethod(STOLEN(BoxedCode*) code, const char* name, const char* doc = NULL); BoxedBuiltinFunctionOrMethod(STOLEN(BoxedCode*) code);
BoxedBuiltinFunctionOrMethod(STOLEN(BoxedCode*) code, const char* name, std::initializer_list<Box*> defaults, BoxedBuiltinFunctionOrMethod(STOLEN(BoxedCode*) code, std::initializer_list<Box*> defaults,
BoxedClosure* closure = NULL, const char* doc = NULL); BoxedClosure* closure = NULL);
DEFAULT_CLASS_SIMPLE(builtin_function_or_method_cls, true); DEFAULT_CLASS_SIMPLE(builtin_function_or_method_cls, true);
}; };
......
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