.github/workflows/main.yml

@@ -2,6 +2,7 @@ name: build
 
 on:
   push:
+    branches: [ main ]
     paths-ignore:
       - 'docs/**'
       - 'web/**'

.github/workflows/pybind11.yml

@@ -2,6 +2,7 @@ name: PKBIND Build and Test
 
 on:
   push:
+    branches: [ main ]
     paths-ignore:
       - "docs/**"
       - "web/**"

3rd/libhv/include/libhv_bindings.hpp

@@ -4,8 +4,6 @@
 #include "http/HttpMessage.h"
 #include "base/hplatform.h"
 
-#include "pocketpy/common/name.h"
-
 extern "C" void pk__add_module_libhv();
 
 void libhv_HttpRequest_create(py_OutRef out, HttpRequestPtr ptr);

CMakeLists.txt

@@ -53,11 +53,6 @@ if(PK_ENABLE_WATCHDOG)
     add_definitions(-DPK_ENABLE_WATCHDOG=1)
 endif()
 
-if(PK_ENABLE_CUSTOM_SNAME)
-    add_definitions(-DPK_ENABLE_CUSTOM_SNAME=1)
-endif()
-
-
 if(PK_BUILD_MODULE_LZ4)
     add_subdirectory(3rd/lz4)
     add_definitions(-DPK_BUILD_MODULE_LZ4)

CMakeOptions.txt

@@ -9,7 +9,6 @@ endif()
 option(PK_ENABLE_OS "" OFF)
 option(PK_ENABLE_DETERMINISM "" OFF)
 option(PK_ENABLE_WATCHDOG "" OFF)
-option(PK_ENABLE_CUSTOM_SNAME "" OFF)
 
 # modules
 option(PK_BUILD_MODULE_LZ4 "" OFF)

include/pocketpy/common/name.h

@@ -8,8 +8,3 @@ void pk_names_finalize();
 #define MAGIC_METHOD(x) extern py_Name x;
 #include "pocketpy/xmacros/magics.h"
 #undef MAGIC_METHOD
-
-py_Name py_namev(c11_sv name);
-c11_sv py_name2sv(py_Name index);
-py_Name py_name(const char* name);
-const char* py_name2str(py_Name index);

include/pocketpy/config.h

@@ -20,10 +20,6 @@
 #define PK_ENABLE_WATCHDOG          0                
 #endif
 
-#ifndef PK_ENABLE_CUSTOM_SNAME      // can be overridden by cmake
-#define PK_ENABLE_CUSTOM_SNAME      0                
-#endif
-
 // GC min threshold
 #ifndef PK_GC_MIN_THRESHOLD         // can be overridden by cmake
     #define PK_GC_MIN_THRESHOLD     32768
@@ -66,9 +62,9 @@
 
 // Hash table load factor (smaller ones mean less collision but more memory)
 // For class instance
-#define PK_INST_ATTR_LOAD_FACTOR    0.67f
+#define PK_INST_ATTR_LOAD_FACTOR    0.67
 // For class itself
-#define PK_TYPE_ATTR_LOAD_FACTOR    0.5f
+#define PK_TYPE_ATTR_LOAD_FACTOR    0.5
 
 #ifdef _WIN32
     #define PK_PLATFORM_SEP '\\'

include/pybind11/internal/class.h

@@ -30,8 +30,8 @@ public:
         auto& info = type_info::of<T>();
         info.name = name;
 
-        py_bind(
-            py_tpobject(this->index()),
+        py_newfunction(
+            py_tpgetmagic(this->index(), __new__),
             "__new__(type, *args, **kwargs)",
             [](int, py_Ref stack) {
                 auto cls = py_offset(stack, 0);
@@ -44,7 +44,9 @@ public:
                     py_newobject(py_retval(), steal<type>(cls).index(), slot, sizeof(instance));
                 new (data) instance{instance::Flag::Own, operator new (info->size), info};
                 return true;
-            });
+            },
+            nullptr,
+            0);
     }
 
     /// bind constructor

include/pybind11/internal/error.h

@@ -101,25 +101,25 @@ inline object::operator bool () const { return raise_call<py_bool>(m_ptr); }
         return object::from_ret();                                                                 \
     }
 
-PKBIND_BINARY_OPERATOR(==, py_name("__eq__"), py_name("__eq__"))
-PKBIND_BINARY_OPERATOR(!=, py_name("__ne__"), py_name("__ne__"))
-PKBIND_BINARY_OPERATOR(<, py_name("__lt__"), py_name("__gt__"))
-PKBIND_BINARY_OPERATOR(<=, py_name("__le__"), py_name("__ge__"))
-PKBIND_BINARY_OPERATOR(>, py_name("__gt__"), py_name("__lt__"))
-PKBIND_BINARY_OPERATOR(>=, py_name("__ge__"), py_name("__le__"))
+PKBIND_BINARY_OPERATOR(==, __eq__, __eq__)
+PKBIND_BINARY_OPERATOR(!=, __ne__, __ne__)
+PKBIND_BINARY_OPERATOR(<, __lt__, __gt__)
+PKBIND_BINARY_OPERATOR(<=, __le__, __ge__)
+PKBIND_BINARY_OPERATOR(>, __gt__, __lt__)
+PKBIND_BINARY_OPERATOR(>=, __ge__, __le__)
 
-PKBIND_BINARY_OPERATOR(+, py_name("__add__"), py_name("__radd__"))
-PKBIND_BINARY_OPERATOR(-, py_name("__sub__"), py_name("__rsub__"))
-PKBIND_BINARY_OPERATOR(*, py_name("__mul__"), py_name("__rmul__"))
-PKBIND_BINARY_OPERATOR(/, py_name("__truediv__"), py_name("__rtruediv__"))
-PKBIND_BINARY_OPERATOR(%, py_name("__mod__"), py_name("__rmod__"))
+PKBIND_BINARY_OPERATOR(+, __add__, __radd__)
+PKBIND_BINARY_OPERATOR(-, __sub__, __rsub__)
+PKBIND_BINARY_OPERATOR(*, __mul__, __rmul__)
+PKBIND_BINARY_OPERATOR(/, __truediv__, __rtruediv__)
+PKBIND_BINARY_OPERATOR(%, __mod__, __rmod__)
 
 // FIXME: support __rand__ ...
-PKBIND_BINARY_OPERATOR(&, py_name("__and__"), nullptr)
-PKBIND_BINARY_OPERATOR(|, py_name("__or__"), nullptr)
-PKBIND_BINARY_OPERATOR(^, py_name("__xor__"), nullptr)
-PKBIND_BINARY_OPERATOR(<<, py_name("__lshift__"), nullptr)
-PKBIND_BINARY_OPERATOR(>>, py_name("__rshift__"), nullptr)
+PKBIND_BINARY_OPERATOR(&, __and__, 0)
+PKBIND_BINARY_OPERATOR(|, __or__, 0)
+PKBIND_BINARY_OPERATOR(^, __xor__, 0)
+PKBIND_BINARY_OPERATOR(<<, __lshift__, 0)
+PKBIND_BINARY_OPERATOR(>>, __rshift__, 0)
 
 #undef PKBIND_BINARY_OPERATOR
 

src/common/name.c

@@ -1,5 +1,3 @@
-#if PK_ENABLE_CUSTOM_SNAME == 0
-
 #include "pocketpy/common/name.h"
 #include "pocketpy/common/str.h"
 #include "pocketpy/pocketpy.h"
@@ -16,7 +14,7 @@ typedef struct NameBucket {
 
 static struct {
     NameBucket* table[0x10000];
-    atomic_flag lock;
+    atomic_bool lock;
 } pk_string_table;
 
 #define MAGIC_METHOD(x) py_Name x;
@@ -42,25 +40,24 @@ void pk_names_finalize() {
 }
 
 py_Name py_namev(c11_sv name) {
-    while(atomic_flag_test_and_set(&pk_string_table.lock)) {
+    while(atomic_exchange(&pk_string_table.lock, true)) {
         // busy-wait until the lock is released
     }
     uint64_t hash = c11_sv__hash(name);
     int index = hash & 0xFFFF;
     NameBucket* p = pk_string_table.table[index];
-    NameBucket* prev = NULL;
     bool found = false;
     while(p) {
         c11_sv p_sv = {p->data, p->size};
         if(p->hash == hash && c11__sveq(p_sv, name)) {
             found = true;
             break;
+        } else {
+            p = p->next;
         }
-        prev = p;
-        p = p->next;
     }
     if(found) {
-        atomic_flag_clear(&pk_string_table.lock);
+        atomic_store(&pk_string_table.lock, false);
         return (py_Name)p;
     }
 
@@ -71,13 +68,13 @@ py_Name py_namev(c11_sv name) {
     bucket->size = name.size;
     memcpy(bucket->data, name.data, name.size);
     bucket->data[name.size] = '\0';
-    if(prev == NULL) {
+    if(p == NULL) {
         pk_string_table.table[index] = bucket;
     } else {
-        assert(prev->next == NULL);
-        prev->next = bucket;
+        assert(p->next == NULL);
+        p->next = bucket;
     }
-    atomic_flag_clear(&pk_string_table.lock);
+    atomic_store(&pk_string_table.lock, false);
     return (py_Name)bucket;
 }
 
@@ -97,5 +94,3 @@ const char* py_name2str(py_Name index) {
     NameBucket* p = (NameBucket*)index;
     return p->data;
 }
-
-#endif

src/interpreter/ceval.c

@@ -92,7 +92,6 @@ FrameResult VM__run_top_frame(VM* self) {
             py_exception(tp_RecursionError, "maximum recursion depth exceeded");
             goto __ERROR;
         }
-        // NOTE: remember to change another occurrence after __ERROR_RE_RAISE:
         co_codes = frame->co->codes.data;
         co_names = frame->co->names.data;
         frame->ip++;
@@ -902,7 +901,7 @@ FrameResult VM__run_top_frame(VM* self) {
             case OP_POP_IMPORT_STAR: {
                 // [module]
                 NameDict* dict = PyObject__dict(TOP()->_obj);
-                py_ItemRef all = NameDict__try_get(dict, __all__);
+                py_Ref all = NameDict__try_get(dict, __all__);
                 if(all) {
                     py_TValue* p;
                     int length = pk_arrayview(all, &p);
@@ -912,7 +911,7 @@ FrameResult VM__run_top_frame(VM* self) {
                     }
                     for(int i = 0; i < length; i++) {
                         py_Name name = py_namev(py_tosv(p + i));
-                        py_ItemRef value = NameDict__try_get(dict, name);
+                        py_Ref value = NameDict__try_get(dict, name);
                         if(value == NULL) {
                             ImportError("cannot import name '%n'", name);
                             goto __ERROR;
@@ -921,7 +920,7 @@ FrameResult VM__run_top_frame(VM* self) {
                         }
                     }
                 } else {
-                    for(int i = 0; i < dict->capacity; i++) {
+                    for(int i = 0; i < dict->length; i++) {
                         NameDict_KV* kv = &dict->items[i];
                         if(kv->key == NULL) continue;
                         c11_sv name = py_name2sv(kv->key);
@@ -1240,7 +1239,6 @@ FrameResult VM__run_top_frame(VM* self) {
             }
             frame = self->top_frame;
             co_codes = frame->co->codes.data;
-            co_names = frame->co->names.data;
             goto __ERROR;
         }
     }

src/interpreter/vm.c

@@ -678,9 +678,9 @@ void ManagedHeap__mark(ManagedHeap* self) {
             for(int i = 0; i < obj->slots; i++)
                 pk__mark_value(p + i);
         } else if(obj->slots == -1) {
-            NameDict* dict = PyObject__dict(obj);
-            for(int i = 0; i < dict->capacity; i++) {
-                NameDict_KV* kv = &dict->items[i];
+            NameDict* namedict = PyObject__dict(obj);
+            for(int i = 0; i < namedict->length; i++) {
+                NameDict_KV* kv = &namedict->items[i];
                 if(kv->key == NULL) continue;
                 pk__mark_value(&kv->value);
             }

src/modules/dis.c

@@ -84,8 +84,7 @@ static bool disassemble(CodeObject* co) {
                 case OP_BEGIN_CLASS:
                 case OP_DELETE_GLOBAL:
                 case OP_STORE_CLASS_ATTR: {
-                    py_Name name = c11__getitem(py_Name, &co->names, byte.arg);
-                    pk_sprintf(&ss, " (%n)", name);
+                    pk_sprintf(&ss, " (%n)", byte.arg);
                     break;
                 }
                 case OP_LOAD_FAST:

src/modules/pickle.c

@@ -374,7 +374,7 @@ static bool pkl__write_object(PickleObject* buf, py_TValue* obj) {
             }
             if(ti->is_python) {
                 NameDict* dict = PyObject__dict(obj->_obj);
-                for(int i = dict->capacity - 1; i >= 0; i--) {
+                for(int i = dict->length - 1; i >= 0; i--) {
                     NameDict_KV* kv = &dict->items[i];
                     if(kv->key == NULL) continue;
                     if(!pkl__write_object(buf, &kv->value)) return false;
@@ -383,7 +383,7 @@ static bool pkl__write_object(PickleObject* buf, py_TValue* obj) {
                 pkl__emit_int(buf, obj->type);
                 buf->used_types[obj->type] = true;
                 pkl__emit_int(buf, dict->length);
-                for(int i = 0; i < dict->capacity; i++) {
+                for(int i = 0; i < dict->length; i++) {
                     NameDict_KV* kv = &dict->items[i];
                     if(kv->key == NULL) continue;
                     c11_sv field = py_name2sv(kv->key);

src/modules/pkpy.c

@@ -217,8 +217,7 @@ static bool ComputeThread__init__(int argc, py_Ref argv) {
 static bool ComputeThread_is_done(int argc, py_Ref argv) {
     PY_CHECK_ARGC(1);
     c11_ComputeThread* self = py_touserdata(argv);
-    bool value = atomic_load(&self->is_done);
-    py_newbool(py_retval(), value);
+    py_newbool(py_retval(), atomic_load(&self->is_done));
     return true;
 }
 

src/public/modules.c

@@ -764,9 +764,9 @@ void function__gc_mark(void* ud, c11_vector* p_stack) {
     Function* func = ud;
     if(func->globals) pk__mark_value(func->globals);
     if(func->closure) {
-        NameDict* dict = func->closure;
-        for(int i = 0; i < dict->capacity; i++) {
-            NameDict_KV* kv = &dict->items[i];
+        NameDict* namedict = func->closure;
+        for(int i = 0; i < namedict->length; i++) {
+            NameDict_KV* kv = &namedict->items[i];
             if(kv->key == NULL) continue;
             pk__mark_value(&kv->value);
         }

src/public/py_exception.c

@@ -225,13 +225,6 @@ char* py_formatexc() {
 }
 
 bool py_exception(py_Type type, const char* fmt, ...) {
-#ifndef NDEBUG
-    if(py_checkexc(true)) {
-        const char* name = py_tpname(pk_current_vm->curr_exception.type);
-        c11__abort("py_exception(): `%s` was already set!", name);
-    }
-#endif
-
     c11_sbuf buf;
     c11_sbuf__ctor(&buf);
     va_list args;

src/public/py_mappingproxy.c

@@ -52,11 +52,11 @@ static bool namedict_items(int argc, py_Ref argv) {
     py_Ref object = py_getslot(argv, 0);
     NameDict* dict = PyObject__dict(object->_obj);
     py_newlist(py_retval());
-    for(int i = 0; i < dict->capacity; i++) {
-        NameDict_KV* kv = &dict->items[i];
-        if(kv->key == NULL) continue;
+    for(int i = 0; i < dict->length; i++) {
         py_Ref slot = py_list_emplace(py_retval());
         py_Ref p = py_newtuple(slot, 2);
+        NameDict_KV* kv = &dict->items[i];
+        if(kv->key == NULL) continue;
         p[0] = *py_name2ref(kv->key);
         p[1] = kv->value;
     }

src/public/stack_ops.c

@@ -26,7 +26,7 @@ py_ItemRef py_emplacedict(py_Ref self, py_Name name) {
 bool py_applydict(py_Ref self, bool (*f)(py_Name, py_Ref, void*), void* ctx) {
     assert(self && self->is_ptr);
     NameDict* dict = PyObject__dict(self->_obj);
-    for(int i = 0; i < dict->capacity; i++) {
+    for(int i = 0; i < dict->length; i++) {
         NameDict_KV* kv = &dict->items[i];
         if(kv->key == NULL) continue;
         bool ok = f(kv->key, &kv->value, ctx);