src/interpreter/ceval.c

@@ -4,7 +4,6 @@
 #include "pocketpy/interpreter/vm.h"
 #include "pocketpy/common/sstream.h"
 #include "pocketpy/objects/codeobject.h"
-#include "pocketpy/objects/exception.h"
 #include "pocketpy/pocketpy.h"
 #include "pocketpy/objects/error.h"
 #include <stdbool.h>
@@ -821,8 +820,7 @@ __NEXT_STEP:
                 return RES_YIELD;
             } else {
                 assert(self->last_retval.type == tp_StopIteration);
-                BaseException* ud = py_touserdata(py_retval());
+                py_ObjectRef value = py_getslot(&self->last_retval, 0);
-                py_ObjectRef value = &ud->args;
                 if(py_isnil(value)) value = py_None();
                 *TOP() = *value;  // [iter] -> [retval]
                 DISPATCH_JUMP((int16_t)byte.arg);

src/interpreter/vm.c

@@ -635,8 +635,7 @@ void ManagedHeap__mark(ManagedHeap* self) {
     assert(p_stack->length == 0);
 
     // mark value stack
-    for(py_TValue* p = vm->stack.begin; p < vm->stack.sp; p++) {
+    for(py_TValue* p = vm->stack.begin; p != vm->stack.end; p++) {
-        // assert(p->type != tp_nil);
         pk__mark_value(p);
     }
     // mark modules

src/objects/namedict.c

@@ -5,29 +5,27 @@
 #include <string.h>
 #include <assert.h>
 
-#define HASH_KEY(__k) ((uintptr_t)(__k) >> 3U)
-
 #define HASH_PROBE_0(__k, ok, i)                                                                   \
     ok = false;                                                                                    \
-    i = HASH_KEY(__k) & self->mask;                                                                \
+    i = (uintptr_t)(__k)&self->mask;                                                               \
     do {                                                                                           \
         if(self->items[i].key == (__k)) {                                                          \
             ok = true;                                                                             \
             break;                                                                                 \
         }                                                                                          \
         if(self->items[i].key == NULL) break;                                                      \
-        i = (i + 1) & self->mask;                                                                  \
+        i = (5 * i + 1) & self->mask;                                                              \
     } while(true);
 
 #define HASH_PROBE_1(__k, ok, i)                                                                   \
     ok = false;                                                                                    \
-    i = HASH_KEY(__k) & self->mask;                                                                \
+    i = (uintptr_t)(__k)&self->mask;                                                               \
     while(self->items[i].key != NULL) {                                                            \
         if(self->items[i].key == (__k)) {                                                          \
             ok = true;                                                                             \
             break;                                                                                 \
         }                                                                                          \
-        i = (i + 1) & self->mask;                                                                  \
+        i = (5 * i + 1) & self->mask;                                                              \
     }
 
 static void NameDict__set_capacity_and_alloc_items(NameDict* self, int val) {
@@ -113,12 +111,12 @@ bool NameDict__del(NameDict* self, py_Name key) {
     self->items[i].value = *py_NIL();
     self->length--;
     /* tidy */
-    uintptr_t posToRemove = i;
+    uint32_t posToRemove = i;
-    uintptr_t posToShift = posToRemove;
+    uint32_t posToShift = posToRemove;
     while(true) {
-        posToShift = (posToShift + 1) & self->mask;
+        posToShift = (5 * posToShift + 1) & self->mask;
         if(self->items[posToShift].key == NULL) break;
-        uintptr_t hash_z = HASH_KEY(self->items[posToShift].key);
+        uintptr_t hash_z = (uintptr_t)self->items[posToShift].key;
         uintptr_t insertPos = hash_z & self->mask;
         bool cond1 = insertPos <= posToRemove;
         bool cond2 = posToRemove <= posToShift;
@@ -126,7 +124,6 @@ bool NameDict__del(NameDict* self, py_Name key) {
            // chain wrapped around capacity
            (posToShift < insertPos && (cond1 || cond2))) {
             NameDict_KV tmp = self->items[posToRemove];
-            assert(tmp.key == NULL);
             self->items[posToRemove] = self->items[posToShift];
             self->items[posToShift] = tmp;
             posToRemove = posToShift;
@@ -145,4 +142,3 @@ void NameDict__clear(NameDict* self) {
 
 #undef HASH_PROBE_0
 #undef HASH_PROBE_1
-#undef HASH_KEY

src/public/py_exception.c

@@ -20,14 +20,9 @@ void py_BaseException__stpush(py_Frame* frame,
     frame_dump->lineno = lineno;
     frame_dump->name = func_name ? c11_string__new(func_name) : NULL;
 
-    if(py_debugger_isattached()) {
+    if(py_debugger_isattached() && frame != NULL) {
-        if(frame != NULL) {
+        py_Frame_newlocals(frame, &frame_dump->locals);
-            py_Frame_newlocals(frame, &frame_dump->locals);
+        py_Frame_newglobals(frame, &frame_dump->globals);
-            py_Frame_newglobals(frame, &frame_dump->globals);
-        } else {
-            py_newdict(&frame_dump->locals);
-            py_newdict(&frame_dump->globals);
-        }
     }
 }
 

tests/08_dict.py

@@ -166,16 +166,3 @@ for i in range(len(data)):
     if i % 3 == 0:
         y = b.pop()
         delattr(a, y)
-
-# bug test
-d = {
-    '__name__': '__main__',
-    '__package__': '',
-    '__path__': '__main__',
-    'a': [],
-    'gc': 1,
-}
-
-del d['a']
-assert 'a' not in d
-assert d['gc'] == 1

tests/71_gc_bug.py

@@ -1,35 +0,0 @@
-# a=[]
-# import gc
-# gc.collect()
-
-# # a.append(a)
-# print(globals().items())
-# del a
-# print(list(globals().items()))
-# print(globals()['gc'])
-# gc.collect()
-
-d = object()
-d.__name__ = '__main__'
-d.__package__ = ''
-d.__path__ = '__main__'
-d.a = []
-d.gc = 1
-
-print('-' * 100)
-assert d.gc == 1
-del d.a
-
-assert not hasattr(d, 'a')
-assert d.gc == 1
-
-# [0, 1, 6, 7, 4, 5, 2, 3]
-
-# 0 __name__      [0]
-# 1 __package__   [1]
-# 2 nil
-# 3 nil
-# 4 gc            [4]
-# 5 nil
-# 6 __path__      [2]
-# 7 a             [3]