refactor string

include/pocketpy/common/smallmap.h

@@ -17,7 +17,7 @@ extern "C" {
 
 
 #define SMALLMAP_T__HEADER
-#define K c11_string
+#define K c11_stringview
 #define V uint16_t
 #define NAME c11_smallmap_s2n
 #define less(a, b)      (c11_string__cmp((a), (b)) <  0)

include/pocketpy/common/sstream.h

@@ -15,21 +15,19 @@ typedef struct pk_SStream {
 } pk_SStream;
 
 void pk_SStream__ctor(pk_SStream* self);
-void pk_SStream__ctor2(pk_SStream* self, int capacity);
 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_Str(pk_SStream* self, const py_Str*);
-void pk_SStream__write_sv(pk_SStream* self, c11_string);
+void pk_SStream__write_sv(pk_SStream* self, c11_stringview);
 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*);
 // Submit the stream and return the final string. The stream becomes invalid after this call
-py_Str pk_SStream__submit(pk_SStream* self);
+c11_string* pk_SStream__submit(pk_SStream* self);
 
 void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args);
 void pk_sprintf(pk_SStream* ss, const char* fmt, ...);

include/pocketpy/common/str.h

@@ -10,66 +10,48 @@ extern "C" {
 #endif
 
 /* string_view */
-typedef struct c11_string{
+typedef struct c11_stringview{
     const char* data;
     int size;
-} c11_string;
+} c11_stringview;
+
+int c11_string__cmp(c11_stringview self, c11_stringview other);
+int c11_string__cmp2(c11_stringview self, const char* other, int size);
+int c11_string__cmp3(c11_stringview self, const char* other);
+
+// int size | char[] | '\0'
+typedef const char c11_string;
+
+c11_string* c11_string__new(const char* data);
+c11_string* c11_string__new2(const char* data, int size);
+c11_string* c11_string__copy(c11_string* self);
+void c11_string__delete(c11_string* self);
+int c11_string__len(c11_string* self);
+c11_stringview c11_string__view(c11_string* self);
+c11_string* c11_string__replace(c11_string* self, char old, char new_);
+
+int c11_string__u8_length(const c11_string* self);
+c11_stringview 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_stringview sv, char quote, c11_vector* buf);
+void c11_sv__lower(c11_stringview sv, c11_vector* buf);
+void c11_sv__upper(c11_stringview sv, c11_vector* buf);
+c11_stringview c11_sv__slice(c11_stringview sv, int start);
+c11_stringview c11_sv__slice2(c11_stringview sv, int start, int stop);
+c11_stringview c11_sv__strip(c11_stringview sv, bool left, bool right);
+int c11_sv__index(c11_stringview self, char c);
+int c11_sv__index2(c11_stringview self, c11_stringview sub, int start);
+int c11_sv__count(c11_stringview self, c11_stringview sub);
+
+c11_vector/* T=c11_stringview */ c11_sv__split(c11_stringview self, char sep);
+c11_vector/* T=c11_stringview */ c11_sv__split2(c11_stringview self, c11_stringview sep);
+
+// misc
+int c11__unicode_index_to_byte(const char* data, int i);
+int c11__byte_index_to_unicode(const char* data, int n);
 
-int c11_string__cmp(c11_string self, c11_string other);
-int c11_string__cmp2(c11_string self, const char* other, int size);
-int c11_string__cmp3(c11_string self, const char* other);
-int c11_string__index(c11_string self, char c);
-
-typedef struct py_Str{
-    int size;
-    bool is_ascii;
-    bool is_sso;
-    union{
-        char* _ptr;
-        char _inlined[16];
-    };
-} py_Str;
-
-PK_INLINE const char* py_Str__data(const py_Str* self){
-    return self->is_sso ? self->_inlined : self->_ptr;
-}
-
-PK_INLINE c11_string py_Str__sv(const py_Str* self){
-    c11_string retval;
-    retval.data = py_Str__data(self);
-    retval.size = self->size;
-    return retval;
-}
-
-void py_Str__ctor(py_Str* self, const char* data);
-void py_Str__ctor2(py_Str* self, const char* data, int size);
-void py_Str__dtor(py_Str* self);
-py_Str py_Str__copy(const py_Str* self);
-py_Str py_Str__concat(const py_Str* self, const py_Str* other);
-py_Str py_Str__concat2(const py_Str* self, const char* other, int size);
-py_Str py_Str__slice(const py_Str* self, int start);
-py_Str py_Str__slice2(const py_Str* self, int start, int stop);
-py_Str py_Str__lower(const py_Str* self);
-py_Str py_Str__upper(const py_Str* self);
-py_Str py_Str__escape(const py_Str* self, char quote);
-py_Str py_Str__strip(const py_Str* self, bool left, bool right);
-py_Str py_Str__strip2(const py_Str* self, bool left, bool right, const py_Str* chars);
-py_Str py_Str__replace(const py_Str* self, char old, char new_);
-py_Str py_Str__replace2(const py_Str* self, const py_Str* old, const py_Str* new_);
-py_Str py_Str__u8_getitem(const py_Str* self, int i);
-py_Str py_Str__u8_slice(const py_Str* self, int start, int stop, int step);
-int py_Str__u8_length(const py_Str* self);
-int py_Str__cmp(const py_Str* self, const py_Str* other);
-int py_Str__cmp2(const py_Str* self, const char* other, int size);
-int py_Str__cmp3(const py_Str* self, const char* other);
-int py_Str__unicode_index_to_byte(const py_Str* self, int i);
-int py_Str__byte_index_to_unicode(const py_Str* self, int n);
-int py_Str__index(const py_Str* self, const py_Str* sub, int start);
-int py_Str__count(const py_Str* self, const py_Str* sub);
-c11_vector/* T=c11_string */ py_Str__split(const py_Str* self, char sep);
-c11_vector/* T=c11_string */ py_Str__split2(const py_Str* self, const py_Str* sep);
-
-bool c11__isascii(const char* p, int size);
 bool c11__is_unicode_Lo_char(int c);
 int c11__u8_header(unsigned char c, bool suppress);
 

include/pocketpy/common/strname.h

@@ -11,9 +11,9 @@ extern "C" {
 typedef uint16_t StrName;
 
 uint16_t pk_StrName__map(const char*);
-uint16_t pk_StrName__map2(c11_string);
+uint16_t pk_StrName__map2(c11_stringview);
 const char* pk_StrName__rmap(uint16_t index);
-c11_string pk_StrName__rmap2(uint16_t index);
+c11_stringview pk_StrName__rmap2(uint16_t index);
 
 void pk_StrName__initialize();
 void pk_StrName__finalize();

include/pocketpy/compiler/lexer.h

@@ -46,9 +46,9 @@ enum TokenValueIndex{
 typedef struct TokenValue {
     enum TokenValueIndex index;  // 0: empty
     union {
-        int64_t _i64;   // 1
-        double _f64;    // 2
-        py_Str _str;    // 3
+        int64_t _i64;       // 1
+        double _f64;        // 2
+        c11_string* _str;   // 3
     };
 } TokenValue;
 
@@ -93,17 +93,17 @@ typedef enum IntParsingResult{
     IntParsing_OVERFLOW,
 } IntParsingResult;
 
-IntParsingResult parse_uint(c11_string text, int64_t* out, int base);
+IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base);
 
 typedef struct Error Error;
 
 typedef c11_array pk_TokenArray;
 
 Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens);
-Error* pk_Lexer__process_and_dump(pk_SourceData_ src, py_Str* out_string);
+Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out_string);
 void pk_TokenArray__dtor(pk_TokenArray* self);
 
-#define Token__sv(self) (c11_string){(self)->start, (self)->length}
+#define Token__sv(self) (c11_stringview){(self)->start, (self)->length}
 
 #ifdef __cplusplus
 }

include/pocketpy/objects/codeobject.h

@@ -68,7 +68,7 @@ typedef struct BytecodeEx {
 
 typedef struct CodeObject {
     pk_SourceData_ src;
-    py_Str name;
+    c11_string* name;
 
     c11_vector/*T=Bytecode*/                codes;
     c11_vector/*T=CodeObjectByteCodeEx*/    codes_ex;
@@ -87,7 +87,7 @@ typedef struct CodeObject {
     int end_line;
 } CodeObject;
 
-void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_string name);
+void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_stringview name);
 void CodeObject__dtor(CodeObject* self);
 void CodeObject__gc_mark(const CodeObject* self);
 
@@ -116,7 +116,7 @@ typedef struct FuncDecl {
 
 typedef FuncDecl* FuncDecl_;
 
-FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_string name);
+FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_stringview name);
 void FuncDecl__dtor(FuncDecl* self);
 void FuncDecl__add_kwarg(FuncDecl* self, int index, uint16_t key, const py_TValue* value);
 void FuncDecl__gc_mark(const FuncDecl* self);

include/pocketpy/objects/error.h

@@ -9,30 +9,30 @@
 extern "C" {
 #endif
 
-typedef struct pkpy_ExceptionFrame {
-    pk_SourceData_ src;
-    int lineno;
-    const char* cursor;
-    py_Str name;
-} pkpy_ExceptionFrame;
-
-typedef struct pkpy_Exception {
-    StrName type;
-    py_Str msg;
-    bool is_re;
-
-    int _ip_on_error;
-    void* _code_on_error;
-
-    PyObject* self;  // weak reference
-
-    c11_vector/*T=pkpy_ExceptionFrame*/ stacktrace;
-} pkpy_Exception;
-
-void pkpy_Exception__ctor(pkpy_Exception* self, StrName 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);
+// typedef struct pkpy_ExceptionFrame {
+//     pk_SourceData_ src;
+//     int lineno;
+//     const char* cursor;
+//     py_Str name;
+// } pkpy_ExceptionFrame;
+
+// typedef struct pkpy_Exception {
+//     StrName type;
+//     py_Str msg;
+//     bool is_re;
+
+//     int _ip_on_error;
+//     void* _code_on_error;
+
+//     PyObject* self;  // weak reference
+
+//     c11_vector/*T=pkpy_ExceptionFrame*/ stacktrace;
+// } pkpy_Exception;
+
+// void pkpy_Exception__ctor(pkpy_Exception* self, StrName 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);
 
 struct Error{
     const char* type;

include/pocketpy/objects/sourcedata.h

@@ -16,18 +16,18 @@ struct pk_SourceData {
     bool is_precompiled;
     bool is_dynamic;    // for exec() and eval()
 
-    py_Str filename;
-    py_Str source;
+    c11_string* filename;
+    c11_string* source;
 
     c11_vector/*T=const char* */ line_starts;
-    c11_vector/*T=py_Str*/ _precompiled_tokens;
+    c11_vector/*T=c11_string* */ _precompiled_tokens;
 };
 
 typedef struct pk_SourceData* pk_SourceData_;
 
 pk_SourceData_ pk_SourceData__rcnew(const char* source, const char* filename, enum CompileMode mode, bool is_dynamic);
 bool pk_SourceData__get_line(const struct pk_SourceData* self, int lineno, const char** st, const char** ed);
-py_Str pk_SourceData__snapshot(const struct pk_SourceData *self, int lineno, const char *cursor, const char *name);
+c11_string* pk_SourceData__snapshot(const struct pk_SourceData *self, int lineno, const char *cursor, const char *name);
 
 #ifdef __cplusplus
 }

include/pocketpy/pocketpy.h

@@ -9,7 +9,6 @@ typedef struct py_TValue py_TValue;
 typedef struct pk_VM pk_VM;
 typedef uint16_t py_Name;
 typedef int16_t py_Type;
-typedef struct py_Str py_Str;
 
 typedef int64_t py_i64;
 typedef double py_f64;

src/common/smallmap.c

@@ -9,7 +9,7 @@
 
 
 #define SMALLMAP_T__SOURCE
-#define K c11_string
+#define K c11_stringview
 #define V uint16_t
 #define NAME c11_smallmap_s2n
 #define less(a, b)      (c11_string__cmp((a), (b)) <  0)

src/common/sourcedata.c

@@ -9,10 +9,10 @@ static void pk_SourceData__ctor(struct pk_SourceData* self,
                                 const char* filename,
                                 enum CompileMode mode,
                                 bool is_dynamic) {
-    py_Str__ctor(&self->filename, filename);
+    self->filename = c11_string__new(filename);
     self->mode = mode;
     c11_vector__ctor(&self->line_starts, sizeof(const char*));
-    c11_vector__ctor(&self->_precompiled_tokens, sizeof(py_Str));
+    c11_vector__ctor(&self->_precompiled_tokens, sizeof(c11_string*));
 
     // Skip utf8 BOM if there is any.
     if(strncmp(source, "\xEF\xBB\xBF", 3) == 0) source += 3;
@@ -26,18 +26,18 @@ static void pk_SourceData__ctor(struct pk_SourceData* self,
         source++;
     }
     self->source = pk_SStream__submit(&ss);
-    source = py_Str__data(&self->source);
     self->is_precompiled = (strncmp(source, "pkpy:", 5) == 0);
-    c11_vector__push(const char*, &self->line_starts, source);
+    c11_vector__push(const char*, &self->line_starts, self->source);
 }
 
 static void pk_SourceData__dtor(struct pk_SourceData* self) {
-    py_Str__dtor(&self->filename);
-    py_Str__dtor(&self->source);
+    c11_string__delete(self->filename);
+    c11_string__delete(self->source);
+
     c11_vector__dtor(&self->line_starts);
 
     for(int i = 0; i < self->_precompiled_tokens.count; i++) {
-        py_Str__dtor(c11__at(py_Str, &self->_precompiled_tokens, i));
+        c11_string__delete(c11__getitem(c11_string*, &self->_precompiled_tokens, i));
     }
     c11_vector__dtor(&self->_precompiled_tokens);
 }
@@ -70,7 +70,7 @@ bool pk_SourceData__get_line(const struct pk_SourceData* self,
     return true;
 }
 
-py_Str pk_SourceData__snapshot(const struct pk_SourceData* self,
+c11_string* pk_SourceData__snapshot(const struct pk_SourceData* self,
                                int lineno,
                                const char* cursor,
                                const char* name) {

src/common/sstream.c

@@ -9,11 +9,12 @@
 #include <ctype.h>
 #include <math.h>
 
-void pk_SStream__ctor(pk_SStream* self) { c11_vector__ctor(&self->data, sizeof(char)); }
+const static int C11_STRING_HEADER_SIZE = sizeof(int);
 
-void pk_SStream__ctor2(pk_SStream* self, int capacity) {
+void pk_SStream__ctor(pk_SStream* self) {
     c11_vector__ctor(&self->data, sizeof(char));
-    c11_vector__reserve(&self->data, capacity);
+    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); }
@@ -21,30 +22,17 @@ void pk_SStream__dtor(pk_SStream* self) { c11_vector__dtor(&self->data); }
 void pk_SStream__write_char(pk_SStream* self, char c) { c11_vector__push(char, &self->data, c); }
 
 void pk_SStream__write_int(pk_SStream* self, int i) {
-    char buf[12];  // sign + 10 digits + null terminator
-    snprintf(buf, sizeof(buf), "%d", i);
-    pk_SStream__write_cstr(self, buf);
+    // len('-2147483648') == 11
+    c11_vector__reserve(&self->data, self->data.count + 11 + 1);
+    int n = sprintf(self->data.data, "%d", i);
+    self->data.count += n;
 }
 
 void pk_SStream__write_i64(pk_SStream* self, int64_t val) {
-    // sign + 21 digits + null terminator
-    // str(-2**64).__len__() == 21
-    c11_vector__reserve(&self->data, self->data.count + 23);
-    if(val == 0) {
-        pk_SStream__write_char(self, '0');
-        return;
-    }
-    if(val < 0) {
-        pk_SStream__write_char(self, '-');
-        val = -val;
-    }
-    int start = self->data.count;
-    while(val) {
-        c11_vector__push(char, &self->data, '0' + val % 10);
-        val /= 10;
-    }
-    int end = self->data.count - 1;
-    c11_vector__reverse(char, &self->data, start, end);
+    // len('-9223372036854775808') == 20
+    c11_vector__reserve(&self->data, self->data.count + 20 + 1);
+    int n = sprintf(self->data.data, "%lld", (long long)val);
+    self->data.count += n;
 }
 
 void pk_SStream__write_f64(pk_SStream* self, double val, int precision) {
@@ -76,11 +64,7 @@ void pk_SStream__write_f64(pk_SStream* self, double val, int precision) {
     if(all_is_digit) pk_SStream__write_cstr(self, ".0");
 }
 
-void pk_SStream__write_Str(pk_SStream* self, const py_Str* str) {
-    pk_SStream__write_cstrn(self, py_Str__data(str), str->size);
-}
-
-void pk_SStream__write_sv(pk_SStream* self, c11_string sv) {
+void pk_SStream__write_sv(pk_SStream* self, c11_stringview sv) {
     pk_SStream__write_cstrn(self, sv.data, sv.size);
 }
 
@@ -119,15 +103,12 @@ void pk_SStream__write_ptr(pk_SStream* self, void* p) {
     }
 }
 
-py_Str pk_SStream__submit(pk_SStream* self) {
+c11_string* pk_SStream__submit(pk_SStream* self) {
     c11_vector__push(char, &self->data, '\0');
-    c11_array a = c11_vector__submit(&self->data);
-    // TODO: optimize c11__isascii
-    py_Str retval = {.size = a.count - 1,
-                     .is_ascii = c11__isascii((char*)a.data, a.count),
-                     .is_sso = false,
-                     ._ptr = (char*)a.data};
-    return retval;
+    c11_array arr = c11_vector__submit(&self->data);
+    int* p = arr.data;
+    *p = arr.count - C11_STRING_HEADER_SIZE - 1;
+    return (c11_string*)(p + 1);
 }
 
 void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
@@ -165,17 +146,8 @@ void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
             }
             case 'q': {
                 const char* s = va_arg(args, const char*);
-                py_Str tmp, tmp2;
-                py_Str__ctor(&tmp, s);
-                tmp2 = py_Str__escape(&tmp, '\'');
-                pk_SStream__write_Str(ss, &tmp2);
-                py_Str__dtor(&tmp);
-                py_Str__dtor(&tmp2);
-                break;
-            }
-            case 'S': {
-                const py_Str* s = va_arg(args, const py_Str*);
-                pk_SStream__write_Str(ss, s);
+                c11_stringview sv = {s, strlen(s)};
+                c11_sv__quote(sv, '\'', &ss->data);
                 break;
             }
             case 'c': {
@@ -218,7 +190,7 @@ void pk_sprintf(pk_SStream* ss, const char* fmt, ...) {
 const char* py_fmt(const char* fmt, ...) {
     PK_THREAD_LOCAL pk_SStream ss;
     if(ss.data.elem_size == 0) {
-        pk_SStream__ctor2(&ss, 256);
+        pk_SStream__ctor(&ss);
     } else {
         c11_vector__clear(&ss.data);
     }

src/common/strname.c

@@ -17,7 +17,7 @@ void pk_StrName__initialize() {
     for(int i = 0; i < _r_interned.count; i++) {
         free(c11__at(char*, &_r_interned, i));
     }
-    c11_vector__ctor(&_r_interned, sizeof(c11_string));
+    c11_vector__ctor(&_r_interned, sizeof(c11_stringview));
     _initialized = true;
 
 #define MAGIC_METHOD(x) x = pk_StrName__map(#x);
@@ -46,10 +46,10 @@ void pk_StrName__finalize() {
 }
 
 uint16_t pk_StrName__map(const char* name) {
-    return pk_StrName__map2((c11_string){name, strlen(name)});
+    return pk_StrName__map2((c11_stringview){name, strlen(name)});
 }
 
-uint16_t pk_StrName__map2(c11_string name) {
+uint16_t pk_StrName__map2(c11_stringview name) {
     // TODO: PK_GLOBAL_SCOPE_LOCK()
     if(!_initialized) {
         pk_StrName__initialize();  // lazy init
@@ -65,7 +65,7 @@ uint16_t pk_StrName__map2(c11_string name) {
     c11_vector__push(char*, &_r_interned, p);
     index = _r_interned.count;  // 1-based
     // save to _interned
-    c11_smallmap_s2n__set(&_interned, (c11_string){p, name.size}, index);
+    c11_smallmap_s2n__set(&_interned, (c11_stringview){p, name.size}, index);
     assert(_interned.count == _r_interned.count);
     return index;
 }
@@ -76,9 +76,9 @@ const char* pk_StrName__rmap(uint16_t index) {
     return c11__getitem(char*, &_r_interned, index - 1);
 }
 
-c11_string pk_StrName__rmap2(uint16_t index) {
+c11_stringview pk_StrName__rmap2(uint16_t index) {
     const char* p = pk_StrName__rmap(index);
-    return (c11_string){p, strlen(p)};
+    return (c11_stringview){p, strlen(p)};
 }
 
 py_Name py_name(const char* name) {

src/compiler/compiler.c

@@ -83,7 +83,7 @@ void Ctx__patch_jump(Ctx* self, int index);
 bool Ctx__add_label(Ctx* self, StrName name);
 int Ctx__add_varname(Ctx* self, StrName name);
 int Ctx__add_const(Ctx* self, py_Ref);
-int Ctx__add_const_string(Ctx* self, c11_string);
+int Ctx__add_const_string(Ctx* self, c11_stringview);
 void Ctx__emit_store_name(Ctx* self, NameScope scope, StrName name, int line);
 void Ctx__try_merge_for_iter_store(Ctx* self, int);
 void Ctx__s_emit_top(Ctx*);     // emit top -> pop -> delete
@@ -222,7 +222,7 @@ UnaryExpr* UnaryExpr__new(int line, Expr* child, Opcode opcode) {
 
 typedef struct RawStringExpr {
     EXPR_COMMON_HEADER
-    c11_string value;
+    c11_stringview value;
     Opcode opcode;
 } RawStringExpr;
 
@@ -233,7 +233,7 @@ void RawStringExpr__emit_(Expr* self_, Ctx* ctx) {
     Ctx__emit_(ctx, self->opcode, BC_NOARG, self->line);
 }
 
-RawStringExpr* RawStringExpr__new(int line, c11_string value, Opcode opcode) {
+RawStringExpr* RawStringExpr__new(int line, c11_stringview value, Opcode opcode) {
     const static ExprVt Vt = {.emit_ = RawStringExpr__emit_};
     static_assert_expr_size(RawStringExpr);
     RawStringExpr* self = PoolExpr_alloc();
@@ -289,7 +289,7 @@ void LiteralExpr__emit_(Expr* self_, Ctx* ctx) {
             break;
         }
         case TokenValue_STR: {
-            c11_string sv = py_Str__sv(&self->value->_str);
+            c11_stringview sv = c11_string__view(self->value->_str);
             int index = Ctx__add_const_string(ctx, sv);
             Ctx__emit_(ctx, OP_LOAD_CONST, index, self->line);
             break;
@@ -585,7 +585,7 @@ LambdaExpr* LambdaExpr__new(int line, int index) {
 
 typedef struct FStringExpr {
     EXPR_COMMON_HEADER
-    c11_string src;
+    c11_stringview src;
 } FStringExpr;
 
 static bool is_fmt_valid_char(char c) {
@@ -601,7 +601,7 @@ static bool is_fmt_valid_char(char c) {
     }
 }
 
-static bool is_identifier(c11_string s) {
+static bool is_identifier(c11_stringview s) {
     if(s.size == 0) return false;
     if(!isalpha(s.data[0]) && s.data[0] != '_') return false;
     for(int i = 0; i < s.size; i++) {
@@ -611,7 +611,7 @@ static bool is_identifier(c11_string s) {
     return true;
 }
 
-static void _load_simple_expr(Ctx* ctx, c11_string expr, int line) {
+static void _load_simple_expr(Ctx* ctx, c11_stringview expr, int line) {
     bool repr = false;
     const char* expr_end = expr.data + expr.size;
     if(expr.size >= 2 && expr_end[-2] == '!') {
@@ -634,10 +634,10 @@ static void _load_simple_expr(Ctx* ctx, c11_string expr, int line) {
         Ctx__emit_(ctx, OP_LOAD_NAME, pk_StrName__map2(expr), line);
         is_fastpath = true;
     } else {
-        int dot = c11_string__index(expr, '.');
+        int dot = c11_sv__index(expr, '.');
         if(dot > 0) {
-            c11_string a = {expr.data, dot};                                // expr[:dot]
-            c11_string b = {expr.data + (dot + 1), expr.size - (dot + 1)};  // expr[dot+1:]
+            c11_stringview a = {expr.data, dot};                                // expr[:dot]
+            c11_stringview 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);
@@ -666,11 +666,11 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
         if(flag) {
             if(src[j] == '}') {
                 // add expression
-                c11_string expr = {src + i, j - i};  // src[i:j]
+                c11_stringview expr = {src + i, j - i};  // src[i:j]
                 // BUG: ':' is not a format specifier in f"{stack[2:]}"
-                int conon = c11_string__index(expr, ':');
+                int conon = c11_sv__index(expr, ':');
                 if(conon >= 0) {
-                    c11_string spec = {expr.data + (conon + 1),
+                    c11_stringview spec = {expr.data + (conon + 1),
                                        expr.size - (conon + 1)};  // expr[conon+1:]
                     // filter some invalid spec
                     bool ok = true;
@@ -707,7 +707,7 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
                     j++;
                     Ctx__emit_(ctx,
                                OP_LOAD_CONST,
-                               Ctx__add_const_string(ctx, (c11_string){"{", 1}),
+                               Ctx__add_const_string(ctx, (c11_stringview){"{", 1}),
                                self->line);
                     count++;
                 } else {
@@ -722,7 +722,7 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
                     j++;
                     Ctx__emit_(ctx,
                                OP_LOAD_CONST,
-                               Ctx__add_const_string(ctx, (c11_string){"}", 1}),
+                               Ctx__add_const_string(ctx, (c11_stringview){"}", 1}),
                                self->line);
                     count++;
                 } else {
@@ -735,7 +735,7 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
                 i = j;
                 while(j < self->src.size && src[j] != '{' && src[j] != '}')
                     j++;
-                c11_string literal = {src + i, j - i};  // src[i:j]
+                c11_stringview literal = {src + i, j - i};  // src[i:j]
                 Ctx__emit_(ctx, OP_LOAD_CONST, Ctx__add_const_string(ctx, literal), self->line);
                 count++;
                 continue;  // skip j++
@@ -746,14 +746,14 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
 
     if(flag) {
         // literal
-        c11_string literal = {src + i, self->src.size - i};  // src[i:]
+        c11_stringview literal = {src + i, self->src.size - i};  // src[i:]
         Ctx__emit_(ctx, OP_LOAD_CONST, Ctx__add_const_string(ctx, literal), self->line);
         count++;
     }
     Ctx__emit_(ctx, OP_BUILD_STRING, count, self->line);
 }
 
-FStringExpr* FStringExpr__new(int line, c11_string src) {
+FStringExpr* FStringExpr__new(int line, c11_stringview src) {
     const static ExprVt Vt = {.emit_ = FStringExpr__emit_};
     static_assert_expr_size(FStringExpr);
     FStringExpr* self = PoolExpr_alloc();
@@ -1344,7 +1344,7 @@ int Ctx__add_varname(Ctx* self, StrName name) {
     return index;
 }
 
-int Ctx__add_const_string(Ctx* self, c11_string key) {
+int Ctx__add_const_string(Ctx* self, c11_stringview key) {
     uint16_t* val = c11_smallmap_s2n__try_get(&self->co_consts_string_dedup_map, key);
     if(val) {
         return *val;
@@ -1354,7 +1354,7 @@ int Ctx__add_const_string(Ctx* self, c11_string key) {
         c11_vector__push(py_TValue, &self->co->consts, tmp);
         int index = self->co->consts.count - 1;
         c11_smallmap_s2n__set(&self->co_consts_string_dedup_map,
-                              py_Str__sv(PyObject__value(tmp._obj)),
+                              c11_string__view(PyObject__value(tmp._obj)),
                               index);
         return index;
     }
@@ -1659,19 +1659,19 @@ static Error* exprLiteral(Compiler* self) {
 }
 
 static Error* exprLong(Compiler* self) {
-    c11_string sv = Token__sv(prev());
+    c11_stringview sv = Token__sv(prev());
     Ctx__s_push(ctx(), (Expr*)RawStringExpr__new(prev()->line, sv, OP_BUILD_LONG));
     return NULL;
 }
 
 static Error* exprBytes(Compiler* self) {
-    c11_string sv = py_Str__sv(&prev()->value._str);
+    c11_stringview sv = c11_string__view(prev()->value._str);
     Ctx__s_push(ctx(), (Expr*)RawStringExpr__new(prev()->line, sv, OP_BUILD_BYTES));
     return NULL;
 }
 
 static Error* exprFString(Compiler* self) {
-    c11_string sv = py_Str__sv(&prev()->value._str);
+    c11_stringview sv = c11_string__view(prev()->value._str);
     Ctx__s_push(ctx(), (Expr*)FStringExpr__new(prev()->line, sv));
     return NULL;
 }
@@ -2054,18 +2054,17 @@ Error* pk_compile(pk_SourceData_ src, CodeObject* out) {
     if(err) return err;
 
     Token* data = (Token*)tokens.data;
-    printf("%s\n", py_Str__data(&src->filename));
+    printf("%s\n", src->filename);
     for(int i = 0; i < tokens.count; i++) {
         Token* t = data + i;
-        py_Str tmp;
-        py_Str__ctor2(&tmp, t->start, t->length);
-        printf("[%d] %s: %s\n", t->line, pk_TokenSymbols[t->type], py_Str__data(&tmp));
-        py_Str__dtor(&tmp);
+        c11_string* tmp = c11_string__new2(t->start, t->length);
+        printf("[%d] %s: %s\n", t->line, pk_TokenSymbols[t->type], tmp);
+        c11_string__delete(tmp);
     }
 
     Compiler compiler;
     Compiler__ctor(&compiler, src, tokens);
-    CodeObject__ctor(out, src, py_Str__sv(&src->filename));
+    CodeObject__ctor(out, src, c11_string__view(src->filename));
     err = Compiler__compile(&compiler, out);
     if(err) {
         // if error occurs, dispose the code object

src/compiler/compiler.cpp

@@ -28,7 +28,7 @@ CodeObject* Compiler::push_global_context() noexcept{
     return co;
 }
 
-FuncDecl_ Compiler::push_f_context(c11_string name, int* out_index) noexcept{
+FuncDecl_ Compiler::push_f_context(c11_stringview name, int* out_index) noexcept{
     FuncDecl_ decl = FuncDecl__rcnew(lexer.src, name);
     decl->code->start_line = __i == 0 ? 1 : prev().line;
     decl->nested = name_scope() == NAME_LOCAL;

src/compiler/lexer.c

@@ -28,8 +28,8 @@ typedef struct TokenDeserializer {
 
 void TokenDeserializer__ctor(TokenDeserializer* self, const char* source);
 bool TokenDeserializer__match_char(TokenDeserializer* self, char c);
-c11_string TokenDeserializer__read_string(TokenDeserializer* self, char c);
-py_Str TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c);
+c11_stringview TokenDeserializer__read_string(TokenDeserializer* self, char c);
+c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c);
 int TokenDeserializer__read_count(TokenDeserializer* self);
 int64_t TokenDeserializer__read_uint(TokenDeserializer* self, char c);
 double TokenDeserializer__read_float(TokenDeserializer* self, char c);
@@ -40,7 +40,7 @@ const static TokenValue EmptyTokenValue;
 static void pk_Lexer__ctor(pk_Lexer* self, pk_SourceData_ src){
     PK_INCREF(src);
     self->src = src;
-    self->curr_char = self->token_start = py_Str__data(&src->source);
+    self->curr_char = self->token_start = src->source;
     self->current_line = 1;
     self->brackets_level = 0;
     c11_vector__ctor(&self->nexts, sizeof(Token));
@@ -220,15 +220,9 @@ static Error* eat_name(pk_Lexer* self){
             }
         }
         // handle multibyte char
-        py_Str u8str;
-        py_Str__ctor2(&u8str, self->curr_char, u8bytes);
-        if(u8str.size != u8bytes){
-            py_Str__dtor(&u8str);
-            return SyntaxError("invalid utf8 sequence: %s", py_Str__data(&u8str));
-        }
         uint32_t value = 0;
         for(int k = 0; k < u8bytes; k++) {
-            uint8_t b = py_Str__data(&u8str)[k];
+            uint8_t b = self->curr_char[k];
             if(k == 0) {
                 if(u8bytes == 2)
                     value = (b & 0b00011111) << 6;
@@ -240,15 +234,16 @@ static Error* eat_name(pk_Lexer* self){
                 value |= (b & 0b00111111) << (6 * (u8bytes - k - 1));
             }
         }
-        if(c11__is_unicode_Lo_char(value))
+        if(c11__is_unicode_Lo_char(value)){
             self->curr_char += u8bytes;
-        else
+        }else{
             break;
+        }
     }
 
     int length = (int)(self->curr_char - self->token_start);
     if(length == 0) return SyntaxError("@id contains invalid char");
-    c11_string name = {self->token_start, length};
+    c11_stringview name = {self->token_start, length};
 
     if(self->src->mode == JSON_MODE) {
         if(c11_string__cmp3(name, "true") == 0) {
@@ -278,7 +273,7 @@ static Error* eat_name(pk_Lexer* self){
     return NULL;
 }
 
-static Error* eat_string_until(pk_Lexer* self, char quote, bool raw, py_Str* out) {
+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;
@@ -341,7 +336,7 @@ enum StringType {
 };
 
 static Error* eat_string(pk_Lexer* self, char quote, enum StringType type){
-    py_Str s;
+    c11_string* s;
     Error* err = eat_string_until(self, quote, type == RAW_STRING, &s);
     if(err) return err;
     TokenValue value = {TokenValue_STR, ._str = s};
@@ -366,7 +361,7 @@ static Error* eat_number(pk_Lexer* self){
         is_scientific_notation = true;
     }
 
-    c11_string text = {self->token_start, i - self->token_start};
+    c11_stringview text = {self->token_start, i - self->token_start};
     self->curr_char = i;
 
     if(text.data[0] != '.' && !is_scientific_notation) {
@@ -554,10 +549,10 @@ static Error* lex_one_token(pk_Lexer* self, bool* eof){
 
 static Error* from_precompiled(pk_Lexer* self) {
     TokenDeserializer deserializer;
-    TokenDeserializer__ctor(&deserializer, py_Str__data(&self->src->source));
+    TokenDeserializer__ctor(&deserializer, self->src->source);
 
     deserializer.curr += 5;  // skip "pkpy:"
-    c11_string version = TokenDeserializer__read_string(&deserializer, '\n');
+    c11_stringview version = TokenDeserializer__read_string(&deserializer, '\n');
 
     if(c11_string__cmp3(version, PK_VERSION) != 0) {
         return SyntaxError("precompiled version mismatch");
@@ -569,10 +564,9 @@ static Error* from_precompiled(pk_Lexer* self) {
     int count = TokenDeserializer__read_count(&deserializer);
     c11_vector* precompiled_tokens = &self->src->_precompiled_tokens;
     for(int i = 0; i < count; i++) {
-        c11_string item = TokenDeserializer__read_string(&deserializer, '\n');
-        py_Str copied_item;
-        py_Str__ctor2(&copied_item, item.data, item.size);
-        c11_vector__push(py_Str, precompiled_tokens, copied_item);
+        c11_stringview item = TokenDeserializer__read_string(&deserializer, '\n');
+        c11_string* copied_item = c11_string__new2(item.data, item.size);
+        c11_vector__push(c11_string*, precompiled_tokens, copied_item);
     }
 
     count = TokenDeserializer__read_count(&deserializer);
@@ -581,9 +575,9 @@ static Error* from_precompiled(pk_Lexer* self) {
         t.type = (TokenIndex)TokenDeserializer__read_uint(&deserializer, ',');
         if(is_raw_string_used(t.type)) {
             int64_t index = TokenDeserializer__read_uint(&deserializer, ',');
-            py_Str* p = c11__at(py_Str, precompiled_tokens, index);
-            t.start = py_Str__data(p);
-            t.length = c11__getitem(py_Str, precompiled_tokens, index).size;
+            c11_string* p = c11__getitem(c11_string*, precompiled_tokens, index);
+            t.start = p;
+            t.length = c11_string__len(p);
         } else {
             t.start = NULL;
             t.length = 0;
@@ -612,7 +606,7 @@ static Error* from_precompiled(pk_Lexer* self) {
                 t.value = (TokenValue){TokenValue_F64, ._f64 = res};
             } break;
             case 'S': {
-                py_Str res = TokenDeserializer__read_string_from_hex(&deserializer, '\n');
+                c11_string* res = TokenDeserializer__read_string_from_hex(&deserializer, '\n');
                 t.value = (TokenValue){TokenValue_STR, ._str = res};
             } break;
             default:
@@ -624,10 +618,10 @@ static Error* from_precompiled(pk_Lexer* self) {
     return NULL;
 }
 
-IntParsingResult parse_uint(c11_string text, int64_t* out, int base) {
+IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base) {
     *out = 0;
 
-    c11_string prefix = {.data = text.data, .size = PK_MIN(2, text.size)};
+    c11_stringview prefix = {.data = text.data, .size = PK_MIN(2, text.size)};
     if(base == -1) {
         if(c11_string__cmp3(prefix, "0b") == 0)
             base = 2;
@@ -657,7 +651,7 @@ IntParsingResult parse_uint(c11_string text, int64_t* out, int base) {
         // 2-base   0b101010
         if(c11_string__cmp3(prefix, "0b") == 0) {
             // text.remove_prefix(2);
-            text = (c11_string){text.data + 2, text.size - 2};
+            text = (c11_stringview){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -675,7 +669,7 @@ IntParsingResult parse_uint(c11_string text, int64_t* out, int base) {
         // 8-base   0o123
         if(c11_string__cmp3(prefix, "0o") == 0) {
             // text.remove_prefix(2);
-            text = (c11_string){text.data + 2, text.size - 2};
+            text = (c11_stringview){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -693,7 +687,7 @@ IntParsingResult parse_uint(c11_string text, int64_t* out, int base) {
         // 16-base  0x123
         if(c11_string__cmp3(prefix, "0x") == 0) {
             // text.remove_prefix(2);
-            text = (c11_string){text.data + 2, text.size - 2};
+            text = (c11_stringview){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -745,7 +739,7 @@ Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens){
     return NULL;
 }
 
-Error* pk_Lexer__process_and_dump(pk_SourceData_ src, py_Str* out) {
+Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
     assert(!src->is_precompiled);
     pk_TokenArray nexts;    // output tokens
     Error* err = pk_Lexer__process(src, &nexts);
@@ -765,7 +759,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, py_Str* out) {
 
     c11__foreach(Token, &nexts, token) {
         if(is_raw_string_used(token->type)) {
-            c11_string token_sv = {token->start, token->length};
+            c11_stringview token_sv = {token->start, token->length};
             if(!c11_smallmap_s2n__contains(&token_indices, token_sv)) {
                 c11_smallmap_s2n__set(&token_indices, token_sv, 0);
             }
@@ -796,7 +790,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, py_Str* out) {
 
         if(is_raw_string_used(token->type)) {
             uint16_t *p = c11_smallmap_s2n__try_get(
-                &token_indices, (c11_string){token->start, token->length});
+                &token_indices, (c11_stringview){token->start, token->length});
             assert(p != NULL);
             pk_SStream__write_int(&ss, (int)*p);
             pk_SStream__write_char(&ss, ',');
@@ -827,7 +821,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, py_Str* out) {
                 break;
             case TokenValue_STR: {
                 pk_SStream__write_char(&ss, 'S');
-                c11_string sv = py_Str__sv(&token->value._str);
+                c11_stringview sv = c11_string__view(token->value._str);
                 for(int i=0; i<sv.size; i++){
                     pk_SStream__write_hex(&ss, sv.data[i], false);
                 }
@@ -845,7 +839,7 @@ void pk_TokenArray__dtor(pk_TokenArray *self){
     Token* data = self->data;
     for(int i=0; i<self->count; i++){
         if(data[i].value.index == TokenValue_STR){
-            py_Str__dtor(&data[i].value._str);
+            c11_string__delete(data[i].value._str);
         }
     }
     c11_array__dtor(self);
@@ -888,19 +882,20 @@ bool TokenDeserializer__match_char(TokenDeserializer* self, char c){
     return false;
 }
 
-c11_string TokenDeserializer__read_string(TokenDeserializer* self, char c){
+c11_stringview TokenDeserializer__read_string(TokenDeserializer* self, char c){
     const char* start = self->curr;
     while(*self->curr != c)
         self->curr++;
-    c11_string retval = {start, (int)(self->curr-start)};
+    c11_stringview retval = {start, (int)(self->curr-start)};
     self->curr++;  // skip the delimiter
     return retval;
 }
 
-py_Str TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c){
-    c11_string sv = TokenDeserializer__read_string(self, c);
+c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c){
+    c11_stringview sv = TokenDeserializer__read_string(self, c);
     const char* s = sv.data;
-    char* buffer = (char*)malloc(sv.size / 2 + 1);
+    pk_SStream ss;
+    pk_SStream__ctor(&ss);
     for(int i = 0; i < sv.size; i += 2) {
         char c = 0;
         if(s[i] >= '0' && s[i] <= '9')
@@ -916,15 +911,9 @@ py_Str TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c){
             c += s[i + 1] - 'a' + 10;
         else
             assert(false);
-        buffer[i / 2] = c;
+        pk_SStream__write_char(&ss, c);
     }
-    buffer[sv.size / 2] = 0;
-    return (py_Str){
-        .size = sv.size / 2,
-        .is_ascii = c11__isascii(buffer, sv.size / 2),
-        .is_sso = false,
-        ._ptr = buffer
-    };
+    return pk_SStream__submit(&ss);
 }
 
 int TokenDeserializer__read_count(TokenDeserializer* self){
@@ -944,12 +933,12 @@ int64_t TokenDeserializer__read_uint(TokenDeserializer* self, char c){
 }
 
 double TokenDeserializer__read_float(TokenDeserializer* self, char c){
-    c11_string sv = TokenDeserializer__read_string(self, c);
-    py_Str nullterm;
-    py_Str__ctor2(&nullterm, sv.data, sv.size);
+    c11_stringview sv = TokenDeserializer__read_string(self, c);
+    // TODO: optimize this
+    c11_string* nullterm = c11_string__new2(sv.data, sv.size);
     char* end;
-    double retval = strtod(py_Str__data(&nullterm), &end);
-    py_Str__dtor(&nullterm);
+    double retval = strtod(nullterm, &end);
+    c11_string__delete(nullterm);
     assert(*end == 0);
     return retval;
 }

src/error.c

@@ -1,59 +1,59 @@
-#include "pocketpy/objects/error.h"
-#include "pocketpy/common/strname.h"
-#include "pocketpy/common/sstream.h"
-
-void pkpy_Exception__ctor(pkpy_Exception* self, StrName type){
-    self->type = type;
-    self->is_re = true;
-    self->_ip_on_error = -1;
-    self->_code_on_error = NULL;
-    self->self = NULL;
-
-    py_Str__ctor(&self->msg, "");
-    c11_vector__ctor(&self->stacktrace, sizeof(pkpy_ExceptionFrame));
-}
-
-void pkpy_Exception__dtor(pkpy_Exception* self){
-    for(int i=0; i<self->stacktrace.count; i++){
-        pkpy_ExceptionFrame* frame = c11__at(pkpy_ExceptionFrame, &self->stacktrace, i);
-        PK_DECREF(frame->src);
-        py_Str__dtor(&frame->name);
-    }
-    py_Str__dtor(&self->msg);
-    c11_vector__dtor(&self->stacktrace);
-}
-
-void pkpy_Exception__stpush(pkpy_Exception* self, pk_SourceData_ src, int lineno, const char* cursor, const char* name){
-    if(self->stacktrace.count >= 7) return;
-    PK_INCREF(src);
-    pkpy_ExceptionFrame* frame = c11_vector__emplace(&self->stacktrace);
-    frame->src = src;
-    frame->lineno = lineno;
-    frame->cursor = cursor;
-    py_Str__ctor(&frame->name, name);
-}
-
-py_Str pkpy_Exception__summary(pkpy_Exception* self){
-    pk_SStream ss;
-    pk_SStream__ctor(&ss);
-
-    if(self->is_re){
-        pk_SStream__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);
-        py_Str__dtor(&s);
-        pk_SStream__write_cstr(&ss, "\n");
-    }
-
-    const char* name = pk_StrName__rmap(self->type);
-    pk_SStream__write_cstr(&ss, name);
-
-    if(self->msg.size > 0){
-        pk_SStream__write_cstr(&ss, ": ");
-        pk_SStream__write_Str(&ss, &self->msg);
-    }
-    return pk_SStream__submit(&ss);
-}
+// #include "pocketpy/objects/error.h"
+// #include "pocketpy/common/strname.h"
+// #include "pocketpy/common/sstream.h"
+
+// void pkpy_Exception__ctor(pkpy_Exception* self, StrName type){
+//     self->type = type;
+//     self->is_re = true;
+//     self->_ip_on_error = -1;
+//     self->_code_on_error = NULL;
+//     self->self = NULL;
+
+//     py_Str__ctor(&self->msg, "");
+//     c11_vector__ctor(&self->stacktrace, sizeof(pkpy_ExceptionFrame));
+// }
+
+// void pkpy_Exception__dtor(pkpy_Exception* self){
+//     for(int i=0; i<self->stacktrace.count; i++){
+//         pkpy_ExceptionFrame* frame = c11__at(pkpy_ExceptionFrame, &self->stacktrace, i);
+//         PK_DECREF(frame->src);
+//         py_Str__dtor(&frame->name);
+//     }
+//     py_Str__dtor(&self->msg);
+//     c11_vector__dtor(&self->stacktrace);
+// }
+
+// void pkpy_Exception__stpush(pkpy_Exception* self, pk_SourceData_ src, int lineno, const char* cursor, const char* name){
+//     if(self->stacktrace.count >= 7) return;
+//     PK_INCREF(src);
+//     pkpy_ExceptionFrame* frame = c11_vector__emplace(&self->stacktrace);
+//     frame->src = src;
+//     frame->lineno = lineno;
+//     frame->cursor = cursor;
+//     py_Str__ctor(&frame->name, name);
+// }
+
+// py_Str pkpy_Exception__summary(pkpy_Exception* self){
+//     pk_SStream ss;
+//     pk_SStream__ctor(&ss);
+
+//     if(self->is_re){
+//         pk_SStream__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);
+//         py_Str__dtor(&s);
+//         pk_SStream__write_cstr(&ss, "\n");
+//     }
+
+//     const char* name = pk_StrName__rmap(self->type);
+//     pk_SStream__write_cstr(&ss, name);
+
+//     if(self->msg.size > 0){
+//         pk_SStream__write_cstr(&ss, ": ");
+//         pk_SStream__write_Str(&ss, &self->msg);
+//     }
+//     return pk_SStream__submit(&ss);
+// }

src/interpreter/ceval.c

@@ -13,8 +13,6 @@ int NameError(py_Name name) { return -1; }
 
 static bool stack_binaryop(pk_VM* self, py_Name op, py_Name rop);
 
-// private
-void py_newStr_(py_Ref, py_Str);
 
 #define DISPATCH()                                                                                 \
     do {                                                                                           \
@@ -426,10 +424,11 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 DISPATCH();
             }
             case OP_BUILD_BYTES: {
-                py_Str* s = py_touserdata(TOP());
-                unsigned char* p = (unsigned char*)malloc(s->size);
-                memcpy(p, py_Str__data(s), s->size);
-                py_newbytes(TOP(), p, s->size);
+                int size;
+                const char* data = py_tostrn(TOP(), &size);
+                unsigned char* p = (unsigned char*)malloc(size);
+                memcpy(p, data, size);
+                py_newbytes(TOP(), p, size);
                 DISPATCH();
             }
             case OP_BUILD_TUPLE: {
@@ -490,11 +489,14 @@ pk_FrameResult pk_VM__run_top_frame(pk_VM* self) {
                 pk_SStream__ctor(&ss);
                 for(int i = 0; i < byte.arg; i++) {
                     if(!py_str(begin + i)) goto __ERROR;
-                    py_Str* item = py_touserdata(&self->last_retval);
-                    pk_SStream__write_Str(&ss, item);
+                    int size;
+                    const char* data = py_tostrn(&self->last_retval, &size);
+                    pk_SStream__write_cstrn(&ss, data, size);
                 }
                 SP() = begin;
-                py_newStr_(SP()++, pk_SStream__submit(&ss));
+                c11_string* res = pk_SStream__submit(&ss);
+                py_newstrn(SP()++, res, c11_string__len(res));
+                c11_string__delete(res);
                 DISPATCH();
             }
             /*****************************/

src/interpreter/py_number.c

@@ -2,56 +2,19 @@
 
 #include <math.h>
 
-// static int _py_print(const py_Ref args, int argc){
-//     int length = py_tuple__len(args+0);
-//     py_Str* sep;
-//     py_Str* end;
-
-//     int err;
-//     err = py_tostr(args+1, &sep);
-//     if(err) return err;
-//     err = py_tostr(args+2, &end);
-//     if(err) return err;
-
-//     pk_SStream ss;
-//     pk_SStream__ctor(&ss);
-
-//     for(int i=0; i<length; i++){
-//         const py_Ref item = py_tuple__getitem(args+0, i);
-//         py_Str tmp;
-//         int err = py_str(item, &tmp);
-//         if(!err){
-//             pk_SStream__write_Str(&ss, &tmp);
-//             py_Str__dtor(&tmp);
-//             if(i != length-1){
-//                 pk_SStream__write_Str(&ss, sep);
-//             }
-//         }else{
-//             py_Str__dtor(&tmp);
-//             pk_SStream__dtor(&ss);
-//             return err;
-//         }
-//     }
-//     pk_SStream__write_Str(&ss, end);
-//     py_Str out = pk_SStream__submit(&ss);
-//     pk_current_vm->_stdout(py_Str__data(&out));
-//     py_Str__dtor(&out);
-//     return 0;
-// }
-
 #define DEF_NUM_BINARY_OP(name, op, rint, rfloat)                                                  \
     static bool _py_int##name(int argc, py_Ref argv) {                                             \
         py_checkargc(2);                                                                           \
         if(py_isint(&argv[1])) {                                                                   \
             int64_t lhs = py_toint(&argv[0]);                                                      \
             int64_t rhs = py_toint(&argv[1]);                                                      \
-            rint(py_retval(), lhs op rhs);                                                     \
+            rint(py_retval(), lhs op rhs);                                                         \
         } else if(py_isfloat(&argv[1])) {                                                          \
             int64_t lhs = py_toint(&argv[0]);                                                      \
             double rhs = py_tofloat(&argv[1]);                                                     \
-            rfloat(py_retval(), lhs op rhs);                                                   \
+            rfloat(py_retval(), lhs op rhs);                                                       \
         } else {                                                                                   \
-            py_newnotimplemented(py_retval());                                                 \
+            py_newnotimplemented(py_retval());                                                     \
         }                                                                                          \
         return true;                                                                               \
     }                                                                                              \
@@ -60,9 +23,9 @@
         double lhs = py_tofloat(&argv[0]);                                                         \
         double rhs;                                                                                \
         if(py_castfloat(&argv[1], &rhs)) {                                                         \
-            rfloat(py_retval(), lhs op rhs);                                                   \
+            rfloat(py_retval(), lhs op rhs);                                                       \
         } else {                                                                                   \
-            py_newnotimplemented(py_retval());                                                 \
+            py_newnotimplemented(py_retval());                                                     \
         }                                                                                          \
         return true;                                                                               \
     }
@@ -204,9 +167,9 @@ static bool _py_int__bit_length(int argc, py_Ref argv) {
         int64_t lhs = py_toint(&argv[0]);                                                          \
         if(py_isint(&argv[1])) {                                                                   \
             int64_t rhs = py_toint(&argv[1]);                                                      \
-            py_newint(py_retval(), lhs op rhs);                                                \
+            py_newint(py_retval(), lhs op rhs);                                                    \
         } else {                                                                                   \
-            py_newnotimplemented(py_retval());                                                 \
+            py_newnotimplemented(py_retval());                                                     \
         }                                                                                          \
         return true;                                                                               \
     }
@@ -270,11 +233,4 @@ void pk_VM__init_builtins(pk_VM* self) {
 
     // int.bit_length
     py_bindmethod(tp_int, "bit_length", _py_int__bit_length);
-
-    // py_Ref builtins = py_getmodule("builtins");
-    // py_newfunction(py_reg(0), _py_print,
-    //     "print(*args, sep=' ', end='\\n')",
-    //     BindType_FUNCTION
-    // );
-    // py_setdict(builtins, py_name("hello"), py_reg(0));
 }

src/objects/codeobject.c

@@ -13,7 +13,7 @@ bool Bytecode__is_forward_jump(const Bytecode* self) {
     return self->op >= OP_JUMP_FORWARD && self->op <= OP_LOOP_BREAK;
 }
 
-FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_string name) {
+FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_stringview name) {
     FuncDecl* self = malloc(sizeof(FuncDecl));
     self->rc.count = 1;
     self->rc.dtor = (void (*)(void*))FuncDecl__dtor;
@@ -46,10 +46,10 @@ void FuncDecl__add_kwarg(FuncDecl* self, int index, uint16_t key, const py_TValu
     c11_vector__push(FuncDeclKwArg, &self->kwargs, item);
 }
 
-void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_string name) {
+void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_stringview name) {
     self->src = src;
     PK_INCREF(src);
-    py_Str__ctor2(&self->name, name.data, name.size);
+    self->name = c11_string__new2(name.data, name.size);
 
     c11_vector__ctor(&self->codes, sizeof(Bytecode));
     c11_vector__ctor(&self->codes_ex, sizeof(BytecodeEx));
@@ -73,7 +73,7 @@ void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_string name) {
 
 void CodeObject__dtor(CodeObject* self) {
     PK_DECREF(self->src);
-    py_Str__dtor(&self->name);
+    c11_string__delete(self->name);
 
     c11_vector__dtor(&self->codes);
     c11_vector__dtor(&self->codes_ex);

src/public/cast.c

@@ -40,15 +40,15 @@ py_Type py_totype(const py_Ref self){
 
 const char* py_tostr(const py_Ref self){
     assert(self->type == tp_str);
-    py_Str* ud = PyObject__value(self->_obj);
-    return py_Str__data(ud);
+    int* p = PyObject__value(self->_obj);
+    return (const char*)(p+1);
 }
 
 const char* py_tostrn(const py_Ref self, int* size){
     assert(self->type == tp_str);
-    py_Str* ud = PyObject__value(self->_obj);
-    *size = ud->size;
-    return py_Str__data(ud);
+    int* p = PyObject__value(self->_obj);
+    *size = *p;
+    return (const char*)(p+1);
 }
 
 const unsigned char* py_tobytes(const py_Ref self, int* size){

src/public/values.c

@@ -41,28 +41,15 @@ void py_newellipsis(py_Ref out) {
 void py_newnull(py_Ref out) { out->type = 0; }
 
 void py_newstr(py_Ref out, const char* data) {
-    pk_ManagedHeap* heap = &pk_current_vm->heap;
-    PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_str, 0, sizeof(py_Str));
-    py_Str__ctor(PyObject__value(obj), data);
-    out->type = tp_str;
-    out->is_ptr = true;
-    out->_obj = obj;
+    return py_newstrn(out, data, strlen(data));
 }
 
 void py_newstrn(py_Ref out, const char* data, int size) {
     pk_ManagedHeap* heap = &pk_current_vm->heap;
-    PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_str, 0, sizeof(py_Str));
-    py_Str__ctor2((py_Str*)PyObject__value(obj), data, size);
-    out->type = tp_str;
-    out->is_ptr = true;
-    out->_obj = obj;
-}
-
-void py_newStr_(py_Ref out, py_Str input) {
-    pk_ManagedHeap* heap = &pk_current_vm->heap;
-    PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_str, 0, sizeof(py_Str));
-    py_Str* userdata = PyObject__value(obj);
-    *userdata = input;
+    int total_size = sizeof(int) + size + 1;
+    PyObject* obj = pk_ManagedHeap__gcnew(heap, tp_str, 0, total_size);
+    int* p = PyObject__value(obj);
+    *p = size;
     out->type = tp_str;
     out->is_ptr = true;
     out->_obj = obj;