some rename

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;
-
-void pk_SStream__ctor(pk_SStream* self);
-void pk_SStream__dtor(pk_SStream* 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*);
+} c11_sbuf;
+
+void c11_sbuf__ctor(c11_sbuf* self);
+void c11_sbuf__dtor(c11_sbuf* self);
+
+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/pocketpy.h

@@ -320,15 +320,16 @@ 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
 
 
-enum py_MagicMethods{
-    py_MagicMethods__NULL,  // 0 is reserved
+enum py_MagicNames{
+    py_MagicNames__NULL,  // 0 is reserved
     #define MAGIC_METHOD(x) x,
     #include "pocketpy/xmacros/magics.h"
     #undef MAGIC_METHOD

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/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

@@ -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);
+//     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

@@ -485,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();