some fix

include/pocketpy/common/algorithm.h

@@ -12,7 +12,7 @@ extern "C" {
     do {                                                                                           \
         T* __first = ptr;                                                                          \
         int __len = count;                                                                         \
-        while(__len != 0) {                                                                        \
+        while(__len > 8) {                                                                         \
             int __l2 = __len >> 1;                                                                 \
             T* __m = __first + __l2;                                                               \
             if(less((*__m), (key))) {                                                              \
@@ -22,6 +22,10 @@ extern "C" {
                 __len = __l2;                                                                      \
             }                                                                                      \
         }                                                                                          \
+        while(__len && less(*__first, (key))) {                                                    \
+            ++__first;                                                                             \
+            --__len;                                                                               \
+        }                                                                                          \
         *(out_index) = __first - (T*)(ptr);                                                        \
     } while(0)
 
@@ -30,7 +34,8 @@ extern "C" {
  * @param ptr Pointer to the first element of the array.
  * @param count Number of elements in the array.
  * @param elem_size Size of each element in the array.
- * @param cmp Comparison function that takes two elements and returns an integer similar to `strcmp`.
+ * @param cmp Comparison function that takes two elements and returns an integer similar to
+ * `strcmp`.
  */
 void c11__stable_sort(void* ptr,
                       int count,

include/pocketpy/common/sstream.h

@@ -10,27 +10,28 @@
 extern "C" {
 #endif
 
-typedef struct pk_SStream {
+typedef struct c11_sbuf {
     c11_vector data;
-} pk_SStream;
+} c11_sbuf;
 
-void pk_SStream__ctor(pk_SStream* self);
-void pk_SStream__dtor(pk_SStream* self);
+void c11_sbuf__ctor(c11_sbuf* self);
+void c11_sbuf__dtor(c11_sbuf* self);
 
-void pk_SStream__write_int(pk_SStream* self, int);
-void pk_SStream__write_i64(pk_SStream* self, int64_t);
-void pk_SStream__write_f64(pk_SStream* self, double, int precision);
-void pk_SStream__write_char(pk_SStream* self, char);
-void pk_SStream__write_sv(pk_SStream* self, c11_sv);
-void pk_SStream__write_cstr(pk_SStream* self, const char*);
-void pk_SStream__write_cstrn(pk_SStream* self, const char*, int);
-void pk_SStream__write_hex(pk_SStream* self, unsigned char, bool non_zero);
-void pk_SStream__write_ptr(pk_SStream* self, void*);
+void c11_sbuf__write_int(c11_sbuf* self, int);
+void c11_sbuf__write_i64(c11_sbuf* self, int64_t);
+void c11_sbuf__write_f64(c11_sbuf* self, double, int precision);
+void c11_sbuf__write_char(c11_sbuf* self, char);
+void c11_sbuf__write_sv(c11_sbuf* self, c11_sv);
+void c11_sbuf__write_cstr(c11_sbuf* self, const char*);
+void c11_sbuf__write_cstrn(c11_sbuf* self, const char*, int);
+void c11_sbuf__write_quoted(c11_sbuf* self, c11_sv, char quote);
+void c11_sbuf__write_hex(c11_sbuf* self, unsigned char, bool non_zero);
+void c11_sbuf__write_ptr(c11_sbuf* self, void*);
 // Submit the stream and return the final string. The stream becomes invalid after this call
-c11_string* pk_SStream__submit(pk_SStream* self);
+c11_string* c11_sbuf__submit(c11_sbuf* self);
 
-void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args);
-void pk_sprintf(pk_SStream* ss, const char* fmt, ...);
+void pk_vsprintf(c11_sbuf* ss, const char* fmt, va_list args);
+void pk_sprintf(c11_sbuf* ss, const char* fmt, ...);
 
 #ifdef __cplusplus
 }

include/pocketpy/common/str.h

@@ -48,7 +48,6 @@ c11_sv c11_string__u8_getitem(c11_string* self, int i);
 c11_string* c11_string__u8_slice(c11_string* self, int start, int stop, int step);
 
 // general string operations
-void c11_sv__quote(c11_sv sv, char quote, c11_vector* buf);
 void c11_sv__lower(c11_sv sv, c11_vector* buf);
 void c11_sv__upper(c11_sv sv, c11_vector* buf);
 c11_sv c11_sv__slice(c11_sv sv, int start);

include/pocketpy/common/strname.h

@@ -1,27 +1,17 @@
 #pragma once
 
 #include <stdint.h>
-#include "pocketpy/pocketpy.h"
 #include "pocketpy/common/str.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef uint16_t StrName;
+uint16_t py_name2(c11_sv name);
+c11_sv py_name2sv(uint16_t index);
 
-uint16_t pk_StrName__map(const char*);
-uint16_t pk_StrName__map2(c11_sv);
-const char* pk_StrName__rmap(uint16_t index);
-c11_sv pk_StrName__rmap2(uint16_t index);
-
-void pk_StrName__initialize();
-void pk_StrName__finalize();
-
-extern uint16_t pk_id_add;
-extern uint16_t pk_id_set;
-extern uint16_t pk_id_long;
-extern uint16_t pk_id_complex;
+void py_Name__initialize();
+void py_Name__finalize();
 
 #ifdef __cplusplus
 }

include/pocketpy/interpreter/vm.h

@@ -19,7 +19,7 @@ typedef struct pk_TypeInfo {
     void (*dtor)(void*);
     void (*gc_mark)(void*);
 
-    c11_vector /*T=StrName*/ annotated_fields;
+    c11_vector /*T=py_Name*/ annotated_fields;
 
     py_CFunction on_end_subclass;  // backdoor for enum module
 

include/pocketpy/objects/base.h

@@ -13,8 +13,9 @@
 extern "C" {
 #endif
 
-typedef int16_t py_Type;
 typedef struct PyObject PyObject;
+typedef struct pk_VM pk_VM;
+extern pk_VM* pk_current_vm;
 
 typedef struct py_TValue {
     py_Type type;
@@ -35,19 +36,6 @@ typedef struct py_TValue {
 static_assert(sizeof(py_CFunction) <= 8, "sizeof(py_CFunction) > 8");
 static_assert(sizeof(py_TValue) == 16, "sizeof(py_TValue) != 16");
 
-/* predefined vars */
-const static py_Type tp_object = {1}, tp_type = {2};
-const static py_Type tp_int = {3}, tp_float = {4}, tp_bool = {5}, tp_str = {6};
-const static py_Type tp_list = {7}, tp_tuple = {8};
-const static py_Type tp_slice = {9}, tp_range = {10}, tp_module = {11};
-const static py_Type tp_function = {12}, tp_nativefunc = {13}, tp_bound_method = {14};
-const static py_Type tp_super = {15}, tp_exception = {16}, tp_bytes = {17}, tp_mappingproxy = {18};
-const static py_Type tp_dict = {19}, tp_property = {20}, tp_star_wrapper = {21};
-const static py_Type tp_staticmethod = {22}, tp_classmethod = {23};
-const static py_Type tp_none_type = {24}, tp_not_implemented_type = {25};
-const static py_Type tp_ellipsis = {26};
-const static py_Type tp_syntax_error = {27}, tp_stop_iteration = {28};
-
 extern py_TValue PY_NULL;
 
 #ifdef __cplusplus

include/pocketpy/objects/codeobject.h

@@ -74,7 +74,7 @@ typedef struct CodeObject {
     c11_vector/*T=CodeObjectByteCodeEx*/    codes_ex;
 
     c11_vector/*T=py_TValue*/   consts;     // constants
-    c11_vector/*T=StrName*/ varnames;   // local variables
+    c11_vector/*T=py_Name*/ varnames;   // local variables
     int nlocals;                        // cached varnames.size()
 
     c11_smallmap_n2i varnames_inv;

include/pocketpy/objects/error.h

@@ -17,7 +17,7 @@ extern "C" {
 // } pkpy_ExceptionFrame;
 
 // typedef struct pkpy_Exception {
-//     StrName type;
+//     py_Name type;
 //     py_Str msg;
 //     bool is_re;
 
@@ -29,7 +29,7 @@ extern "C" {
 //     c11_vector/*T=pkpy_ExceptionFrame*/ stacktrace;
 // } pkpy_Exception;
 
-// void pkpy_Exception__ctor(pkpy_Exception* self, StrName type);
+// void pkpy_Exception__ctor(pkpy_Exception* self, py_Name type);
 // void pkpy_Exception__dtor(pkpy_Exception* self);
 // void pkpy_Exception__stpush(pkpy_Exception* self, pk_SourceData_ src, int lineno, const char* cursor, const char* name);
 // py_Str pkpy_Exception__summary(pkpy_Exception* self);

include/pocketpy/pocketpy.h

@@ -6,7 +6,6 @@
 
 /************* Public Types *************/
 typedef struct py_TValue py_TValue;
-typedef struct pk_VM pk_VM;
 typedef uint16_t py_Name;
 typedef int16_t py_Type;
 
@@ -36,8 +35,6 @@ typedef enum BindType {
     BindType_CLASSMETHOD,
 } BindType;
 
-extern pk_VM* pk_current_vm;
-
 /************* Global VMs *************/
 void py_initialize();
 void py_finalize();
@@ -142,18 +139,17 @@ void py_bindmethod2(py_Type type, const char* name, py_CFunction f, BindType bt)
 void py_bindnativefunc(py_Ref obj, const char* name, py_CFunction f);
 
 /// Get the reference to the i-th register.
+/// All registers are located in a contiguous memory.
 py_GlobalRef py_reg(int i);
 
 /// Get the reference of the object's `__dict__`.
 /// The object must have a `__dict__`.
 /// Returns a reference to the value or NULL if not found.
-/// @lifespan: Object.
 py_ObjectRef py_getdict(const py_Ref self, py_Name name);
 void py_setdict(py_Ref self, py_Name name, const py_Ref val);
 
 /// Get the reference of the i-th slot of the object.
 /// The object must have slots and `i` must be in range.
-/// @lifespan: Object.
 py_ObjectRef py_getslot(const py_Ref self, int i);
 void py_setslot(py_Ref self, int i, const py_Ref val);
 
@@ -320,15 +316,34 @@ bool py_checktype(const py_Ref self, py_Type type);
 /// %i: py_i64 (int64_t)
 /// %f: py_f64 (double)
 /// %s: const char*
-/// %q: single quoted %s
+/// %q: c11_sv
+/// %v: c11_sv
 /// %c: char
 /// %p: void*
 /// %t: py_Type
 /// %n: py_Name
 
-#define MAGIC_METHOD(x) extern uint16_t x;
-#include "pocketpy/xmacros/magics.h"
-#undef MAGIC_METHOD
+
+enum py_MagicNames{
+    py_MagicNames__NULL,  // 0 is reserved
+    #define MAGIC_METHOD(x) x,
+    #include "pocketpy/xmacros/magics.h"
+    #undef MAGIC_METHOD
+};
+
+enum py_PredefinedTypes{
+    tp_object = 1, tp_type,
+    tp_int, tp_float, tp_bool, tp_str,
+    tp_list, tp_tuple,
+    tp_slice, tp_range, tp_module,
+    tp_function, tp_nativefunc, tp_bound_method,
+    tp_super, tp_exception, tp_bytes, tp_mappingproxy,
+    tp_dict, tp_property, tp_star_wrapper,
+    tp_staticmethod, tp_classmethod,
+    tp_none_type, tp_not_implemented_type,
+    tp_ellipsis,
+    tp_syntax_error, tp_stop_iteration
+};
 
 #ifdef __cplusplus
 }

include/pocketpy/xmacros/smallmap.h

@@ -86,19 +86,11 @@ void METHOD(set)(NAME* self, K key, V value) {
 }
 
 V* METHOD(try_get)(const NAME* self, K key) {
-    // use `bsearch` which is faster than `lower_bound`
-    int low = 0;
-    int high = self->count - 1;
-    KV* a = self->data;
-    while(low <= high){
-        int mid = (low + high) / 2;
-        if(equal(a[mid].key, key)){
-            return &a[mid].value;
-        } else if(less(a[mid].key, key)){
-            low = mid + 1;
-        } else {
-            high = mid - 1;
-        }
+    int index;
+    c11__lower_bound(KV, self->data, self->count, key, partial_less, &index);
+    if(index != self->count){
+        KV* it = c11__at(KV, self, index);
+        if(equal(it->key, key)) return &it->value;
     }
     return NULL;
 }

src/common/sourcedata.c

@@ -17,15 +17,15 @@ static void pk_SourceData__ctor(struct pk_SourceData* self,
     // Skip utf8 BOM if there is any.
     if(strncmp(source, "\xEF\xBB\xBF", 3) == 0) source += 3;
     // Drop all '\r'
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
+    c11_sbuf ss;
+    c11_sbuf__ctor(&ss);
     while(true) {
         char c = *source;
         if(c == '\0') break;
-        if(c != '\r') pk_SStream__write_char(&ss, c);
+        if(c != '\r') c11_sbuf__write_char(&ss, c);
         source++;
     }
-    self->source = pk_SStream__submit(&ss);
+    self->source = c11_sbuf__submit(&ss);
     self->is_precompiled = (strncmp(source, "pkpy:", 5) == 0);
     c11_vector__push(const char*, &self->line_starts, self->source->data);
 }
@@ -74,37 +74,37 @@ c11_string* pk_SourceData__snapshot(const struct pk_SourceData* self,
                                int lineno,
                                const char* cursor,
                                const char* name) {
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
+    c11_sbuf ss;
+    c11_sbuf__ctor(&ss);
 
     pk_sprintf(&ss, "  File \"%s\", line %d", self->filename->data, lineno);
 
     if(name && *name) {
-        pk_SStream__write_cstr(&ss, ", in ");
-        pk_SStream__write_cstr(&ss, name);
+        c11_sbuf__write_cstr(&ss, ", in ");
+        c11_sbuf__write_cstr(&ss, name);
     }
 
     if(!self->is_precompiled) {
-        pk_SStream__write_char(&ss, '\n');
+        c11_sbuf__write_char(&ss, '\n');
         const char *st = NULL, *ed;
         if(pk_SourceData__get_line(self, lineno, &st, &ed)) {
             while(st < ed && isblank(*st))
                 ++st;
             if(st < ed) {
-                pk_SStream__write_cstr(&ss, "    ");
-                pk_SStream__write_cstrn(&ss, st, ed - st);
+                c11_sbuf__write_cstr(&ss, "    ");
+                c11_sbuf__write_cstrn(&ss, st, ed - st);
                 if(cursor && st <= cursor && cursor <= ed) {
-                    pk_SStream__write_cstr(&ss, "\n    ");
+                    c11_sbuf__write_cstr(&ss, "\n    ");
                     for(int i = 0; i < (cursor - st); ++i)
-                        pk_SStream__write_char(&ss, ' ');
-                    pk_SStream__write_cstr(&ss, "^");
+                        c11_sbuf__write_char(&ss, ' ');
+                    c11_sbuf__write_cstr(&ss, "^");
                 }
             } else {
                 st = NULL;
             }
         }
 
-        if(!st) { pk_SStream__write_cstr(&ss, "    <?>"); }
+        if(!st) { c11_sbuf__write_cstr(&ss, "    <?>"); }
     }
-    return pk_SStream__submit(&ss);
+    return c11_sbuf__submit(&ss);
 }

src/common/sstream.c

@@ -12,37 +12,37 @@
 
 const static int C11_STRING_HEADER_SIZE = sizeof(c11_string);
 
-void pk_SStream__ctor(pk_SStream* self) {
+void c11_sbuf__ctor(c11_sbuf* self) {
     c11_vector__ctor(&self->data, sizeof(char));
     c11_vector__reserve(&self->data, 100 + C11_STRING_HEADER_SIZE);
     self->data.count = C11_STRING_HEADER_SIZE;
 }
 
-void pk_SStream__dtor(pk_SStream* self) { c11_vector__dtor(&self->data); }
+void c11_sbuf__dtor(c11_sbuf* self) { c11_vector__dtor(&self->data); }
 
-void pk_SStream__write_char(pk_SStream* self, char c) { c11_vector__push(char, &self->data, c); }
+void c11_sbuf__write_char(c11_sbuf* self, char c) { c11_vector__push(char, &self->data, c); }
 
-void pk_SStream__write_int(pk_SStream* self, int i) {
+void c11_sbuf__write_int(c11_sbuf* self, int i) {
     // len('-2147483648') == 11
     c11_vector__reserve(&self->data, self->data.count + 11 + 1);
     int n = snprintf(self->data.data, 11 + 1, "%d", i);
     self->data.count += n;
 }
 
-void pk_SStream__write_i64(pk_SStream* self, int64_t val) {
+void c11_sbuf__write_i64(c11_sbuf* self, int64_t val) {
     // len('-9223372036854775808') == 20
     c11_vector__reserve(&self->data, self->data.count + 20 + 1);
     int n = snprintf(self->data.data, 20 + 1, "%lld", (long long)val);
     self->data.count += n;
 }
 
-void pk_SStream__write_f64(pk_SStream* self, double val, int precision) {
+void c11_sbuf__write_f64(c11_sbuf* self, double val, int precision) {
     if(isinf(val)) {
-        pk_SStream__write_cstr(self, val > 0 ? "inf" : "-inf");
+        c11_sbuf__write_cstr(self, val > 0 ? "inf" : "-inf");
         return;
     }
     if(isnan(val)) {
-        pk_SStream__write_cstr(self, "nan");
+        c11_sbuf__write_cstr(self, "nan");
         return;
     }
     char b[32];
@@ -54,7 +54,7 @@ void pk_SStream__write_f64(pk_SStream* self, double val, int precision) {
         int prec = precision;
         size = snprintf(b, sizeof(b), "%.*f", prec, val);
     }
-    pk_SStream__write_cstr(self, b);
+    c11_sbuf__write_cstr(self, b);
     bool all_is_digit = true;
     for(int i = 1; i < size; i++) {
         if(!isdigit(b[i])) {
@@ -62,49 +62,78 @@ void pk_SStream__write_f64(pk_SStream* self, double val, int precision) {
             break;
         }
     }
-    if(all_is_digit) pk_SStream__write_cstr(self, ".0");
+    if(all_is_digit) c11_sbuf__write_cstr(self, ".0");
 }
 
-void pk_SStream__write_sv(pk_SStream* self, c11_sv sv) {
-    pk_SStream__write_cstrn(self, sv.data, sv.size);
+void c11_sbuf__write_sv(c11_sbuf* self, c11_sv sv) {
+    c11_sbuf__write_cstrn(self, sv.data, sv.size);
 }
 
-void pk_SStream__write_cstr(pk_SStream* self, const char* str) {
-    pk_SStream__write_cstrn(self, str, strlen(str));
+void c11_sbuf__write_cstr(c11_sbuf* self, const char* str) {
+    c11_sbuf__write_cstrn(self, str, strlen(str));
 }
 
-void pk_SStream__write_cstrn(pk_SStream* self, const char* str, int n) {
+void c11_sbuf__write_cstrn(c11_sbuf* self, const char* str, int n) {
     c11_vector__extend(char, &self->data, str, n);
 }
 
-void pk_SStream__write_hex(pk_SStream* self, unsigned char c, bool non_zero) {
+void c11_sbuf__write_quoted(c11_sbuf* self, c11_sv sv, char quote) {
+    assert(quote == '"' || quote == '\'');
+    c11_sbuf__write_char(self, quote);
+    for(int i = 0; i < sv.size; i++) {
+        char c = sv.data[i];
+        switch(c) {
+            case '"':
+            case '\'':
+                if(c == quote) c11_sbuf__write_char(self, '\\');
+                c11_sbuf__write_char(self, c);
+                break;
+            case '\\': c11_sbuf__write_cstrn(self, "\\\\", 2); break;
+            case '\n': c11_sbuf__write_cstrn(self, "\\n", 2); break;
+            case '\r': c11_sbuf__write_cstrn(self, "\\r", 2); break;
+            case '\t': c11_sbuf__write_cstrn(self, "\\t", 2); break;
+            case '\b': c11_sbuf__write_cstrn(self, "\\b", 2); break;
+            default:
+                if('\x00' <= c && c <= '\x1f') {
+                    c11_sbuf__write_cstrn(self, "\\x", 2);
+                    c11_sbuf__write_char(self, PK_HEX_TABLE[c >> 4]);
+                    c11_sbuf__write_char(self, PK_HEX_TABLE[c & 0xf]);
+                } else {
+                    c11_sbuf__write_char(self, c);
+                }
+        }
+    }
+    c11_sbuf__write_char(self, quote);
+}
+
+void c11_sbuf__write_hex(c11_sbuf* self, unsigned char c, bool non_zero) {
     unsigned char high = c >> 4;
     unsigned char low = c & 0xf;
     if(non_zero) {
-        if(high) pk_SStream__write_char(self, PK_HEX_TABLE[high]);
-        if(high || low) pk_SStream__write_char(self, PK_HEX_TABLE[low]);
+        if(high) c11_sbuf__write_char(self, PK_HEX_TABLE[high]);
+        if(high || low) c11_sbuf__write_char(self, PK_HEX_TABLE[low]);
     } else {
-        pk_SStream__write_char(self, PK_HEX_TABLE[high]);
-        pk_SStream__write_char(self, PK_HEX_TABLE[low]);
+        c11_sbuf__write_char(self, PK_HEX_TABLE[high]);
+        c11_sbuf__write_char(self, PK_HEX_TABLE[low]);
     }
 }
 
-void pk_SStream__write_ptr(pk_SStream* self, void* p) {
+void c11_sbuf__write_ptr(c11_sbuf* self, void* p) {
     if(p == NULL) {
-        pk_SStream__write_cstr(self, "0x0");
+        c11_sbuf__write_cstr(self, "0x0");
         return;
     }
-    pk_SStream__write_cstr(self, "0x");
+    c11_sbuf__write_cstr(self, "0x");
     uintptr_t p_t = (uintptr_t)(p);
     bool non_zero = true;
     for(int i = sizeof(void*) - 1; i >= 0; i--) {
         unsigned char cpnt = (p_t >> (i * 8)) & 0xff;
-        pk_SStream__write_hex(self, cpnt, non_zero);
+        c11_sbuf__write_hex(self, cpnt, non_zero);
         if(cpnt != 0) non_zero = false;
     }
 }
 
-c11_string* pk_SStream__submit(pk_SStream* self) {
+c11_string* c11_sbuf__submit(c11_sbuf* self) {
     c11_vector__push(char, &self->data, '\0');
     c11_array arr = c11_vector__submit(&self->data);
     c11_string* retval = (c11_string*)arr.data;
@@ -112,11 +141,11 @@ c11_string* pk_SStream__submit(pk_SStream* self) {
     return retval;
 }
 
-void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
+void pk_vsprintf(c11_sbuf* ss, const char* fmt, va_list args) {
     while(fmt) {
         char c = *fmt;
         if(c != '%') {
-            pk_SStream__write_char(ss, c);
+            c11_sbuf__write_char(ss, c);
             fmt++;
             continue;
         }
@@ -127,53 +156,57 @@ void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
         switch(c) {
             case 'd': {
                 int i = va_arg(args, int);
-                pk_SStream__write_int(ss, i);
+                c11_sbuf__write_int(ss, i);
                 break;
             }
             case 'i': {
                 int64_t i = va_arg(args, int64_t);
-                pk_SStream__write_i64(ss, i);
+                c11_sbuf__write_i64(ss, i);
                 break;
             }
             case 'f': {
                 double d = va_arg(args, double);
-                pk_SStream__write_f64(ss, d, -1);
+                c11_sbuf__write_f64(ss, d, -1);
                 break;
             }
             case 's': {
                 const char* s = va_arg(args, const char*);
-                pk_SStream__write_cstr(ss, s);
+                c11_sbuf__write_cstr(ss, s);
                 break;
             }
             case 'q': {
-                const char* s = va_arg(args, const char*);
-                c11_sv sv = {s, strlen(s)};
-                c11_sv__quote(sv, '\'', &ss->data);
+                c11_sv sv = va_arg(args, c11_sv);
+                c11_sbuf__write_quoted(ss, sv, '\'');
+                break;
+            }
+            case 'v': {
+                c11_sv sv = va_arg(args, c11_sv);
+                c11_sbuf__write_sv(ss, sv);
                 break;
             }
             case 'c': {
                 char c = va_arg(args, int);
-                pk_SStream__write_char(ss, c);
+                c11_sbuf__write_char(ss, c);
                 break;
             }
             case 'p': {
                 void* p = va_arg(args, void*);
-                pk_SStream__write_ptr(ss, p);
+                c11_sbuf__write_ptr(ss, p);
                 break;
             }
             case 't': {
                 py_Type t = va_arg(args, int);
-                pk_SStream__write_cstr(ss, py_tpname(t));
+                c11_sbuf__write_cstr(ss, py_tpname(t));
                 break;
             }
             case 'n': {
                 py_Name n = va_arg(args, int);
-                pk_SStream__write_cstr(ss, py_name2str(n));
+                c11_sbuf__write_cstr(ss, py_name2str(n));
                 break;
             }
-            case '%': pk_SStream__write_char(ss, '%'); break;
+            case '%': c11_sbuf__write_char(ss, '%'); break;
             default:
-                pk_SStream__write_char(ss, c);
+                c11_sbuf__write_char(ss, c);
                 assert(false);  // invalid format
                 break;
         }
@@ -181,7 +214,7 @@ void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
     }
 }
 
-void pk_sprintf(pk_SStream* ss, const char* fmt, ...) {
+void pk_sprintf(c11_sbuf* ss, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
     pk_vsprintf(ss, fmt, args);

src/common/str.c

@@ -58,46 +58,17 @@ c11_sv c11_string__u8_getitem(c11_string* self, int i) {
 }
 
 c11_string* c11_string__u8_slice(c11_string* self, int start, int stop, int step) {
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
+    c11_sbuf ss;
+    c11_sbuf__ctor(&ss);
     assert(step != 0);
     for(int i = start; step > 0 ? i < stop : i > stop; i += step) {
         c11_sv unicode = c11_string__u8_getitem(self, i);
-        pk_SStream__write_sv(&ss, unicode);
+        c11_sbuf__write_sv(&ss, unicode);
     }
-    return pk_SStream__submit(&ss);
+    return c11_sbuf__submit(&ss);
 }
 
 /////////////////////////////////////////
-void c11_sv__quote(c11_sv sv, char quote, c11_vector* buf) {
-    assert(quote == '"' || quote == '\'');
-    c11_vector__push(char, buf, quote);
-    for(int i = 0; i < sv.size; i++) {
-        char c = sv.data[i];
-        switch(c) {
-            case '"':
-            case '\'':
-                if(c == quote) c11_vector__push(char, buf, '\\');
-                c11_vector__push(char, buf, c);
-                break;
-            case '\\': c11_vector__extend(char, buf, "\\\\", 2); break;
-            case '\n': c11_vector__extend(char, buf, "\\n", 2); break;
-            case '\r': c11_vector__extend(char, buf, "\\r", 2); break;
-            case '\t': c11_vector__extend(char, buf, "\\t", 2); break;
-            case '\b': c11_vector__extend(char, buf, "\\b", 2); break;
-            default:
-                if('\x00' <= c && c <= '\x1f') {
-                    c11_vector__extend(char, buf, "\\x", 2);
-                    c11_vector__push(char, buf, PK_HEX_TABLE[c >> 4]);
-                    c11_vector__push(char, buf, PK_HEX_TABLE[c & 0xf]);
-                } else {
-                    c11_vector__push(char, buf, c);
-                }
-        }
-    }
-    c11_vector__push(char, buf, quote);
-}
-
 void c11_sv__lower(c11_sv sv, c11_vector* buf) {
     for(int i = 0; i < sv.size; i++) {
         char c = sv.data[i];

src/common/strname.c

@@ -9,18 +9,15 @@
 // TODO: use a more efficient data structure
 static c11_smallmap_s2n _interned;
 static c11_vector /*T=char* */ _r_interned;
-static bool _initialized = false;
 
-void pk_StrName__initialize() {
-    if(_initialized) return;
+void py_Name__initialize() {
     c11_smallmap_s2n__ctor(&_interned);
     for(int i = 0; i < _r_interned.count; i++) {
         free(c11__at(char*, &_r_interned, i));
     }
     c11_vector__ctor(&_r_interned, sizeof(c11_sv));
-    _initialized = true;
 
-#define MAGIC_METHOD(x) x = pk_StrName__map(#x);
+#define MAGIC_METHOD(x) assert(x == py_name(#x));
 #include "pocketpy/xmacros/magics.h"
 #undef MAGIC_METHOD
 
@@ -28,15 +25,9 @@ void pk_StrName__initialize() {
     for(int i = 0; i < _interned.count; i++) {
         printf("%d: %s\n", i + 1, c11__getitem(char*, &_r_interned, i));
     }
-
-    pk_id_add = pk_StrName__map("add");
-    pk_id_set = pk_StrName__map("set");
-    pk_id_long = pk_StrName__map("long");
-    pk_id_complex = pk_StrName__map("complex");
 }
 
-void pk_StrName__finalize() {
-    if(!_initialized) return;
+void py_Name__finalize() {
     // free all char*
     for(int i = 0; i < _r_interned.count; i++) {
         free(c11__getitem(char*, &_r_interned, i));
@@ -45,19 +36,16 @@ void pk_StrName__finalize() {
     c11_vector__dtor(&_r_interned);
 }
 
-uint16_t pk_StrName__map(const char* name) {
-    return pk_StrName__map2((c11_sv){name, strlen(name)});
+py_Name py_name(const char* name) {
+    return py_name2((c11_sv){name, strlen(name)});
 }
 
-uint16_t pk_StrName__map2(c11_sv name) {
+py_Name py_name2(c11_sv name) {
     // TODO: PK_GLOBAL_SCOPE_LOCK()
-    if(!_initialized) {
-        pk_StrName__initialize();  // lazy init
-    }
     uint16_t index = c11_smallmap_s2n__get(&_interned, name, 0);
     if(index != 0) return index;
     // generate new index
-    if(_interned.count > 65530) { PK_FATAL_ERROR("StrName index overflow\n"); }
+    if(_interned.count > 65530) { PK_FATAL_ERROR("py_Name index overflow\n"); }
     // NOTE: we must allocate the string in the heap so iterators are not invalidated
     char* p = malloc(name.size + 1);
     memcpy(p, name.data, name.size);
@@ -70,35 +58,19 @@ uint16_t pk_StrName__map2(c11_sv name) {
     return index;
 }
 
-const char* pk_StrName__rmap(uint16_t index) {
-    assert(_initialized);
+const char* py_name2str(py_Name index) {
     assert(index > 0 && index <= _interned.count);
     return c11__getitem(char*, &_r_interned, index - 1);
 }
 
-c11_sv pk_StrName__rmap2(uint16_t index) {
-    const char* p = pk_StrName__rmap(index);
+c11_sv py_name2sv(py_Name index) {
+    assert(index > 0 && index <= _interned.count);
+    const char* p = py_name2str(index);
     return (c11_sv){p, strlen(p)};
 }
 
-py_Name py_name(const char* name) {
-    return pk_StrName__map(name);
-}
-
-const char* py_name2str(py_Name name) {
-    return pk_StrName__rmap(name);
-}
 
 bool py_ismagicname(py_Name name){
     return name <= __missing__;
 }
 
-///////////////////////////////////
-#define MAGIC_METHOD(x) uint16_t x;
-#include "pocketpy/xmacros/magics.h"
-#undef MAGIC_METHOD
-
-uint16_t pk_id_add;
-uint16_t pk_id_set;
-uint16_t pk_id_long;
-uint16_t pk_id_complex;

src/compiler/compiler.c

@@ -64,7 +64,7 @@ typedef struct Ctx {
     int curr_iblock;
     bool is_compiling_class;
     c11_vector /*T=Expr* */ s_expr;
-    c11_vector /*T=StrName*/ global_names;
+    c11_vector /*T=py_Name*/ global_names;
     c11_smallmap_s2n co_consts_string_dedup_map;
 } Ctx;
 
@@ -80,11 +80,11 @@ int Ctx__emit_virtual(Ctx* self, Opcode opcode, uint16_t arg, int line, bool vir
 void Ctx__revert_last_emit_(Ctx* self);
 int Ctx__emit_int(Ctx* self, int64_t value, int line);
 void Ctx__patch_jump(Ctx* self, int index);
-bool Ctx__add_label(Ctx* self, StrName name);
-int Ctx__add_varname(Ctx* self, StrName name);
+bool Ctx__add_label(Ctx* self, py_Name name);
+int Ctx__add_varname(Ctx* self, py_Name name);
 int Ctx__add_const(Ctx* self, py_Ref);
 int Ctx__add_const_string(Ctx* self, c11_sv);
-void Ctx__emit_store_name(Ctx* self, NameScope scope, StrName name, int line);
+void Ctx__emit_store_name(Ctx* self, NameScope scope, py_Name name, int line);
 void Ctx__try_merge_for_iter_store(Ctx* self, int);
 void Ctx__s_emit_top(Ctx*);     // emit top -> pop -> delete
 void Ctx__s_push(Ctx*, Expr*);  // push
@@ -97,7 +97,7 @@ void Ctx__s_emit_decorators(Ctx*, int count);
 /* expr.c */
 typedef struct NameExpr {
     EXPR_COMMON_HEADER
-    StrName name;
+    py_Name name;
     NameScope scope;
 } NameExpr;
 
@@ -144,7 +144,7 @@ bool NameExpr__emit_store(Expr* self_, Ctx* ctx) {
     return true;
 }
 
-NameExpr* NameExpr__new(int line, StrName name, NameScope scope) {
+NameExpr* NameExpr__new(int line, py_Name name, NameScope scope) {
     const static ExprVt Vt = {.emit_ = NameExpr__emit_,
                               .emit_del = NameExpr__emit_del,
                               .emit_store = NameExpr__emit_store,
@@ -630,8 +630,8 @@ static void _load_simple_expr(Ctx* ctx, c11_sv expr, int line) {
     // name or name.name
     bool is_fastpath = false;
     if(is_identifier(expr)) {
-        // ctx->emit_(OP_LOAD_NAME, StrName(expr.sv()).index, line);
-        Ctx__emit_(ctx, OP_LOAD_NAME, pk_StrName__map2(expr), line);
+        // ctx->emit_(OP_LOAD_NAME, py_Name(expr.sv()).index, line);
+        Ctx__emit_(ctx, OP_LOAD_NAME, py_name2(expr), line);
         is_fastpath = true;
     } else {
         int dot = c11_sv__index(expr, '.');
@@ -639,8 +639,8 @@ static void _load_simple_expr(Ctx* ctx, c11_sv expr, int line) {
             c11_sv a = {expr.data, dot};                                // expr[:dot]
             c11_sv b = {expr.data + (dot + 1), expr.size - (dot + 1)};  // expr[dot+1:]
             if(is_identifier(a) && is_identifier(b)) {
-                Ctx__emit_(ctx, OP_LOAD_NAME, pk_StrName__map2(a), line);
-                Ctx__emit_(ctx, OP_LOAD_ATTR, pk_StrName__map2(b), line);
+                Ctx__emit_(ctx, OP_LOAD_NAME, py_name2(a), line);
+                Ctx__emit_(ctx, OP_LOAD_ATTR, py_name2(b), line);
                 is_fastpath = true;
             }
         }
@@ -849,7 +849,7 @@ static void BinaryExpr__dtor(Expr* self_) {
     vtdelete(self->rhs);
 }
 
-static Opcode cmp_token2name(TokenIndex token) {
+static py_Name cmp_token2name(TokenIndex token) {
     switch(token) {
         case TK_LT: return __lt__;
         case TK_LE: return __le__;
@@ -1073,7 +1073,7 @@ SubscrExpr* SubscrExpr__new(int line) {
 typedef struct AttribExpr {
     EXPR_COMMON_HEADER
     Expr* child;
-    StrName name;
+    py_Name name;
 } AttribExpr;
 
 void AttribExpr__emit_(Expr* self_, Ctx* ctx) {
@@ -1111,7 +1111,7 @@ bool AttribExpr__emit_istore(Expr* self_, Ctx* ctx) {
     return true;
 }
 
-AttribExpr* AttribExpr__new(int line, Expr* child, StrName name) {
+AttribExpr* AttribExpr__new(int line, Expr* child, py_Name name) {
     const static ExprVt Vt = {.emit_ = AttribExpr__emit_,
                               .emit_del = AttribExpr__emit_del,
                               .emit_store = AttribExpr__emit_store,
@@ -1128,7 +1128,7 @@ AttribExpr* AttribExpr__new(int line, Expr* child, StrName name) {
 }
 
 typedef struct CallExprKwArg {
-    StrName key;
+    py_Name key;
     Expr* val;
 } CallExprKwArg;
 
@@ -1209,7 +1209,7 @@ void Ctx__ctor(Ctx* self, CodeObject* co, FuncDecl* func, int level) {
     self->curr_iblock = 0;
     self->is_compiling_class = false;
     c11_vector__ctor(&self->s_expr, sizeof(Expr*));
-    c11_vector__ctor(&self->global_names, sizeof(StrName));
+    c11_vector__ctor(&self->global_names, sizeof(py_Name));
     c11_smallmap_s2n__ctor(&self->co_consts_string_dedup_map);
 }
 
@@ -1326,14 +1326,14 @@ void Ctx__patch_jump(Ctx* self, int index) {
     Bytecode__set_signed_arg(&co_codes[index], target - index);
 }
 
-bool Ctx__add_label(Ctx* self, StrName name) {
+bool Ctx__add_label(Ctx* self, py_Name name) {
     bool ok = c11_smallmap_n2i__contains(&self->co->labels, name);
     if(ok) return false;
     c11_smallmap_n2i__set(&self->co->labels, name, self->co->codes.count);
     return true;
 }
 
-int Ctx__add_varname(Ctx* self, StrName name) {
+int Ctx__add_varname(Ctx* self, py_Name name) {
     // PK_MAX_CO_VARNAMES will be checked when pop_context(), not here
     int index = c11_smallmap_n2i__get(&self->co->varnames_inv, name, -1);
     if(index >= 0) return index;
@@ -1366,7 +1366,7 @@ int Ctx__add_const(Ctx* self, py_Ref v) {
     return self->co->consts.count - 1;
 }
 
-void Ctx__emit_store_name(Ctx* self, NameScope scope, StrName name, int line) {
+void Ctx__emit_store_name(Ctx* self, NameScope scope, py_Name name, int line) {
     switch(scope) {
         case NAME_LOCAL: Ctx__emit_(self, OP_STORE_FAST, Ctx__add_varname(self, name), line); break;
         case NAME_GLOBAL: Ctx__emit_(self, OP_STORE_GLOBAL, name, line); break;
@@ -1795,11 +1795,11 @@ static Error* exprGroup(Compiler* self) {
 }
 
 static Error* exprName(Compiler* self) {
-    StrName name = pk_StrName__map2(Token__sv(prev()));
+    py_Name name = py_name2(Token__sv(prev()));
     NameScope scope = name_scope(self);
     // promote this name to global scope if needed
     c11_vector* global_names = &ctx()->global_names;
-    c11__foreach(StrName, global_names, it) {
+    c11__foreach(py_Name, global_names, it) {
         if(*it == name) scope = NAME_GLOBAL;
     }
     NameExpr* e = NameExpr__new(prev()->line, name, scope);
@@ -1809,7 +1809,7 @@ static Error* exprName(Compiler* self) {
 
 static Error* exprAttrib(Compiler* self) {
     consume(TK_ID);
-    StrName name = pk_StrName__map2(Token__sv(prev()));
+    py_Name name = py_name2(Token__sv(prev()));
     AttribExpr* e = AttribExpr__new(prev()->line, Ctx__s_popx(ctx()), name);
     Ctx__s_push(ctx(), (Expr*)e);
     return NULL;
@@ -1922,7 +1922,7 @@ static Error* exprCall(Compiler* self) {
         if(curr()->type == TK_RPAREN) break;
         if(curr()->type == TK_ID && next()->type == TK_ASSIGN) {
             consume(TK_ID);
-            StrName key = pk_StrName__map2(Token__sv(prev()));
+            py_Name key = py_name2(Token__sv(prev()));
             consume(TK_ASSIGN);
             check(EXPR(self));
             CallExprKwArg kw = {key, Ctx__s_popx(ctx())};

src/compiler/lexer.c

@@ -276,13 +276,13 @@ static Error* eat_name(pk_Lexer* self){
 static Error* eat_string_until(pk_Lexer* self, char quote, bool raw, c11_string** out) {
     // previous char is quote
     bool quote3 = match_n_chars(self, 2, quote);
-    pk_SStream buff;
-    pk_SStream__ctor(&buff);
+    c11_sbuf buff;
+    c11_sbuf__ctor(&buff);
     while(true) {
         char c = eatchar_include_newline(self);
         if(c == quote) {
             if(quote3 && !match_n_chars(self, 2, quote)) {
-                pk_SStream__write_char(&buff, c);
+                c11_sbuf__write_char(&buff, c);
                 continue;
             }
             break;
@@ -297,34 +297,34 @@ static Error* eat_string_until(pk_Lexer* self, char quote, bool raw, c11_string*
             if(!quote3)
                 return SyntaxError("EOL while scanning string literal");
             else {
-                pk_SStream__write_char(&buff, c);
+                c11_sbuf__write_char(&buff, c);
                 continue;
             }
         }
         if(!raw && c == '\\') {
             switch(eatchar_include_newline(self)) {
-                case '"': pk_SStream__write_char(&buff, '"'); break;
-                case '\'': pk_SStream__write_char(&buff, '\''); break;
-                case '\\': pk_SStream__write_char(&buff, '\\'); break;
-                case 'n': pk_SStream__write_char(&buff, '\n'); break;
-                case 'r': pk_SStream__write_char(&buff, '\r'); break;
-                case 't': pk_SStream__write_char(&buff, '\t'); break;
-                case 'b': pk_SStream__write_char(&buff, '\b'); break;
+                case '"': c11_sbuf__write_char(&buff, '"'); break;
+                case '\'': c11_sbuf__write_char(&buff, '\''); break;
+                case '\\': c11_sbuf__write_char(&buff, '\\'); break;
+                case 'n': c11_sbuf__write_char(&buff, '\n'); break;
+                case 'r': c11_sbuf__write_char(&buff, '\r'); break;
+                case 't': c11_sbuf__write_char(&buff, '\t'); break;
+                case 'b': c11_sbuf__write_char(&buff, '\b'); break;
                 case 'x': {
                     char hex[3] = {eatchar(self), eatchar(self), '\0'};
                     int code;
                     if(sscanf(hex, "%x", &code) != 1) {
                         return SyntaxError("invalid hex char");
                     }
-                    pk_SStream__write_char(&buff, (char)code);
+                    c11_sbuf__write_char(&buff, (char)code);
                 } break;
                 default: return SyntaxError("invalid escape char");
             }
         } else {
-            pk_SStream__write_char(&buff, c);
+            c11_sbuf__write_char(&buff, c);
         }
     }
-    *out = pk_SStream__submit(&buff);
+    *out = c11_sbuf__submit(&buff);
     return NULL;
 }
 
@@ -654,14 +654,14 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
     Error* err = pk_Lexer__process(src, &nexts);
     if(err) return err;
 
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
+    c11_sbuf ss;
+    c11_sbuf__ctor(&ss);
 
     // L1: version string
-    pk_SStream__write_cstr(&ss, "pkpy:" PK_VERSION "\n");
+    c11_sbuf__write_cstr(&ss, "pkpy:" PK_VERSION "\n");
     // L2: mode
-    pk_SStream__write_int(&ss, (int)src->mode);
-    pk_SStream__write_char(&ss, '\n');
+    c11_sbuf__write_int(&ss, (int)src->mode);
+    c11_sbuf__write_char(&ss, '\n');
 
     c11_smallmap_s2n token_indices;
     c11_smallmap_s2n__ctor(&token_indices);
@@ -675,71 +675,71 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
         }
     }
     // L3: raw string count
-    pk_SStream__write_char(&ss, '=');
-    pk_SStream__write_int(&ss, token_indices.count);
-    pk_SStream__write_char(&ss, '\n');
+    c11_sbuf__write_char(&ss, '=');
+    c11_sbuf__write_int(&ss, token_indices.count);
+    c11_sbuf__write_char(&ss, '\n');
 
     uint16_t index = 0;
     for(int i=0; i<token_indices.count; i++){
         c11_smallmap_s2n_KV* kv = c11__at(c11_smallmap_s2n_KV, &token_indices, i);
         // L4: raw strings
-        pk_SStream__write_cstrn(&ss, kv->key.data, kv->key.size);
+        c11_sbuf__write_cstrn(&ss, kv->key.data, kv->key.size);
         kv->value = index++;
     }
 
     // L5: token count
-    pk_SStream__write_char(&ss, '=');
-    pk_SStream__write_int(&ss, nexts.count);
-    pk_SStream__write_char(&ss, '\n');
+    c11_sbuf__write_char(&ss, '=');
+    c11_sbuf__write_int(&ss, nexts.count);
+    c11_sbuf__write_char(&ss, '\n');
 
     for(int i = 0; i < nexts.count; i++) {
         const Token* token = c11__at(Token, &nexts, i);
-        pk_SStream__write_int(&ss, (int)token->type);
-        pk_SStream__write_char(&ss, ',');
+        c11_sbuf__write_int(&ss, (int)token->type);
+        c11_sbuf__write_char(&ss, ',');
 
         if(is_raw_string_used(token->type)) {
             uint16_t *p = c11_smallmap_s2n__try_get(
                 &token_indices, (c11_sv){token->start, token->length});
             assert(p != NULL);
-            pk_SStream__write_int(&ss, (int)*p);
-            pk_SStream__write_char(&ss, ',');
+            c11_sbuf__write_int(&ss, (int)*p);
+            c11_sbuf__write_char(&ss, ',');
         }
         if(i > 0 && c11__getitem(Token, &nexts, i-1).line == token->line){
-            pk_SStream__write_char(&ss, ',');
+            c11_sbuf__write_char(&ss, ',');
         }else{
-            pk_SStream__write_int(&ss, token->line);
-            pk_SStream__write_char(&ss, ',');
+            c11_sbuf__write_int(&ss, token->line);
+            c11_sbuf__write_char(&ss, ',');
         }
             
         if(i > 0 && c11__getitem(Token, &nexts, i-1).brackets_level == token->brackets_level){
-            pk_SStream__write_char(&ss, ',');
+            c11_sbuf__write_char(&ss, ',');
         }else{
-            pk_SStream__write_int(&ss, token->brackets_level);
-            pk_SStream__write_char(&ss, ',');
+            c11_sbuf__write_int(&ss, token->brackets_level);
+            c11_sbuf__write_char(&ss, ',');
         }
         // visit token value
         switch(token->value.index){
             case TokenValue_EMPTY: break;
             case TokenValue_I64:
-                pk_SStream__write_char(&ss, 'I');
-                pk_SStream__write_int(&ss, token->value._i64);
+                c11_sbuf__write_char(&ss, 'I');
+                c11_sbuf__write_int(&ss, token->value._i64);
                 break;
             case TokenValue_F64:
-                pk_SStream__write_char(&ss, 'F');
-                pk_SStream__write_f64(&ss, token->value._f64, -1);
+                c11_sbuf__write_char(&ss, 'F');
+                c11_sbuf__write_f64(&ss, token->value._f64, -1);
                 break;
             case TokenValue_STR: {
-                pk_SStream__write_char(&ss, 'S');
+                c11_sbuf__write_char(&ss, 'S');
                 c11_sv sv = c11_string__sv(token->value._str);
                 for(int i=0; i<sv.size; i++){
-                    pk_SStream__write_hex(&ss, sv.data[i], false);
+                    c11_sbuf__write_hex(&ss, sv.data[i], false);
                 }
                 break;
             }
         }
-        pk_SStream__write_char(&ss, '\n');
+        c11_sbuf__write_char(&ss, '\n');
     }
-    *out = pk_SStream__submit(&ss);
+    *out = c11_sbuf__submit(&ss);
     c11_smallmap_s2n__dtor(&token_indices);
     return NULL;
 }
@@ -803,8 +803,8 @@ c11_sv TokenDeserializer__read_string(TokenDeserializer* self, char c){
 c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c){
     c11_sv sv = TokenDeserializer__read_string(self, c);
     const char* s = sv.data;
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
+    c11_sbuf ss;
+    c11_sbuf__ctor(&ss);
     for(int i = 0; i < sv.size; i += 2) {
         char c = 0;
         if(s[i] >= '0' && s[i] <= '9')
@@ -820,9 +820,9 @@ c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, cha
             c += s[i + 1] - 'a' + 10;
         else
             assert(false);
-        pk_SStream__write_char(&ss, c);
+        c11_sbuf__write_char(&ss, c);
     }
-    return pk_SStream__submit(&ss);
+    return c11_sbuf__submit(&ss);
 }
 
 int TokenDeserializer__read_count(TokenDeserializer* self){

src/error.c

@@ -2,7 +2,7 @@
 // #include "pocketpy/common/strname.h"
 // #include "pocketpy/common/sstream.h"
 
-// void pkpy_Exception__ctor(pkpy_Exception* self, StrName type){
+// void pkpy_Exception__ctor(pkpy_Exception* self, py_Name type){
 //     self->type = type;
 //     self->is_re = true;
 //     self->_ip_on_error = -1;
@@ -34,26 +34,26 @@
 // }
 
 // py_Str pkpy_Exception__summary(pkpy_Exception* self){
-//     pk_SStream ss;
-//     pk_SStream__ctor(&ss);
+//     c11_sbuf ss;
+//     c11_sbuf__ctor(&ss);
 
 //     if(self->is_re){
-//         pk_SStream__write_cstr(&ss, "Traceback (most recent call last):\n");
+//         c11_sbuf__write_cstr(&ss, "Traceback (most recent call last):\n");
 //     }
 //     for(int i=self->stacktrace.count-1; i >= 0; i--) {
 //         pkpy_ExceptionFrame* frame = c11__at(pkpy_ExceptionFrame, &self->stacktrace, i);
 //         py_Str s = pk_SourceData__snapshot(frame->src, frame->lineno, frame->cursor, py_Str__data(&frame->name));
-//         pk_SStream__write_Str(&ss, &s);
+//         c11_sbuf__write_Str(&ss, &s);
 //         py_Str__dtor(&s);
-//         pk_SStream__write_cstr(&ss, "\n");
+//         c11_sbuf__write_cstr(&ss, "\n");
 //     }
 
-//     const char* name = pk_StrName__rmap(self->type);
-//     pk_SStream__write_cstr(&ss, name);
+//     const char* name = py_Name__rmap(self->type);
+//     c11_sbuf__write_cstr(&ss, name);
 
 //     if(self->msg.size > 0){
-//         pk_SStream__write_cstr(&ss, ": ");
-//         pk_SStream__write_Str(&ss, &self->msg);
+//         c11_sbuf__write_cstr(&ss, ": ");
+//         c11_sbuf__write_Str(&ss, &self->msg);
 //     }
-//     return pk_SStream__submit(&ss);
+//     return c11_sbuf__submit(&ss);
 // }

src/interpreter/ceval.c

@@ -138,7 +138,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 //     obj =
                 //         new_object<Function>(tp_function, decl, frame->_module, nullptr,
                 //         captured);
-                //     uint16_t name = pk_StrName__map2(py_Str__sv(&decl->code->name));
+                //     uint16_t name = py_Name__map2(py_Str__sv(&decl->code->name));
                 //     captured->set(name, obj);
                 // } else {
                 //     obj = new_object<Function>(tp_function, decl, frame->_module, nullptr,
@@ -340,7 +340,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 DISPATCH();
             }
             case OP_DELETE_NAME: {
-                StrName name = byte.arg;
+                py_Name name = byte.arg;
                 if(frame->function) {
                     py_TValue* slot = Frame__f_locals_try_get(frame, name);
                     if(slot) {
@@ -366,7 +366,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 DISPATCH();
             }
             case OP_DELETE_GLOBAL: {
-                StrName name = byte.arg;
+                py_Name name = byte.arg;
                 bool ok = pk_NameDict__del(Frame__f_globals(frame), name);
                 if(!ok) {
                     NameError(name);
@@ -404,7 +404,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
 
             case OP_BUILD_LONG: {
                 // [x]
-                py_Ref f = py_getdict(&self->builtins, pk_id_long);
+                py_Ref f = py_getdict(&self->builtins, py_name("long"));
                 assert(f != NULL);
                 if(!py_call(f, 1, TOP())) goto __ERROR;
                 *TOP() = self->last_retval;
@@ -413,7 +413,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
 
             case OP_BUILD_IMAG: {
                 // [x]
-                py_Ref f = py_getdict(&self->builtins, pk_id_complex);
+                py_Ref f = py_getdict(&self->builtins, py_name("complex"));
                 assert(f != NULL);
                 py_TValue tmp = *TOP();
                 *TOP() = *f;           // [complex]
@@ -467,8 +467,9 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 py_TValue* begin = SP() - byte.arg;
                 py_Ref tmp = py_pushtmp();
                 py_newset(tmp);
+                py_Name id_add = py_name("add");
                 for(int i = 0; i < byte.arg; i++) {
-                    if(!py_callmethod(tmp, pk_id_add, 1, begin + i)) goto __ERROR;
+                    if(!py_callmethod(tmp, id_add, 1, begin + i)) goto __ERROR;
                 }
                 SP() = begin;
                 PUSH(tmp);
@@ -484,16 +485,16 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
             }
             case OP_BUILD_STRING: {
                 py_TValue* begin = SP() - byte.arg;
-                pk_SStream ss;
-                pk_SStream__ctor(&ss);
+                c11_sbuf ss;
+                c11_sbuf__ctor(&ss);
                 for(int i = 0; i < byte.arg; i++) {
                     if(!py_str(begin + i)) goto __ERROR;
                     int size;
                     const char* data = py_tostrn(&self->last_retval, &size);
-                    pk_SStream__write_cstrn(&ss, data, size);
+                    c11_sbuf__write_cstrn(&ss, data, size);
                 }
                 SP() = begin;
-                c11_string* res = pk_SStream__submit(&ss);
+                c11_string* res = c11_sbuf__submit(&ss);
                 py_newstrn(SP()++, res->data, res->size);
                 c11_string__delete(res);
                 DISPATCH();
@@ -597,7 +598,7 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 DISPATCH_JUMP_ABSOLUTE(target);
             }
                 // case OP_GOTO: {
-                //     StrName _name(byte.arg);
+                //     py_Name _name(byte.arg);
                 //     int target = c11_smallmap_n2i__get(&frame->co->labels, byte.arg, -1);
                 //     if(target < 0) RuntimeError(_S("label ", _name.escape(), " not found"));
                 //     frame->prepare_jump_break(&s_data, target);

src/interpreter/frame.c

@@ -132,7 +132,7 @@ void Frame__set_unwind_target(Frame* self, py_TValue* sp) {
     }
 }
 
-py_TValue* Frame__f_closure_try_get(Frame* self, StrName name){
+py_TValue* Frame__f_closure_try_get(Frame* self, py_Name name){
     // if(self->function == NULL) return NULL;
     // pkpy::Function* fn = PyObject__as(pkpy::Function, self->function);
     // if(fn->_closure == nullptr) return nullptr;

src/public/vm.c

@@ -11,7 +11,7 @@ static pk_VM pk_default_vm;
 
 void py_initialize() {
     pk_MemoryPools__initialize();
-    pk_StrName__initialize();
+    py_Name__initialize();
     pk_current_vm = &pk_default_vm;
     pk_VM__ctor(&pk_default_vm);
 }
@@ -19,7 +19,7 @@ void py_initialize() {
 void py_finalize() {
     pk_VM__dtor(&pk_default_vm);
     pk_current_vm = NULL;
-    pk_StrName__finalize();
+    py_Name__finalize();
     pk_MemoryPools__finalize();
 }