intern ascii literals

include/pocketpy/interpreter/heap.h

@@ -3,7 +3,7 @@
 
 typedef struct ManagedHeap {
     MultiPool small_objects;
-    c11_vector large_objects;
+    c11_vector /* PyObject* */ large_objects;
 
     int freed_ma[3];
     int gc_threshold;  // threshold for gc_counter

include/pocketpy/interpreter/vm.h

@@ -27,6 +27,8 @@ typedef struct VM {
 
     py_Callbacks callbacks;
 
+    py_TValue ascii_literals[128+1];
+
     py_TValue last_retval;
     py_TValue curr_exception;
     volatile bool is_signal_interrupted;

src/interpreter/heap.c

@@ -63,14 +63,13 @@ int ManagedHeap__sweep(ManagedHeap* self) {
         } else {
             PyObject__dtor(obj);
             PK_FREE(obj);
-            // type and module objects are perpectual
-            assert(obj->type != tp_type);
-            assert(obj->type != tp_module);
         }
     }
     // shrink `self->large_objects`
     int large_freed = self->large_objects.length - large_living_count;
     self->large_objects.length = large_living_count;
+    // printf("large_freed=%d\n", large_freed);
+    // printf("small_freed=%d\n", small_freed);
     return small_freed + large_freed;
 }
 

src/interpreter/vm.c

@@ -83,6 +83,12 @@ void VM__ctor(VM* self) {
     ValueStack__ctor(&self->stack);
 
     /* Init Builtin Types */
+    for(int i = 0; i < 128; i++) {
+        char* p = py_newstrn(&self->ascii_literals[i], 1);
+        *p = i;
+    }
+    py_newstrn(&self->ascii_literals[128], 0);
+
     // 0: unused
     void* placeholder = TypeList__emplace(&self->types);
     memset(placeholder, 0, sizeof(py_TypeInfo));
@@ -153,7 +159,7 @@ void VM__ctor(VM* self) {
 
     validate(tp_StopIteration, pk_StopIteration__register());
     py_setdict(&self->builtins, py_name("StopIteration"), py_tpobject(tp_StopIteration));
-    
+
     INJECT_BUILTIN_EXC(SyntaxError, tp_Exception);
     INJECT_BUILTIN_EXC(StackOverflowError, tp_Exception);
     INJECT_BUILTIN_EXC(OSError, tp_Exception);
@@ -224,8 +230,8 @@ void VM__ctor(VM* self) {
     pk__add_module_importlib();
 
     pk__add_module_conio();
-    pk__add_module_lz4();       // optional
-    pk__add_module_libhv();     // optional
+    pk__add_module_lz4();    // optional
+    pk__add_module_libhv();  // optional
     pk__add_module_pkpy();
 
     // add python builtins
@@ -509,7 +515,7 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
                 memcpy(argv, self->__vectorcall_buffer, co->nlocals * sizeof(py_TValue));
                 Frame* frame = Frame__new(co, &fn->module, p0, argv, true);
                 pk_newgenerator(py_retval(), frame, p0, self->stack.sp);
-                self->stack.sp = p0;    // reset the stack
+                self->stack.sp = p0;  // reset the stack
                 return RES_RETURN;
             }
             default: c11__unreachable();
@@ -636,15 +642,14 @@ void CodeObject__gc_mark(const CodeObject* self) {
 
 void ManagedHeap__mark(ManagedHeap* self) {
     VM* vm = pk_current_vm;
-    // mark large objects
-    for(int i = 0; i < self->large_objects.length; i++) {
-        PyObject* obj = c11__getitem(PyObject*, &self->large_objects, i);
-        mark_object(obj);
-    }
     // mark value stack
     for(py_TValue* p = vm->stack.begin; p != vm->stack.end; p++) {
         pk__mark_value(p);
     }
+    // mark ascii literals
+    for(int i = 0; i < c11__count_array(vm->ascii_literals); i++) {
+        pk__mark_value(&vm->ascii_literals[i]);
+    }
     // mark modules
     ModuleDict__apply_mark(&vm->modules, mark_object);
     // mark types

src/modules/pkpy.c

@@ -45,8 +45,10 @@ static bool pkpy_memory_usage(int argc, py_Ref argv) {
     c11_sbuf__write_cstr(&buf, "== heap.small_objects ==\n");
     c11_sbuf__write_cstr(&buf, small_objects_usage->data);
     c11_sbuf__write_cstr(&buf, "== heap.large_objects ==\n");
-    c11_sbuf__write_cstr(&buf, "len(large_objects)=");
-    c11_sbuf__write_int(&buf, large_object_count);
+    pk_sprintf(&buf, "len(large_objects)=%d\n", large_object_count);
+    c11_sbuf__write_cstr(&buf, "== heap.gc ==\n");
+    pk_sprintf(&buf, "gc_counter=%d\n", heap->gc_counter);
+    pk_sprintf(&buf, "gc_threshold=%d", heap->gc_threshold);
     // c11_sbuf__write_cstr(&buf, "== vm.pool_frame ==\n");
     c11_sbuf__py_submit(&buf, py_retval());
     c11_string__delete(small_objects_usage);

src/public/modules.c

@@ -204,13 +204,13 @@ static bool builtins_input(int argc, py_Ref argv) {
         if(!py_checkstr(argv)) return false;
         prompt = py_tostr(argv);
     }
-    printf("%s", prompt);
+    pk_current_vm->callbacks.print(prompt);
 
     c11_sbuf buf;
     c11_sbuf__ctor(&buf);
     while(true) {
         int c = pk_current_vm->callbacks.getchar();
-        if(c == '\n') break;
+        if(c == '\n' || c == '\r') break;
         if(c == EOF) break;
         c11_sbuf__write_char(&buf, c);
     }
@@ -456,8 +456,7 @@ static bool builtins_chr(int argc, py_Ref argv) {
     PY_CHECK_ARG_TYPE(0, tp_int);
     py_i64 val = py_toint(py_arg(0));
     if(val < 0 || val > 128) { return ValueError("chr() arg not in range(128)"); }
-    char* data = py_newstrn(py_retval(), 1);
-    data[0] = (char)val;
+    py_assign(py_retval(), &pk_current_vm->ascii_literals[val]);
     return true;
 }
 

src/public/py_str.c

@@ -21,6 +21,17 @@ char* py_newstrn(py_Ref out, int size) {
 }
 
 void py_newstrv(py_OutRef out, c11_sv sv) {
+    if(sv.size == 0) {
+        *out = pk_current_vm->ascii_literals[128];
+        return;
+    }
+    if(sv.size == 1) {
+        int c = sv.data[0];
+        if(c >= 0 && c < 128) {
+            *out = pk_current_vm->ascii_literals[c];
+            return;
+        }
+    }
     char* data = py_newstrn(out, sv.size);
     memcpy(data, sv.data, sv.size);
 }

tests/04_str.py

@@ -190,6 +190,8 @@ assert (1 != '1') is True
 assert (1 == '1') is False
 assert 1 == 1.0
 
+assert chr(97) is 'a'
+
 exit()
 
 # test format()