mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 03:20:18 +00:00
...
This commit is contained in:
blueloveTH
parent
ea9dabdf99
commit
cd9a9f7119
@ -203,6 +203,7 @@ void py_bind(py_Ref obj, const char* sig, py_CFunction f);
|
||||
// old style argc-based bindings
|
||||
void py_bindmethod(py_Type type, const char* name, py_CFunction f);
|
||||
void py_bindfunc(py_Ref obj, const char* name, py_CFunction f);
|
||||
void py_bindproperty(py_Type type, const char* name, py_CFunction getter, py_CFunction setter);
|
||||
|
||||
#define py_bindmagic(type, __magic__, f) py_newnativefunc(py_tpmagic((type), __magic__), (f))
|
||||
|
||||
|
||||
@ -148,12 +148,12 @@ __SUCCESS:
|
||||
|
||||
//////////////////////////
|
||||
|
||||
static bool _py_builtins__repr(int argc, py_Ref argv) {
|
||||
static bool builtins__repr(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return py_repr(argv);
|
||||
}
|
||||
|
||||
static bool _py_builtins__exit(int argc, py_Ref argv) {
|
||||
static bool builtins__exit(int argc, py_Ref argv) {
|
||||
int code = 0;
|
||||
if(argc > 1) return TypeError("exit() takes at most 1 argument");
|
||||
if(argc == 1) {
|
||||
@ -165,12 +165,12 @@ static bool _py_builtins__exit(int argc, py_Ref argv) {
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool _py_builtins__len(int argc, py_Ref argv) {
|
||||
static bool builtins__len(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return py_len(argv);
|
||||
}
|
||||
|
||||
static bool _py_builtins__reversed(int argc, py_Ref argv) {
|
||||
static bool builtins__reversed(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
// convert _0 to list object
|
||||
if(!py_tpcall(tp_list, 1, argv)) return false;
|
||||
@ -178,7 +178,7 @@ static bool _py_builtins__reversed(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__hex(int argc, py_Ref argv) {
|
||||
static bool builtins__hex(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
PY_CHECK_ARG_TYPE(0, tp_int);
|
||||
|
||||
@ -208,12 +208,12 @@ static bool _py_builtins__hex(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__iter(int argc, py_Ref argv) {
|
||||
static bool builtins__iter(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return py_iter(argv);
|
||||
}
|
||||
|
||||
static bool _py_builtins__next(int argc, py_Ref argv) {
|
||||
static bool builtins__next(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
int res = py_next(argv);
|
||||
if(res == -1) return false;
|
||||
@ -221,7 +221,7 @@ static bool _py_builtins__next(int argc, py_Ref argv) {
|
||||
return py_exception("StopIteration", "");
|
||||
}
|
||||
|
||||
static bool _py_builtins__sorted(int argc, py_Ref argv) {
|
||||
static bool builtins__sorted(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
// convert _0 to list object
|
||||
if(!py_tpcall(tp_list, 1, py_arg(0))) return false;
|
||||
@ -238,7 +238,7 @@ static bool _py_builtins__sorted(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__hash(int argc, py_Ref argv) {
|
||||
static bool builtins__hash(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_i64 val;
|
||||
if(!py_hash(argv, &val)) return false;
|
||||
@ -246,12 +246,12 @@ static bool _py_builtins__hash(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__abs(int argc, py_Ref argv) {
|
||||
static bool builtins__abs(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return pk_callmagic(__abs__, 1, argv);
|
||||
}
|
||||
|
||||
static bool _py_builtins__sum(int argc, py_Ref argv) {
|
||||
static bool builtins__sum(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
|
||||
if(!py_iter(py_arg(0))) return false;
|
||||
@ -288,7 +288,7 @@ static bool _py_builtins__sum(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__print(int argc, py_Ref argv) {
|
||||
static bool builtins__print(int argc, py_Ref argv) {
|
||||
int length;
|
||||
py_TValue* args = pk_arrayview(argv, &length);
|
||||
assert(args != NULL);
|
||||
@ -309,18 +309,18 @@ static bool _py_builtins__print(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_NoneType__repr__(int argc, py_Ref argv) {
|
||||
static bool NoneType__repr__(int argc, py_Ref argv) {
|
||||
py_newstr(py_retval(), "None");
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_builtins__exec(int argc, py_Ref argv) {
|
||||
static bool builtins__exec(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
PY_CHECK_ARG_TYPE(0, tp_str);
|
||||
return py_exec(py_tostr(argv), "<exec>", EXEC_MODE, NULL);
|
||||
}
|
||||
|
||||
static bool _py_builtins__eval(int argc, py_Ref argv) {
|
||||
static bool builtins__eval(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
PY_CHECK_ARG_TYPE(0, tp_str);
|
||||
return py_exec(py_tostr(argv), "<eval>", EVAL_MODE, NULL);
|
||||
@ -328,25 +328,25 @@ static bool _py_builtins__eval(int argc, py_Ref argv) {
|
||||
|
||||
py_TValue pk_builtins__register() {
|
||||
py_Ref builtins = py_newmodule("builtins");
|
||||
py_bindfunc(builtins, "repr", _py_builtins__repr);
|
||||
py_bindfunc(builtins, "exit", _py_builtins__exit);
|
||||
py_bindfunc(builtins, "len", _py_builtins__len);
|
||||
py_bindfunc(builtins, "reversed", _py_builtins__reversed);
|
||||
py_bindfunc(builtins, "hex", _py_builtins__hex);
|
||||
py_bindfunc(builtins, "iter", _py_builtins__iter);
|
||||
py_bindfunc(builtins, "next", _py_builtins__next);
|
||||
py_bindfunc(builtins, "hash", _py_builtins__hash);
|
||||
py_bindfunc(builtins, "abs", _py_builtins__abs);
|
||||
py_bindfunc(builtins, "sum", _py_builtins__sum);
|
||||
py_bindfunc(builtins, "repr", builtins__repr);
|
||||
py_bindfunc(builtins, "exit", builtins__exit);
|
||||
py_bindfunc(builtins, "len", builtins__len);
|
||||
py_bindfunc(builtins, "reversed", builtins__reversed);
|
||||
py_bindfunc(builtins, "hex", builtins__hex);
|
||||
py_bindfunc(builtins, "iter", builtins__iter);
|
||||
py_bindfunc(builtins, "next", builtins__next);
|
||||
py_bindfunc(builtins, "hash", builtins__hash);
|
||||
py_bindfunc(builtins, "abs", builtins__abs);
|
||||
py_bindfunc(builtins, "sum", builtins__sum);
|
||||
|
||||
py_bindfunc(builtins, "exec", _py_builtins__exec);
|
||||
py_bindfunc(builtins, "eval", _py_builtins__eval);
|
||||
py_bindfunc(builtins, "exec", builtins__exec);
|
||||
py_bindfunc(builtins, "eval", builtins__eval);
|
||||
|
||||
py_bind(builtins, "print(*args, sep=' ', end='\\n')", _py_builtins__print);
|
||||
py_bind(builtins, "sorted(iterable, key=None, reverse=False)", _py_builtins__sorted);
|
||||
py_bind(builtins, "print(*args, sep=' ', end='\\n')", builtins__print);
|
||||
py_bind(builtins, "sorted(iterable, key=None, reverse=False)", builtins__sorted);
|
||||
|
||||
// None __repr__
|
||||
py_bindmagic(tp_NoneType, __repr__, _py_NoneType__repr__);
|
||||
py_bindmagic(tp_NoneType, __repr__, NoneType__repr__);
|
||||
return *builtins;
|
||||
}
|
||||
|
||||
@ -356,7 +356,7 @@ py_Type pk_function__register() {
|
||||
return type;
|
||||
}
|
||||
|
||||
static bool _py_nativefunc__repr(int argc, py_Ref argv) {
|
||||
static bool nativefunc__repr(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_newstr(py_retval(), "<nativefunc object>");
|
||||
return true;
|
||||
@ -364,6 +364,6 @@ static bool _py_nativefunc__repr(int argc, py_Ref argv) {
|
||||
|
||||
py_Type pk_nativefunc__register() {
|
||||
py_Type type = pk_newtype("nativefunc", tp_object, NULL, NULL, false, true);
|
||||
py_bindmagic(type, __repr__, _py_nativefunc__repr);
|
||||
py_bindmagic(type, __repr__, nativefunc__repr);
|
||||
return type;
|
||||
}
|
||||
@ -61,13 +61,13 @@ bool pk_arraycontains(py_Ref self, py_Ref val) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_array_iterator__iter__(int argc, py_Ref argv) {
|
||||
static bool array_iterator__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
*py_retval() = *argv;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_array_iterator__next__(int argc, py_Ref argv) {
|
||||
static bool array_iterator__next__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
array_iterator* ud = py_touserdata(argv);
|
||||
if(ud->index < ud->length) {
|
||||
@ -79,7 +79,7 @@ static bool _py_array_iterator__next__(int argc, py_Ref argv) {
|
||||
|
||||
py_Type pk_array_iterator__register() {
|
||||
py_Type type = pk_newtype("array_iterator", tp_object, NULL, NULL, false, true);
|
||||
py_bindmagic(type, __iter__, _py_array_iterator__iter__);
|
||||
py_bindmagic(type, __next__, _py_array_iterator__next__);
|
||||
py_bindmagic(type, __iter__, array_iterator__iter__);
|
||||
py_bindmagic(type, __next__, array_iterator__next__);
|
||||
return type;
|
||||
}
|
||||
|
||||
@ -204,12 +204,12 @@ static DictEntry* DictIterator__next(DictIterator* self) {
|
||||
}
|
||||
|
||||
///////////////////////////////
|
||||
static bool _py_dict__new__(int argc, py_Ref argv) {
|
||||
static bool dict__new__(int argc, py_Ref argv) {
|
||||
py_newdict(py_retval());
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__init__(int argc, py_Ref argv) {
|
||||
static bool dict__init__(int argc, py_Ref argv) {
|
||||
if(argc > 2) return TypeError("dict.__init__() takes at most 2 arguments (%d given)", argc);
|
||||
if(argc == 1) return true;
|
||||
assert(argc == 2);
|
||||
@ -228,7 +228,7 @@ static bool _py_dict__init__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__getitem__(int argc, py_Ref argv) {
|
||||
static bool dict__getitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
Dict* self = py_touserdata(argv);
|
||||
DictEntry* entry;
|
||||
@ -240,20 +240,20 @@ static bool _py_dict__getitem__(int argc, py_Ref argv) {
|
||||
return KeyError(py_arg(1));
|
||||
}
|
||||
|
||||
static bool _py_dict__setitem__(int argc, py_Ref argv) {
|
||||
static bool dict__setitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
Dict* self = py_touserdata(argv);
|
||||
return Dict__set(self, py_arg(1), py_arg(2));
|
||||
}
|
||||
|
||||
static bool _py_dict__delitem__(int argc, py_Ref argv) {
|
||||
static bool dict__delitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
Dict* self = py_touserdata(argv);
|
||||
if(!Dict__pop(self, py_arg(1))) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__contains__(int argc, py_Ref argv) {
|
||||
static bool dict__contains__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
Dict* self = py_touserdata(argv);
|
||||
DictEntry* entry;
|
||||
@ -262,14 +262,14 @@ static bool _py_dict__contains__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__len__(int argc, py_Ref argv) {
|
||||
static bool dict__len__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
py_newint(py_retval(), self->length);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__repr__(int argc, py_Ref argv) {
|
||||
static bool dict__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
c11_sbuf buf;
|
||||
@ -292,7 +292,7 @@ static bool _py_dict__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__eq__(int argc, py_Ref argv) {
|
||||
static bool dict__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
Dict* self = py_touserdata(py_arg(0));
|
||||
if(!py_isdict(py_arg(1))) {
|
||||
@ -326,8 +326,8 @@ static bool _py_dict__eq__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__ne__(int argc, py_Ref argv) {
|
||||
if(!_py_dict__eq__(argc, argv)) return false;
|
||||
static bool dict__ne__(int argc, py_Ref argv) {
|
||||
if(!dict__eq__(argc, argv)) return false;
|
||||
if(py_isbool(py_retval())) {
|
||||
bool res = py_tobool(py_retval());
|
||||
py_newbool(py_retval(), !res);
|
||||
@ -335,14 +335,14 @@ static bool _py_dict__ne__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__clear(int argc, py_Ref argv) {
|
||||
static bool dict__clear(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
Dict__clear(self);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__copy(int argc, py_Ref argv) {
|
||||
static bool dict__copy(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
Dict* new_dict = py_newobject(py_retval(), tp_dict, 0, sizeof(Dict));
|
||||
@ -355,7 +355,7 @@ static bool _py_dict__copy(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__update(int argc, py_Ref argv) {
|
||||
static bool dict__update(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
PY_CHECK_ARG_TYPE(1, tp_dict);
|
||||
Dict* self = py_touserdata(argv);
|
||||
@ -368,7 +368,7 @@ static bool _py_dict__update(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__get(int argc, py_Ref argv) {
|
||||
static bool dict__get(int argc, py_Ref argv) {
|
||||
Dict* self = py_touserdata(argv);
|
||||
if(argc > 3) return TypeError("get() takes at most 3 arguments (%d given)", argc);
|
||||
py_Ref default_val = argc == 3 ? py_arg(2) : py_None;
|
||||
@ -378,7 +378,7 @@ static bool _py_dict__get(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__pop(int argc, py_Ref argv) {
|
||||
static bool dict__pop(int argc, py_Ref argv) {
|
||||
Dict* self = py_touserdata(argv);
|
||||
if(argc < 2 || argc > 3) return TypeError("pop() takes 2 or 3 arguments (%d given)", argc);
|
||||
py_Ref default_val = argc == 3 ? py_arg(2) : py_None;
|
||||
@ -387,7 +387,7 @@ static bool _py_dict__pop(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__items(int argc, py_Ref argv) {
|
||||
static bool dict__items(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
DictIterator* ud = py_newobject(py_retval(), tp_dict_items, 1, sizeof(DictIterator));
|
||||
@ -396,7 +396,7 @@ static bool _py_dict__items(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__keys(int argc, py_Ref argv) {
|
||||
static bool dict__keys(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
py_newtuple(py_retval(), self->length);
|
||||
@ -412,7 +412,7 @@ static bool _py_dict__keys(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict__values(int argc, py_Ref argv) {
|
||||
static bool dict__values(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
Dict* self = py_touserdata(argv);
|
||||
py_newtuple(py_retval(), self->length);
|
||||
@ -431,38 +431,38 @@ static bool _py_dict__values(int argc, py_Ref argv) {
|
||||
py_Type pk_dict__register() {
|
||||
py_Type type = pk_newtype("dict", tp_object, NULL, (void (*)(void*))Dict__dtor, false, false);
|
||||
|
||||
py_bindmagic(type, __new__, _py_dict__new__);
|
||||
py_bindmagic(type, __init__, _py_dict__init__);
|
||||
py_bindmagic(type, __getitem__, _py_dict__getitem__);
|
||||
py_bindmagic(type, __setitem__, _py_dict__setitem__);
|
||||
py_bindmagic(type, __delitem__, _py_dict__delitem__);
|
||||
py_bindmagic(type, __contains__, _py_dict__contains__);
|
||||
py_bindmagic(type, __len__, _py_dict__len__);
|
||||
py_bindmagic(type, __repr__, _py_dict__repr__);
|
||||
py_bindmagic(type, __eq__, _py_dict__eq__);
|
||||
py_bindmagic(type, __ne__, _py_dict__ne__);
|
||||
py_bindmagic(type, __new__, dict__new__);
|
||||
py_bindmagic(type, __init__, dict__init__);
|
||||
py_bindmagic(type, __getitem__, dict__getitem__);
|
||||
py_bindmagic(type, __setitem__, dict__setitem__);
|
||||
py_bindmagic(type, __delitem__, dict__delitem__);
|
||||
py_bindmagic(type, __contains__, dict__contains__);
|
||||
py_bindmagic(type, __len__, dict__len__);
|
||||
py_bindmagic(type, __repr__, dict__repr__);
|
||||
py_bindmagic(type, __eq__, dict__eq__);
|
||||
py_bindmagic(type, __ne__, dict__ne__);
|
||||
|
||||
py_bindmethod(type, "clear", _py_dict__clear);
|
||||
py_bindmethod(type, "copy", _py_dict__copy);
|
||||
py_bindmethod(type, "update", _py_dict__update);
|
||||
py_bindmethod(type, "get", _py_dict__get);
|
||||
py_bindmethod(type, "pop", _py_dict__pop);
|
||||
py_bindmethod(type, "items", _py_dict__items);
|
||||
py_bindmethod(type, "keys", _py_dict__keys);
|
||||
py_bindmethod(type, "values", _py_dict__values);
|
||||
py_bindmethod(type, "clear", dict__clear);
|
||||
py_bindmethod(type, "copy", dict__copy);
|
||||
py_bindmethod(type, "update", dict__update);
|
||||
py_bindmethod(type, "get", dict__get);
|
||||
py_bindmethod(type, "pop", dict__pop);
|
||||
py_bindmethod(type, "items", dict__items);
|
||||
py_bindmethod(type, "keys", dict__keys);
|
||||
py_bindmethod(type, "values", dict__values);
|
||||
|
||||
py_setdict(py_tpobject(type), __hash__, py_None);
|
||||
return type;
|
||||
}
|
||||
|
||||
//////////////////////////
|
||||
static bool _py_dict_items__iter__(int argc, py_Ref argv) {
|
||||
static bool dict_items__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
*py_retval() = *argv;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_dict_items__next__(int argc, py_Ref argv) {
|
||||
static bool dict_items__next__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
DictIterator* iter = py_touserdata(py_arg(0));
|
||||
DictEntry* entry = (DictIterator__next(iter));
|
||||
@ -477,8 +477,8 @@ static bool _py_dict_items__next__(int argc, py_Ref argv) {
|
||||
|
||||
py_Type pk_dict_items__register() {
|
||||
py_Type type = pk_newtype("dict_items", tp_object, NULL, NULL, false, true);
|
||||
py_bindmagic(type, __iter__, _py_dict_items__iter__);
|
||||
py_bindmagic(type, __next__, _py_dict_items__next__);
|
||||
py_bindmagic(type, __iter__, dict_items__iter__);
|
||||
py_bindmagic(type, __next__, dict_items__next__);
|
||||
return type;
|
||||
}
|
||||
|
||||
@ -524,7 +524,7 @@ int py_dict__len(py_Ref self) {
|
||||
return ud->length;
|
||||
}
|
||||
|
||||
bool py_dict__apply(py_Ref self, bool (*f)(py_Ref, py_Ref, void *), void *ctx){
|
||||
bool py_dict__apply(py_Ref self, bool (*f)(py_Ref, py_Ref, void*), void* ctx) {
|
||||
Dict* ud = py_touserdata(self);
|
||||
for(int i = 0; i < ud->entries.count; i++) {
|
||||
DictEntry* entry = c11__at(DictEntry, &ud->entries, i);
|
||||
|
||||
@ -65,14 +65,14 @@ void py_list__reverse(py_Ref self) {
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
static bool _py_list__len__(int argc, py_Ref argv) {
|
||||
static bool list__len__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_i64 res = py_list__len(py_arg(0));
|
||||
py_newint(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__eq__(int argc, py_Ref argv) {
|
||||
static bool list__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(py_istype(py_arg(1), tp_list)) {
|
||||
int length0, length1;
|
||||
@ -87,8 +87,8 @@ static bool _py_list__eq__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__ne__(int argc, py_Ref argv) {
|
||||
if(!_py_list__eq__(argc, argv)) return false;
|
||||
static bool list__ne__(int argc, py_Ref argv) {
|
||||
if(!list__eq__(argc, argv)) return false;
|
||||
if(py_isbool(py_retval())) {
|
||||
bool res = py_tobool(py_retval());
|
||||
py_newbool(py_retval(), !res);
|
||||
@ -96,7 +96,7 @@ static bool _py_list__ne__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__new__(int argc, py_Ref argv) {
|
||||
static bool list__new__(int argc, py_Ref argv) {
|
||||
if(argc == 1) {
|
||||
py_newlist(py_retval());
|
||||
return true;
|
||||
@ -120,7 +120,7 @@ static bool _py_list__new__(int argc, py_Ref argv) {
|
||||
py_newlist(list);
|
||||
while(true) {
|
||||
int res = py_next(iter);
|
||||
if(res == -1){
|
||||
if(res == -1) {
|
||||
py_shrink(2);
|
||||
return false;
|
||||
}
|
||||
@ -134,7 +134,7 @@ static bool _py_list__new__(int argc, py_Ref argv) {
|
||||
return TypeError("list() takes at most 1 argument");
|
||||
}
|
||||
|
||||
static bool _py_list__getitem__(int argc, py_Ref argv) {
|
||||
static bool list__getitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -158,7 +158,7 @@ static bool _py_list__getitem__(int argc, py_Ref argv) {
|
||||
}
|
||||
}
|
||||
|
||||
static bool _py_list__setitem__(int argc, py_Ref argv) {
|
||||
static bool list__setitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
@ -168,7 +168,7 @@ static bool _py_list__setitem__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__delitem__(int argc, py_Ref argv) {
|
||||
static bool list__delitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
@ -179,7 +179,7 @@ static bool _py_list__delitem__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__add__(int argc, py_Ref argv) {
|
||||
static bool list__add__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
py_Ref _0 = py_arg(0);
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -196,7 +196,7 @@ static bool _py_list__add__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__mul__(int argc, py_Ref argv) {
|
||||
static bool list__mul__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
py_Ref _0 = py_arg(0);
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -214,16 +214,16 @@ static bool _py_list__mul__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__rmul__(int argc, py_Ref argv) { return _py_list__mul__(argc, argv); }
|
||||
static bool list__rmul__(int argc, py_Ref argv) { return list__mul__(argc, argv); }
|
||||
|
||||
static bool _py_list__append(int argc, py_Ref argv) {
|
||||
static bool list__append(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
py_list__append(py_arg(0), py_arg(1));
|
||||
py_newnone(py_retval());
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__repr__(int argc, py_Ref argv) {
|
||||
static bool list__repr__(int argc, py_Ref argv) {
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
c11_sbuf buf;
|
||||
c11_sbuf__ctor(&buf);
|
||||
@ -243,7 +243,7 @@ static bool _py_list__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__extend(int argc, py_Ref argv) {
|
||||
static bool list__extend(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
PY_CHECK_ARG_TYPE(1, tp_list);
|
||||
@ -253,7 +253,7 @@ static bool _py_list__extend(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__count(int argc, py_Ref argv) {
|
||||
static bool list__count(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
int count = 0;
|
||||
for(int i = 0; i < py_list__len(py_arg(0)); i++) {
|
||||
@ -265,14 +265,14 @@ static bool _py_list__count(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__clear(int argc, py_Ref argv) {
|
||||
static bool list__clear(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_list__clear(py_arg(0));
|
||||
py_newnone(py_retval());
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__copy(int argc, py_Ref argv) {
|
||||
static bool list__copy(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_newlist(py_retval());
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
@ -281,7 +281,7 @@ static bool _py_list__copy(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__index(int argc, py_Ref argv) {
|
||||
static bool list__index(int argc, py_Ref argv) {
|
||||
if(argc > 3) return TypeError("index() takes at most 3 arguments");
|
||||
int start = 0;
|
||||
if(argc == 3) {
|
||||
@ -299,7 +299,7 @@ static bool _py_list__index(int argc, py_Ref argv) {
|
||||
return ValueError("list.index(x): x not in list");
|
||||
}
|
||||
|
||||
static bool _py_list__reverse(int argc, py_Ref argv) {
|
||||
static bool list__reverse(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
c11__reverse(py_TValue, self);
|
||||
@ -307,7 +307,7 @@ static bool _py_list__reverse(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__remove(int argc, py_Ref argv) {
|
||||
static bool list__remove(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
for(int i = 0; i < py_list__len(py_arg(0)); i++) {
|
||||
int res = py_equal(py_list__getitem(py_arg(0), i), py_arg(1));
|
||||
@ -321,7 +321,7 @@ static bool _py_list__remove(int argc, py_Ref argv) {
|
||||
return ValueError("list.remove(x): x not in list");
|
||||
}
|
||||
|
||||
static bool _py_list__pop(int argc, py_Ref argv) {
|
||||
static bool list__pop(int argc, py_Ref argv) {
|
||||
int index;
|
||||
if(argc == 1) {
|
||||
index = -1;
|
||||
@ -339,7 +339,7 @@ static bool _py_list__pop(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__insert(int argc, py_Ref argv) {
|
||||
static bool list__insert(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
@ -352,7 +352,7 @@ static bool _py_list__insert(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static int _py_lt_with_key(py_TValue* a, py_TValue* b, py_TValue* key) {
|
||||
static int lt_with_key(py_TValue* a, py_TValue* b, py_TValue* key) {
|
||||
if(!key) return py_less(a, b);
|
||||
pk_VM* vm = pk_current_vm;
|
||||
// project a
|
||||
@ -375,7 +375,7 @@ static int _py_lt_with_key(py_TValue* a, py_TValue* b, py_TValue* key) {
|
||||
}
|
||||
|
||||
// sort(self, key=None, reverse=False)
|
||||
static bool _py_list__sort(int argc, py_Ref argv) {
|
||||
static bool list__sort(int argc, py_Ref argv) {
|
||||
List* self = py_touserdata(py_arg(0));
|
||||
|
||||
py_Ref key = py_arg(1);
|
||||
@ -384,7 +384,7 @@ static bool _py_list__sort(int argc, py_Ref argv) {
|
||||
bool ok = c11__stable_sort(self->data,
|
||||
self->count,
|
||||
sizeof(py_TValue),
|
||||
(int (*)(const void*, const void*, void*))_py_lt_with_key,
|
||||
(int (*)(const void*, const void*, void*))lt_with_key,
|
||||
key);
|
||||
if(!ok) return false;
|
||||
|
||||
@ -395,12 +395,12 @@ static bool _py_list__sort(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_list__iter__(int argc, py_Ref argv) {
|
||||
static bool list__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return pk_arrayiter(argv);
|
||||
}
|
||||
|
||||
static bool _py_list__contains__(int argc, py_Ref argv) {
|
||||
static bool list__contains__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
return pk_arraycontains(py_arg(0), py_arg(1));
|
||||
}
|
||||
@ -409,33 +409,33 @@ py_Type pk_list__register() {
|
||||
py_Type type =
|
||||
pk_newtype("list", tp_object, NULL, (void (*)(void*))c11_vector__dtor, false, true);
|
||||
|
||||
py_bindmagic(type, __len__, _py_list__len__);
|
||||
py_bindmagic(type, __eq__, _py_list__eq__);
|
||||
py_bindmagic(type, __ne__, _py_list__ne__);
|
||||
py_bindmagic(type, __new__, _py_list__new__);
|
||||
py_bindmagic(type, __getitem__, _py_list__getitem__);
|
||||
py_bindmagic(type, __setitem__, _py_list__setitem__);
|
||||
py_bindmagic(type, __delitem__, _py_list__delitem__);
|
||||
py_bindmagic(type, __add__, _py_list__add__);
|
||||
py_bindmagic(type, __mul__, _py_list__mul__);
|
||||
py_bindmagic(type, __rmul__, _py_list__rmul__);
|
||||
py_bindmagic(type, __repr__, _py_list__repr__);
|
||||
py_bindmagic(type, __iter__, _py_list__iter__);
|
||||
py_bindmagic(type, __contains__, _py_list__contains__);
|
||||
py_bindmagic(type, __len__, list__len__);
|
||||
py_bindmagic(type, __eq__, list__eq__);
|
||||
py_bindmagic(type, __ne__, list__ne__);
|
||||
py_bindmagic(type, __new__, list__new__);
|
||||
py_bindmagic(type, __getitem__, list__getitem__);
|
||||
py_bindmagic(type, __setitem__, list__setitem__);
|
||||
py_bindmagic(type, __delitem__, list__delitem__);
|
||||
py_bindmagic(type, __add__, list__add__);
|
||||
py_bindmagic(type, __mul__, list__mul__);
|
||||
py_bindmagic(type, __rmul__, list__rmul__);
|
||||
py_bindmagic(type, __repr__, list__repr__);
|
||||
py_bindmagic(type, __iter__, list__iter__);
|
||||
py_bindmagic(type, __contains__, list__contains__);
|
||||
|
||||
py_bindmethod(type, "append", _py_list__append);
|
||||
py_bindmethod(type, "extend", _py_list__extend);
|
||||
py_bindmethod(type, "count", _py_list__count);
|
||||
py_bindmethod(type, "clear", _py_list__clear);
|
||||
py_bindmethod(type, "copy", _py_list__copy);
|
||||
py_bindmethod(type, "index", _py_list__index);
|
||||
py_bindmethod(type, "reverse", _py_list__reverse);
|
||||
py_bindmethod(type, "remove", _py_list__remove);
|
||||
py_bindmethod(type, "pop", _py_list__pop);
|
||||
py_bindmethod(type, "insert", _py_list__insert);
|
||||
py_bindmethod(type, "sort", _py_list__sort);
|
||||
py_bindmethod(type, "append", list__append);
|
||||
py_bindmethod(type, "extend", list__extend);
|
||||
py_bindmethod(type, "count", list__count);
|
||||
py_bindmethod(type, "clear", list__clear);
|
||||
py_bindmethod(type, "copy", list__copy);
|
||||
py_bindmethod(type, "index", list__index);
|
||||
py_bindmethod(type, "reverse", list__reverse);
|
||||
py_bindmethod(type, "remove", list__remove);
|
||||
py_bindmethod(type, "pop", list__pop);
|
||||
py_bindmethod(type, "insert", list__insert);
|
||||
py_bindmethod(type, "sort", list__sort);
|
||||
|
||||
py_bind(py_tpobject(type), "sort(self, key=None, reverse=False)", _py_list__sort);
|
||||
py_bind(py_tpobject(type), "sort(self, key=None, reverse=False)", list__sort);
|
||||
|
||||
py_setdict(py_tpobject(type), __hash__, py_None);
|
||||
return type;
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#include "pocketpy/common/sstream.h"
|
||||
#include "pocketpy/pocketpy.h"
|
||||
|
||||
static bool _py_object__new__(int argc, py_Ref argv) {
|
||||
static bool object__new__(int argc, py_Ref argv) {
|
||||
if(argc == 0) return TypeError("object.__new__(): not enough arguments");
|
||||
py_Type cls = py_totype(py_arg(0));
|
||||
pk_TypeInfo* ti = c11__at(pk_TypeInfo, &pk_current_vm->types, cls);
|
||||
@ -13,28 +13,28 @@ static bool _py_object__new__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_object__hash__(int argc, py_Ref argv) {
|
||||
static bool object__hash__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
assert(argv->is_ptr);
|
||||
py_newint(py_retval(), (py_i64)argv->_obj);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_object__eq__(int argc, py_Ref argv) {
|
||||
static bool object__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
bool res = py_isidentical(py_arg(0), py_arg(1));
|
||||
py_newbool(py_retval(), res);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_object__ne__(int argc, py_Ref argv) {
|
||||
static bool object__ne__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
bool res = py_isidentical(py_arg(0), py_arg(1));
|
||||
py_newbool(py_retval(), !res);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_object__repr__(int argc, py_Ref argv) {
|
||||
static bool object__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
assert(argv->is_ptr);
|
||||
c11_sbuf buf;
|
||||
@ -44,7 +44,7 @@ static bool _py_object__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_type__repr__(int argc, py_Ref argv) {
|
||||
static bool type__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_sbuf buf;
|
||||
c11_sbuf__ctor(&buf);
|
||||
@ -53,23 +53,33 @@ static bool _py_type__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_type__new__(int argc, py_Ref argv){
|
||||
static bool type__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
py_Type type = py_typeof(py_arg(1));
|
||||
py_assign(py_retval(), py_tpobject(type));
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool type__base__getter(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
py_Type type = py_totype(argv);
|
||||
pk_TypeInfo* ti = c11__at(pk_TypeInfo, &pk_current_vm->types, type);
|
||||
py_assign(py_retval(), py_tpobject(ti->base));
|
||||
return true;
|
||||
}
|
||||
|
||||
void pk_object__register() {
|
||||
// use staticmethod
|
||||
py_bindmagic(tp_object, __new__, _py_object__new__);
|
||||
py_bindmagic(tp_object, __new__, object__new__);
|
||||
|
||||
py_bindmagic(tp_object, __hash__, _py_object__hash__);
|
||||
py_bindmagic(tp_object, __eq__, _py_object__eq__);
|
||||
py_bindmagic(tp_object, __ne__, _py_object__ne__);
|
||||
py_bindmagic(tp_object, __repr__, _py_object__repr__);
|
||||
py_bindmagic(tp_object, __hash__, object__hash__);
|
||||
py_bindmagic(tp_object, __eq__, object__eq__);
|
||||
py_bindmagic(tp_object, __ne__, object__ne__);
|
||||
py_bindmagic(tp_object, __repr__, object__repr__);
|
||||
|
||||
// type patch...
|
||||
py_bindmagic(tp_type, __repr__, _py_type__repr__);
|
||||
py_bindmagic(tp_type, __new__, _py_type__new__);
|
||||
py_bindmagic(tp_type, __repr__, type__repr__);
|
||||
py_bindmagic(tp_type, __new__, type__new__);
|
||||
|
||||
py_bindproperty(tp_type, "__base__", type__base__getter, NULL);
|
||||
}
|
||||
@ -10,7 +10,7 @@ typedef struct Range {
|
||||
py_i64 step;
|
||||
} Range;
|
||||
|
||||
static bool _py_range__new__(int argc, py_Ref argv) {
|
||||
static bool range__new__(int argc, py_Ref argv) {
|
||||
Range* ud = py_newobject(py_retval(), tp_range, 0, sizeof(Range));
|
||||
switch(argc - 1) { // skip cls
|
||||
case 1: {
|
||||
@ -41,7 +41,7 @@ static bool _py_range__new__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_range__iter__(int argc, py_Ref argv) {
|
||||
static bool range__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return py_tpcall(tp_range_iterator, 1, argv);
|
||||
}
|
||||
@ -49,8 +49,8 @@ static bool _py_range__iter__(int argc, py_Ref argv) {
|
||||
py_Type pk_range__register() {
|
||||
py_Type type = pk_newtype("range", tp_object, NULL, NULL, false, true);
|
||||
|
||||
py_bindmagic(type, __new__, _py_range__new__);
|
||||
py_bindmagic(type, __iter__, _py_range__iter__);
|
||||
py_bindmagic(type, __new__, range__new__);
|
||||
py_bindmagic(type, __iter__, range__iter__);
|
||||
return type;
|
||||
}
|
||||
|
||||
@ -59,7 +59,7 @@ typedef struct RangeIterator {
|
||||
py_i64 current;
|
||||
} RangeIterator;
|
||||
|
||||
static bool _py_range_iterator__new__(int argc, py_Ref argv) {
|
||||
static bool range_iterator__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
PY_CHECK_ARG_TYPE(1, tp_range);
|
||||
RangeIterator* ud = py_newobject(py_retval(), tp_range_iterator, 0, sizeof(RangeIterator));
|
||||
@ -68,13 +68,13 @@ static bool _py_range_iterator__new__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_range_iterator__iter__(int argc, py_Ref argv) {
|
||||
static bool range_iterator__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
*py_retval() = *py_arg(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_range_iterator__next__(int argc, py_Ref argv) {
|
||||
static bool range_iterator__next__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
RangeIterator* ud = py_touserdata(py_arg(0));
|
||||
if(ud->range.step > 0) {
|
||||
@ -90,8 +90,8 @@ static bool _py_range_iterator__next__(int argc, py_Ref argv) {
|
||||
py_Type pk_range_iterator__register() {
|
||||
py_Type type = pk_newtype("range_iterator", tp_object, NULL, NULL, false, true);
|
||||
|
||||
py_bindmagic(type, __new__, _py_range_iterator__new__);
|
||||
py_bindmagic(type, __iter__, _py_range_iterator__iter__);
|
||||
py_bindmagic(type, __next__, _py_range_iterator__next__);
|
||||
py_bindmagic(type, __new__, range_iterator__new__);
|
||||
py_bindmagic(type, __iter__, range_iterator__iter__);
|
||||
py_bindmagic(type, __next__, range_iterator__next__);
|
||||
return type;
|
||||
}
|
||||
@ -13,7 +13,7 @@ void py_newslice(py_Ref out) {
|
||||
out->_obj = obj;
|
||||
}
|
||||
|
||||
static bool _py_slice__new__(int argc, py_Ref argv) {
|
||||
static bool slice__new__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1 + 3);
|
||||
py_Ref slice = py_retval();
|
||||
py_newslice(slice);
|
||||
@ -23,7 +23,7 @@ static bool _py_slice__new__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_slice__repr__(int argc, py_Ref argv) {
|
||||
static bool slice__repr__(int argc, py_Ref argv) {
|
||||
c11_sbuf buf;
|
||||
c11_sbuf__ctor(&buf);
|
||||
c11_sbuf__write_cstr(&buf, "slice(");
|
||||
@ -45,7 +45,7 @@ static bool _py_slice__repr__(int argc, py_Ref argv) {
|
||||
py_Type pk_slice__register() {
|
||||
py_Type type = pk_newtype("slice", tp_object, NULL, NULL, false, true);
|
||||
|
||||
py_bindmagic(type, __new__, _py_slice__new__);
|
||||
py_bindmagic(type, __repr__, _py_slice__repr__);
|
||||
py_bindmagic(type, __new__, slice__new__);
|
||||
py_bindmagic(type, __repr__, slice__repr__);
|
||||
return type;
|
||||
}
|
||||
@ -58,7 +58,7 @@ unsigned char* py_tobytes(py_Ref self, int* size) {
|
||||
}
|
||||
|
||||
////////////////////////////////
|
||||
static bool _py_str__new__(int argc, py_Ref argv) {
|
||||
static bool str__new__(int argc, py_Ref argv) {
|
||||
assert(argc >= 1);
|
||||
if(argc == 1) {
|
||||
py_newstr(py_retval(), "");
|
||||
@ -68,7 +68,7 @@ static bool _py_str__new__(int argc, py_Ref argv) {
|
||||
return py_str(py_arg(1));
|
||||
}
|
||||
|
||||
static bool _py_str__hash__(int argc, py_Ref argv) {
|
||||
static bool str__hash__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
int size;
|
||||
const char* data = py_tostrn(&argv[0], &size);
|
||||
@ -80,14 +80,14 @@ static bool _py_str__hash__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__len__(int argc, py_Ref argv) {
|
||||
static bool str__len__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
py_newint(py_retval(), c11_sv__u8_length((c11_sv){self->data, self->size}));
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__add__(int argc, py_Ref argv) {
|
||||
static bool str__add__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
if(py_arg(1)->type != tp_str) {
|
||||
@ -105,7 +105,7 @@ static bool _py_str__add__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__mul__(int argc, py_Ref argv) {
|
||||
static bool str__mul__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
if(py_arg(1)->type != tp_int) {
|
||||
@ -128,9 +128,9 @@ static bool _py_str__mul__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__rmul__(int argc, py_Ref argv) { return _py_str__mul__(argc, argv); }
|
||||
static bool str__rmul__(int argc, py_Ref argv) { return str__mul__(argc, argv); }
|
||||
|
||||
static bool _py_str__contains__(int argc, py_Ref argv) {
|
||||
static bool str__contains__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
if(py_arg(1)->type != tp_str) {
|
||||
@ -143,13 +143,13 @@ static bool _py_str__contains__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__str__(int argc, py_Ref argv) {
|
||||
static bool str__str__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
*py_retval() = argv[0];
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__repr__(int argc, py_Ref argv) {
|
||||
static bool str__repr__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_sbuf buf;
|
||||
c11_sbuf__ctor(&buf);
|
||||
@ -158,7 +158,7 @@ static bool _py_str__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__iter__(int argc, py_Ref argv) {
|
||||
static bool str__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
int* ud = py_newobject(py_retval(), tp_str_iterator, 1, sizeof(int));
|
||||
*ud = 0;
|
||||
@ -166,7 +166,7 @@ static bool _py_str__iter__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__getitem__(int argc, py_Ref argv) {
|
||||
static bool str__getitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_sv self = c11_string__sv(py_touserdata(&argv[0]));
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -190,7 +190,7 @@ static bool _py_str__getitem__(int argc, py_Ref argv) {
|
||||
}
|
||||
|
||||
#define DEF_STR_CMP_OP(op, __f, __cond) \
|
||||
static bool _py_str##op(int argc, py_Ref argv) { \
|
||||
static bool str##op(int argc, py_Ref argv) { \
|
||||
PY_CHECK_ARGC(2); \
|
||||
c11_string* self = py_touserdata(&argv[0]); \
|
||||
if(py_arg(1)->type != tp_str) { \
|
||||
@ -212,7 +212,7 @@ DEF_STR_CMP_OP(__ge__, c11_sv__cmp, res >= 0)
|
||||
|
||||
#undef DEF_STR_CMP_OP
|
||||
|
||||
static bool _py_str__lower(int argc, py_Ref argv) {
|
||||
static bool str__lower(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
int total_size = sizeof(c11_string) + self->size + 1;
|
||||
@ -227,7 +227,7 @@ static bool _py_str__lower(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__upper(int argc, py_Ref argv) {
|
||||
static bool str__upper(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
int total_size = sizeof(c11_string) + self->size + 1;
|
||||
@ -242,7 +242,7 @@ static bool _py_str__upper(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__startswith(int argc, py_Ref argv) {
|
||||
static bool str__startswith(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
PY_CHECK_ARG_TYPE(1, tp_str);
|
||||
@ -251,7 +251,7 @@ static bool _py_str__startswith(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__endswith(int argc, py_Ref argv) {
|
||||
static bool str__endswith(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
PY_CHECK_ARG_TYPE(1, tp_str);
|
||||
@ -260,7 +260,7 @@ static bool _py_str__endswith(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__join(int argc, py_Ref argv) {
|
||||
static bool str__join(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_sv self = c11_string__sv(py_touserdata(&argv[0]));
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -292,7 +292,7 @@ static bool _py_str__join(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__replace(int argc, py_Ref argv) {
|
||||
static bool str__replace(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(3);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
PY_CHECK_ARG_TYPE(1, tp_str);
|
||||
@ -306,7 +306,7 @@ static bool _py_str__replace(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__split(int argc, py_Ref argv) {
|
||||
static bool str__split(int argc, py_Ref argv) {
|
||||
c11_sv self = c11_string__sv(py_touserdata(&argv[0]));
|
||||
c11_vector res;
|
||||
if(argc > 2) return TypeError("split() takes at most 2 arguments");
|
||||
@ -329,7 +329,7 @@ static bool _py_str__split(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__count(int argc, py_Ref argv) {
|
||||
static bool str__count(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_string* self = py_touserdata(&argv[0]);
|
||||
PY_CHECK_ARG_TYPE(1, tp_str);
|
||||
@ -339,7 +339,7 @@ static bool _py_str__count(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__strip_impl(bool left, bool right, int argc, py_Ref argv) {
|
||||
static bool str__strip_impl(bool left, bool right, int argc, py_Ref argv) {
|
||||
c11_sv self = c11_string__sv(py_touserdata(&argv[0]));
|
||||
c11_sv chars;
|
||||
if(argc == 1) {
|
||||
@ -355,19 +355,19 @@ static bool _py_str__strip_impl(bool left, bool right, int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__strip(int argc, py_Ref argv) {
|
||||
return _py_str__strip_impl(true, true, argc, argv);
|
||||
static bool str__strip(int argc, py_Ref argv) {
|
||||
return str__strip_impl(true, true, argc, argv);
|
||||
}
|
||||
|
||||
static bool _py_str__lstrip(int argc, py_Ref argv) {
|
||||
return _py_str__strip_impl(true, false, argc, argv);
|
||||
static bool str__lstrip(int argc, py_Ref argv) {
|
||||
return str__strip_impl(true, false, argc, argv);
|
||||
}
|
||||
|
||||
static bool _py_str__rstrip(int argc, py_Ref argv) {
|
||||
return _py_str__strip_impl(false, true, argc, argv);
|
||||
static bool str__rstrip(int argc, py_Ref argv) {
|
||||
return str__strip_impl(false, true, argc, argv);
|
||||
}
|
||||
|
||||
static bool _py_str__zfill(int argc, py_Ref argv) {
|
||||
static bool str__zfill(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
c11_sv self = c11_string__sv(py_touserdata(&argv[0]));
|
||||
PY_CHECK_ARG_TYPE(1, tp_int);
|
||||
@ -387,7 +387,7 @@ static bool _py_str__zfill(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__widthjust_impl(bool left, int argc, py_Ref argv) {
|
||||
static bool str__widthjust_impl(bool left, int argc, py_Ref argv) {
|
||||
if(argc > 1 + 2) return TypeError("expected at most 2 arguments");
|
||||
char pad;
|
||||
if(argc == 1 + 1) {
|
||||
@ -423,15 +423,15 @@ static bool _py_str__widthjust_impl(bool left, int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__ljust(int argc, py_Ref argv) {
|
||||
return _py_str__widthjust_impl(true, argc, argv);
|
||||
static bool str__ljust(int argc, py_Ref argv) {
|
||||
return str__widthjust_impl(true, argc, argv);
|
||||
}
|
||||
|
||||
static bool _py_str__rjust(int argc, py_Ref argv) {
|
||||
return _py_str__widthjust_impl(false, argc, argv);
|
||||
static bool str__rjust(int argc, py_Ref argv) {
|
||||
return str__widthjust_impl(false, argc, argv);
|
||||
}
|
||||
|
||||
static bool _py_str__find(int argc, py_Ref argv) {
|
||||
static bool str__find(int argc, py_Ref argv) {
|
||||
if(argc > 3) return TypeError("find() takes at most 3 arguments");
|
||||
int start = 0;
|
||||
if(argc == 3) {
|
||||
@ -446,8 +446,8 @@ static bool _py_str__find(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str__index(int argc, py_Ref argv) {
|
||||
bool ok = _py_str__find(argc, argv);
|
||||
static bool str__index(int argc, py_Ref argv) {
|
||||
bool ok = str__find(argc, argv);
|
||||
if(!ok) return false;
|
||||
if(py_toint(py_retval()) == -1) return ValueError("substring not found");
|
||||
return true;
|
||||
@ -457,51 +457,51 @@ py_Type pk_str__register() {
|
||||
py_Type type = pk_newtype("str", tp_object, NULL, NULL, false, true);
|
||||
// no need to dtor because the memory is controlled by the object
|
||||
|
||||
py_bindmagic(tp_str, __new__, _py_str__new__);
|
||||
py_bindmagic(tp_str, __hash__, _py_str__hash__);
|
||||
py_bindmagic(tp_str, __len__, _py_str__len__);
|
||||
py_bindmagic(tp_str, __add__, _py_str__add__);
|
||||
py_bindmagic(tp_str, __mul__, _py_str__mul__);
|
||||
py_bindmagic(tp_str, __rmul__, _py_str__rmul__);
|
||||
py_bindmagic(tp_str, __contains__, _py_str__contains__);
|
||||
py_bindmagic(tp_str, __str__, _py_str__str__);
|
||||
py_bindmagic(tp_str, __repr__, _py_str__repr__);
|
||||
py_bindmagic(tp_str, __iter__, _py_str__iter__);
|
||||
py_bindmagic(tp_str, __getitem__, _py_str__getitem__);
|
||||
py_bindmagic(tp_str, __new__, str__new__);
|
||||
py_bindmagic(tp_str, __hash__, str__hash__);
|
||||
py_bindmagic(tp_str, __len__, str__len__);
|
||||
py_bindmagic(tp_str, __add__, str__add__);
|
||||
py_bindmagic(tp_str, __mul__, str__mul__);
|
||||
py_bindmagic(tp_str, __rmul__, str__rmul__);
|
||||
py_bindmagic(tp_str, __contains__, str__contains__);
|
||||
py_bindmagic(tp_str, __str__, str__str__);
|
||||
py_bindmagic(tp_str, __repr__, str__repr__);
|
||||
py_bindmagic(tp_str, __iter__, str__iter__);
|
||||
py_bindmagic(tp_str, __getitem__, str__getitem__);
|
||||
|
||||
py_bindmagic(tp_str, __eq__, _py_str__eq__);
|
||||
py_bindmagic(tp_str, __ne__, _py_str__ne__);
|
||||
py_bindmagic(tp_str, __lt__, _py_str__lt__);
|
||||
py_bindmagic(tp_str, __le__, _py_str__le__);
|
||||
py_bindmagic(tp_str, __gt__, _py_str__gt__);
|
||||
py_bindmagic(tp_str, __ge__, _py_str__ge__);
|
||||
py_bindmagic(tp_str, __eq__, str__eq__);
|
||||
py_bindmagic(tp_str, __ne__, str__ne__);
|
||||
py_bindmagic(tp_str, __lt__, str__lt__);
|
||||
py_bindmagic(tp_str, __le__, str__le__);
|
||||
py_bindmagic(tp_str, __gt__, str__gt__);
|
||||
py_bindmagic(tp_str, __ge__, str__ge__);
|
||||
|
||||
py_bindmethod(tp_str, "lower", _py_str__lower);
|
||||
py_bindmethod(tp_str, "upper", _py_str__upper);
|
||||
py_bindmethod(tp_str, "startswith", _py_str__startswith);
|
||||
py_bindmethod(tp_str, "endswith", _py_str__endswith);
|
||||
py_bindmethod(tp_str, "join", _py_str__join);
|
||||
py_bindmethod(tp_str, "replace", _py_str__replace);
|
||||
py_bindmethod(tp_str, "split", _py_str__split);
|
||||
py_bindmethod(tp_str, "count", _py_str__count);
|
||||
py_bindmethod(tp_str, "strip", _py_str__strip);
|
||||
py_bindmethod(tp_str, "lstrip", _py_str__lstrip);
|
||||
py_bindmethod(tp_str, "rstrip", _py_str__rstrip);
|
||||
py_bindmethod(tp_str, "zfill", _py_str__zfill);
|
||||
py_bindmethod(tp_str, "ljust", _py_str__ljust);
|
||||
py_bindmethod(tp_str, "rjust", _py_str__rjust);
|
||||
py_bindmethod(tp_str, "find", _py_str__find);
|
||||
py_bindmethod(tp_str, "index", _py_str__index);
|
||||
py_bindmethod(tp_str, "lower", str__lower);
|
||||
py_bindmethod(tp_str, "upper", str__upper);
|
||||
py_bindmethod(tp_str, "startswith", str__startswith);
|
||||
py_bindmethod(tp_str, "endswith", str__endswith);
|
||||
py_bindmethod(tp_str, "join", str__join);
|
||||
py_bindmethod(tp_str, "replace", str__replace);
|
||||
py_bindmethod(tp_str, "split", str__split);
|
||||
py_bindmethod(tp_str, "count", str__count);
|
||||
py_bindmethod(tp_str, "strip", str__strip);
|
||||
py_bindmethod(tp_str, "lstrip", str__lstrip);
|
||||
py_bindmethod(tp_str, "rstrip", str__rstrip);
|
||||
py_bindmethod(tp_str, "zfill", str__zfill);
|
||||
py_bindmethod(tp_str, "ljust", str__ljust);
|
||||
py_bindmethod(tp_str, "rjust", str__rjust);
|
||||
py_bindmethod(tp_str, "find", str__find);
|
||||
py_bindmethod(tp_str, "index", str__index);
|
||||
return type;
|
||||
}
|
||||
|
||||
static bool _py_str_iterator__iter__(int argc, py_Ref argv) {
|
||||
static bool str_iterator__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
*py_retval() = argv[0];
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_str_iterator__next__(int argc, py_Ref argv) {
|
||||
static bool str_iterator__next__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
int* ud = py_touserdata(&argv[0]);
|
||||
int size;
|
||||
@ -517,8 +517,8 @@ static bool _py_str_iterator__next__(int argc, py_Ref argv) {
|
||||
py_Type pk_str_iterator__register() {
|
||||
py_Type type = pk_newtype("str_iterator", tp_object, NULL, NULL, false, true);
|
||||
|
||||
py_bindmagic(type, __iter__, _py_str_iterator__iter__);
|
||||
py_bindmagic(type, __next__, _py_str_iterator__next__);
|
||||
py_bindmagic(type, __iter__, str_iterator__iter__);
|
||||
py_bindmagic(type, __next__, str_iterator__next__);
|
||||
return type;
|
||||
}
|
||||
|
||||
|
||||
@ -22,12 +22,12 @@ void py_tuple__setitem(py_Ref self, int i, py_Ref val) { py_setslot(self, i, val
|
||||
int py_tuple__len(py_Ref self) { return self->_obj->slots; }
|
||||
|
||||
//////////////
|
||||
static bool _py_tuple__len__(int argc, py_Ref argv) {
|
||||
static bool tuple__len__(int argc, py_Ref argv) {
|
||||
py_newint(py_retval(), py_tuple__len(argv));
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_tuple__repr__(int argc, py_Ref argv) {
|
||||
static bool tuple__repr__(int argc, py_Ref argv) {
|
||||
c11_sbuf buf;
|
||||
c11_sbuf__ctor(&buf);
|
||||
c11_sbuf__write_char(&buf, '(');
|
||||
@ -48,7 +48,7 @@ static bool _py_tuple__repr__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_tuple__new__(int argc, py_Ref argv) {
|
||||
static bool tuple__new__(int argc, py_Ref argv) {
|
||||
if(argc == 1 + 0) {
|
||||
py_newtuple(py_retval(), 0);
|
||||
return true;
|
||||
@ -69,7 +69,7 @@ static bool _py_tuple__new__(int argc, py_Ref argv) {
|
||||
return TypeError("tuple() takes at most 1 argument");
|
||||
}
|
||||
|
||||
static bool _py_tuple__getitem__(int argc, py_Ref argv) {
|
||||
static bool tuple__getitem__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
int length = py_tuple__len(argv);
|
||||
py_Ref _1 = py_arg(1);
|
||||
@ -97,7 +97,7 @@ static bool _py_tuple__getitem__(int argc, py_Ref argv) {
|
||||
}
|
||||
}
|
||||
|
||||
static bool _py_tuple__eq__(int argc, py_Ref argv) {
|
||||
static bool tuple__eq__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
if(py_istype(py_arg(1), tp_tuple)) {
|
||||
int length0, length1;
|
||||
@ -112,8 +112,8 @@ static bool _py_tuple__eq__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_tuple__ne__(int argc, py_Ref argv) {
|
||||
if(!_py_tuple__eq__(argc, argv)) return false;
|
||||
static bool tuple__ne__(int argc, py_Ref argv) {
|
||||
if(!tuple__eq__(argc, argv)) return false;
|
||||
if(py_isbool(py_retval())) {
|
||||
bool res = py_tobool(py_retval());
|
||||
py_newbool(py_retval(), !res);
|
||||
@ -121,12 +121,12 @@ static bool _py_tuple__ne__(int argc, py_Ref argv) {
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool _py_tuple__iter__(int argc, py_Ref argv) {
|
||||
static bool tuple__iter__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(1);
|
||||
return pk_arrayiter(argv);
|
||||
}
|
||||
|
||||
static bool _py_tuple__contains__(int argc, py_Ref argv) {
|
||||
static bool tuple__contains__(int argc, py_Ref argv) {
|
||||
PY_CHECK_ARGC(2);
|
||||
return pk_arraycontains(py_arg(0), py_arg(1));
|
||||
}
|
||||
@ -134,13 +134,13 @@ static bool _py_tuple__contains__(int argc, py_Ref argv) {
|
||||
py_Type pk_tuple__register() {
|
||||
py_Type type = pk_newtype("tuple", tp_object, NULL, NULL, false, true);
|
||||
|
||||
py_bindmagic(type, __len__, _py_tuple__len__);
|
||||
py_bindmagic(type, __repr__, _py_tuple__repr__);
|
||||
py_bindmagic(type, __new__, _py_tuple__new__);
|
||||
py_bindmagic(type, __getitem__, _py_tuple__getitem__);
|
||||
py_bindmagic(type, __eq__, _py_tuple__eq__);
|
||||
py_bindmagic(type, __ne__, _py_tuple__ne__);
|
||||
py_bindmagic(type, __iter__, _py_tuple__iter__);
|
||||
py_bindmagic(type, __contains__, _py_tuple__contains__);
|
||||
py_bindmagic(type, __len__, tuple__len__);
|
||||
py_bindmagic(type, __repr__, tuple__repr__);
|
||||
py_bindmagic(type, __new__, tuple__new__);
|
||||
py_bindmagic(type, __getitem__, tuple__getitem__);
|
||||
py_bindmagic(type, __eq__, tuple__eq__);
|
||||
py_bindmagic(type, __ne__, tuple__ne__);
|
||||
py_bindmagic(type, __iter__, tuple__iter__);
|
||||
py_bindmagic(type, __contains__, tuple__contains__);
|
||||
return type;
|
||||
}
|
||||
|
||||
@ -60,17 +60,26 @@ void py_bindfunc(py_Ref obj, const char* name, py_CFunction f) {
|
||||
py_setdict(obj, py_name(name), &tmp);
|
||||
}
|
||||
|
||||
void py_bindproperty(py_Type type, const char* name, py_CFunction getter, py_CFunction setter) {
|
||||
py_TValue tmp;
|
||||
py_newobject(&tmp, tp_property, 2, 0);
|
||||
py_newnativefunc(py_getslot(&tmp, 0), getter);
|
||||
if(setter) {
|
||||
py_newnativefunc(py_getslot(&tmp, 1), setter);
|
||||
} else {
|
||||
py_setslot(&tmp, 1, py_None);
|
||||
}
|
||||
py_setdict(py_tpobject(type), py_name(name), &tmp);
|
||||
}
|
||||
|
||||
void py_bind(py_Ref obj, const char* sig, py_CFunction f) {
|
||||
py_TValue tmp;
|
||||
py_Name name = py_newfunction(&tmp, sig, f, NULL, 0);
|
||||
py_setdict(obj, name, &tmp);
|
||||
}
|
||||
|
||||
py_Name py_newfunction(py_Ref out,
|
||||
const char* sig,
|
||||
py_CFunction f,
|
||||
const char* docstring,
|
||||
int slots) {
|
||||
py_Name
|
||||
py_newfunction(py_Ref out, const char* sig, py_CFunction f, const char* docstring, int slots) {
|
||||
char buffer[256];
|
||||
snprintf(buffer, sizeof(buffer), "def %s: pass", sig);
|
||||
// fn(a, b, *c, d=1) -> None
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user