a lot of rename

include/pocketpy/common/smallmap.h

@@ -17,11 +17,11 @@ extern "C" {
 
 
 #define SMALLMAP_T__HEADER
-#define K c11_stringview
+#define K c11_sv
 #define V uint16_t
 #define NAME c11_smallmap_s2n
-#define less(a, b)      (c11_string__cmp((a), (b)) <  0)
-#define equal(a, b)     (c11_string__cmp((a), (b)) == 0)
+#define less(a, b)      (c11_sv__cmp((a), (b)) <  0)
+#define equal(a, b)     (c11_sv__cmp((a), (b)) == 0)
 #include "pocketpy/xmacros/smallmap.h"
 #undef SMALLMAP_T__HEADER
 

include/pocketpy/common/sstream.h

@@ -21,7 +21,7 @@ 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_stringview);
+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);

include/pocketpy/common/str.h

@@ -10,14 +10,14 @@ extern "C" {
 #endif
 
 /* string_view */
-typedef struct c11_stringview{
+typedef struct c11_sv{
     const char* data;
     int size;
-} c11_stringview;
+} c11_sv;
 
-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 c11_sv__cmp(c11_sv self, c11_sv other);
+int c11_sv__cmp2(c11_sv self, const char* other, int size);
+int c11_sv__cmp3(c11_sv self, const char* other);
 
 // int size | char[] | '\0'
 typedef const char c11_string;
@@ -27,26 +27,26 @@ 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_sv 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_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_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);
+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);
+c11_sv c11_sv__slice2(c11_sv sv, int start, int stop);
+c11_sv c11_sv__strip(c11_sv sv, bool left, bool right);
+int c11_sv__index(c11_sv self, char c);
+int c11_sv__index2(c11_sv self, c11_sv sub, int start);
+int c11_sv__count(c11_sv self, c11_sv sub);
+
+c11_vector/* T=c11_sv */ c11_sv__split(c11_sv self, char sep);
+c11_vector/* T=c11_sv */ c11_sv__split2(c11_sv self, c11_sv sep);
 
 // misc
 int c11__unicode_index_to_byte(const char* data, int i);

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_stringview);
+uint16_t pk_StrName__map2(c11_sv);
 const char* pk_StrName__rmap(uint16_t index);
-c11_stringview pk_StrName__rmap2(uint16_t index);
+c11_sv pk_StrName__rmap2(uint16_t index);
 
 void pk_StrName__initialize();
 void pk_StrName__finalize();

include/pocketpy/compiler/lexer.h

@@ -93,7 +93,7 @@ typedef enum IntParsingResult{
     IntParsing_OVERFLOW,
 } IntParsingResult;
 
-IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base);
+IntParsingResult parse_uint(c11_sv text, int64_t* out, int base);
 
 typedef struct Error Error;
 
@@ -103,7 +103,7 @@ Error* pk_Lexer__process(pk_SourceData_ src, pk_TokenArray* out_tokens);
 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_stringview){(self)->start, (self)->length}
+#define Token__sv(self) (c11_sv){(self)->start, (self)->length}
 
 #ifdef __cplusplus
 }

include/pocketpy/objects/codeobject.h

@@ -87,7 +87,7 @@ typedef struct CodeObject {
     int end_line;
 } CodeObject;
 
-void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_stringview name);
+void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_sv 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_stringview name);
+FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_sv 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);

src/common/smallmap.c

@@ -9,10 +9,10 @@
 
 
 #define SMALLMAP_T__SOURCE
-#define K c11_stringview
+#define K c11_sv
 #define V uint16_t
 #define NAME c11_smallmap_s2n
-#define less(a, b)      (c11_string__cmp((a), (b)) <  0)
-#define equal(a, b)     (c11_string__cmp((a), (b)) == 0)
+#define less(a, b)      (c11_sv__cmp((a), (b)) <  0)
+#define equal(a, b)     (c11_sv__cmp((a), (b)) == 0)
 #include "pocketpy/xmacros/smallmap.h"
 #undef SMALLMAP_T__SOURCE

src/common/sstream.c

@@ -64,7 +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_sv(pk_SStream* self, c11_stringview sv) {
+void pk_SStream__write_sv(pk_SStream* self, c11_sv sv) {
     pk_SStream__write_cstrn(self, sv.data, sv.size);
 }
 
@@ -146,7 +146,7 @@ void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args) {
             }
             case 'q': {
                 const char* s = va_arg(args, const char*);
-                c11_stringview sv = {s, strlen(s)};
+                c11_sv sv = {s, strlen(s)};
                 c11_sv__quote(sv, '\'', &ss->data);
                 break;
             }

src/common/str.c

@@ -36,9 +36,9 @@ int c11_string__len(c11_string* self) {
     return *p;
 }
 
-c11_stringview c11_string__view(c11_string* self) {
+c11_sv c11_string__view(c11_string* self) {
     int* p = (int*)self - 1;
-    return (c11_stringview){self, *p};
+    return (c11_sv){self, *p};
 }
 
 c11_string* c11_string__replace(c11_string* self, char old, char new_) {
@@ -56,7 +56,7 @@ int c11_string__u8_length(c11_string* self) {
     return c11__byte_index_to_unicode(self, size);
 }
 
-c11_stringview c11_string__u8_getitem(c11_string* self, int i) {
+c11_sv c11_string__u8_getitem(c11_string* self, int i) {
     i = c11__unicode_index_to_byte(self, i);
     int size = c11__u8_header(self[i], false);
     return c11_sv__slice2(c11_string__view(self), i, i + size);
@@ -67,14 +67,14 @@ c11_string* c11_string__u8_slice(c11_string* self, int start, int stop, int step
     pk_SStream__ctor(&ss);
     assert(step != 0);
     for(int i = start; step > 0 ? i < stop : i > stop; i += step) {
-        c11_stringview unicode = c11_string__u8_getitem(self, i);
+        c11_sv unicode = c11_string__u8_getitem(self, i);
         pk_SStream__write_sv(&ss, unicode);
     }
     return pk_SStream__submit(&ss);
 }
 
 /////////////////////////////////////////
-void c11_sv__quote(c11_stringview sv, char quote, c11_vector* buf) {
+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++) {
@@ -103,7 +103,7 @@ void c11_sv__quote(c11_stringview sv, char quote, c11_vector* buf) {
     c11_vector__push(char, buf, quote);
 }
 
-void c11_sv__lower(c11_stringview sv, c11_vector* buf) {
+void c11_sv__lower(c11_sv sv, c11_vector* buf) {
     for(int i = 0; i < sv.size; i++) {
         char c = sv.data[i];
         if('A' <= c && c <= 'Z') c += 32;
@@ -111,7 +111,7 @@ void c11_sv__lower(c11_stringview sv, c11_vector* buf) {
     }
 }
 
-void c11_sv__upper(c11_stringview sv, c11_vector* buf) {
+void c11_sv__upper(c11_sv sv, c11_vector* buf) {
     for(int i = 0; i < sv.size; i++) {
         char c = sv.data[i];
         if('a' <= c && c <= 'z') c -= 32;
@@ -119,16 +119,16 @@ void c11_sv__upper(c11_stringview sv, c11_vector* buf) {
     }
 }
 
-c11_stringview c11_sv__slice(c11_stringview sv, int start) {
+c11_sv c11_sv__slice(c11_sv sv, int start) {
     return c11_sv__slice2(sv, start, sv.size);
 }
 
-c11_stringview c11_sv__slice2(c11_stringview sv, int start, int stop) {
+c11_sv c11_sv__slice2(c11_sv sv, int start, int stop) {
     if(stop < start) stop = start;
-    return (c11_stringview){sv.data + start, stop - start};
+    return (c11_sv){sv.data + start, stop - start};
 }
 
-c11_stringview c11_sv__strip(c11_stringview sv, bool left, bool right) {
+c11_sv c11_sv__strip(c11_sv sv, bool left, bool right) {
     int L = 0;
     int R = sv.size;
     const char* data = sv.data;
@@ -144,14 +144,14 @@ c11_stringview c11_sv__strip(c11_stringview sv, bool left, bool right) {
     return c11_sv__slice2(sv, L, R);
 }
 
-int c11_sv__index(c11_stringview self, char c) {
+int c11_sv__index(c11_sv self, char c) {
     for(int i = 0; i < self.size; i++) {
         if(self.data[i] == c) return i;
     }
     return -1;
 }
 
-int c11_sv__index2(c11_stringview self, c11_stringview sub, int start) {
+int c11_sv__index2(c11_sv self, c11_sv sub, int start) {
     if(sub.size == 0) return start;
     int max_end = self.size - sub.size;
     for(int i = start; i <= max_end; i++) {
@@ -161,7 +161,7 @@ int c11_sv__index2(c11_stringview self, c11_stringview sub, int start) {
     return -1;
 }
 
-int c11_sv__count(c11_stringview self, c11_stringview sub) {
+int c11_sv__count(c11_sv self, c11_sv sub) {
     if(sub.size == 0) return self.size + 1;
     int cnt = 0;
     int start = 0;
@@ -174,42 +174,42 @@ int c11_sv__count(c11_stringview self, c11_stringview sub) {
     return cnt;
 }
 
-c11_vector /* T=c11_stringview */ c11_sv__split(c11_stringview self, char sep) {
+c11_vector /* T=c11_sv */ c11_sv__split(c11_sv self, char sep) {
     c11_vector retval;
-    c11_vector__ctor(&retval, sizeof(c11_stringview));
+    c11_vector__ctor(&retval, sizeof(c11_sv));
     const char* data = self.data;
     int i = 0;
     for(int j = 0; j < self.size; j++) {
         if(data[j] == sep) {
             if(j > i) {
-                c11_stringview tmp = {data + i, j - i};
-                c11_vector__push(c11_stringview, &retval, tmp);
+                c11_sv tmp = {data + i, j - i};
+                c11_vector__push(c11_sv, &retval, tmp);
             }
             i = j + 1;
             continue;
         }
     }
     if(self.size > i) {
-        c11_stringview tmp = {data + i, self.size - i};
-        c11_vector__push(c11_stringview, &retval, tmp);
+        c11_sv tmp = {data + i, self.size - i};
+        c11_vector__push(c11_sv, &retval, tmp);
     }
     return retval;
 }
 
-c11_vector /* T=c11_stringview */ c11_sv__split2(c11_stringview self, c11_stringview sep) {
+c11_vector /* T=c11_sv */ c11_sv__split2(c11_sv self, c11_sv sep) {
     c11_vector retval;
-    c11_vector__ctor(&retval, sizeof(c11_stringview));
+    c11_vector__ctor(&retval, sizeof(c11_sv));
     int start = 0;
     const char* data = self.data;
     while(true) {
         int i = c11_sv__index2(self, sep, start);
         if(i == -1) break;
-        c11_stringview tmp = {data + start, i - start};
-        if(tmp.size != 0) c11_vector__push(c11_stringview, &retval, tmp);
+        c11_sv tmp = {data + start, i - start};
+        if(tmp.size != 0) c11_vector__push(c11_sv, &retval, tmp);
         start = i + sep.size;
     }
-    c11_stringview tmp = {data + start, self.size - start};
-    if(tmp.size != 0) c11_vector__push(c11_stringview, &retval, tmp);
+    c11_sv tmp = {data + start, self.size - start};
+    if(tmp.size != 0) c11_vector__push(c11_sv, &retval, tmp);
     return retval;
 }
 
@@ -232,18 +232,18 @@ int c11__byte_index_to_unicode(const char* data, int n) {
 
 //////////////
 
-int c11_string__cmp(c11_stringview self, c11_stringview other) {
-    return c11_string__cmp2(self, other.data, other.size);
+int c11_sv__cmp(c11_sv self, c11_sv other) {
+    return c11_sv__cmp2(self, other.data, other.size);
 }
 
-int c11_string__cmp2(c11_stringview self, const char* other, int size) {
+int c11_sv__cmp2(c11_sv self, const char* other, int size) {
     int res = strncmp(self.data, other, PK_MIN(self.size, size));
     if(res != 0) return res;
     return self.size - size;
 }
 
-int c11_string__cmp3(c11_stringview self, const char* other) {
-    return c11_string__cmp2(self, other, strlen(other));
+int c11_sv__cmp3(c11_sv self, const char* other) {
+    return c11_sv__cmp2(self, other, strlen(other));
 }
 
 

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_stringview));
+    c11_vector__ctor(&_r_interned, sizeof(c11_sv));
     _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_stringview){name, strlen(name)});
+    return pk_StrName__map2((c11_sv){name, strlen(name)});
 }
 
-uint16_t pk_StrName__map2(c11_stringview name) {
+uint16_t pk_StrName__map2(c11_sv name) {
     // TODO: PK_GLOBAL_SCOPE_LOCK()
     if(!_initialized) {
         pk_StrName__initialize();  // lazy init
@@ -65,7 +65,7 @@ uint16_t pk_StrName__map2(c11_stringview name) {
     c11_vector__push(char*, &_r_interned, p);
     index = _r_interned.count;  // 1-based
     // save to _interned
-    c11_smallmap_s2n__set(&_interned, (c11_stringview){p, name.size}, index);
+    c11_smallmap_s2n__set(&_interned, (c11_sv){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_stringview pk_StrName__rmap2(uint16_t index) {
+c11_sv pk_StrName__rmap2(uint16_t index) {
     const char* p = pk_StrName__rmap(index);
-    return (c11_stringview){p, strlen(p)};
+    return (c11_sv){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_stringview);
+int Ctx__add_const_string(Ctx* self, c11_sv);
 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_stringview value;
+    c11_sv 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_stringview value, Opcode opcode) {
+RawStringExpr* RawStringExpr__new(int line, c11_sv 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_stringview sv = c11_string__view(self->value->_str);
+            c11_sv 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_stringview src;
+    c11_sv 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_stringview s) {
+static bool is_identifier(c11_sv 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_stringview s) {
     return true;
 }
 
-static void _load_simple_expr(Ctx* ctx, c11_stringview expr, int line) {
+static void _load_simple_expr(Ctx* ctx, c11_sv expr, int line) {
     bool repr = false;
     const char* expr_end = expr.data + expr.size;
     if(expr.size >= 2 && expr_end[-2] == '!') {
@@ -636,8 +636,8 @@ static void _load_simple_expr(Ctx* ctx, c11_stringview expr, int line) {
     } else {
         int dot = c11_sv__index(expr, '.');
         if(dot > 0) {
-            c11_stringview a = {expr.data, dot};                                // expr[:dot]
-            c11_stringview b = {expr.data + (dot + 1), expr.size - (dot + 1)};  // expr[dot+1:]
+            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);
@@ -666,11 +666,11 @@ static void FStringExpr__emit_(Expr* self_, Ctx* ctx) {
         if(flag) {
             if(src[j] == '}') {
                 // add expression
-                c11_stringview expr = {src + i, j - i};  // src[i:j]
+                c11_sv expr = {src + i, j - i};  // src[i:j]
                 // BUG: ':' is not a format specifier in f"{stack[2:]}"
                 int conon = c11_sv__index(expr, ':');
                 if(conon >= 0) {
-                    c11_stringview spec = {expr.data + (conon + 1),
+                    c11_sv 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_stringview){"{", 1}),
+                               Ctx__add_const_string(ctx, (c11_sv){"{", 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_stringview){"}", 1}),
+                               Ctx__add_const_string(ctx, (c11_sv){"}", 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_stringview literal = {src + i, j - i};  // src[i:j]
+                c11_sv 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_stringview literal = {src + i, self->src.size - i};  // src[i:]
+        c11_sv 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_stringview src) {
+FStringExpr* FStringExpr__new(int line, c11_sv 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_stringview key) {
+int Ctx__add_const_string(Ctx* self, c11_sv key) {
     uint16_t* val = c11_smallmap_s2n__try_get(&self->co_consts_string_dedup_map, key);
     if(val) {
         return *val;
@@ -1659,19 +1659,19 @@ static Error* exprLiteral(Compiler* self) {
 }
 
 static Error* exprLong(Compiler* self) {
-    c11_stringview sv = Token__sv(prev());
+    c11_sv 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_stringview sv = c11_string__view(prev()->value._str);
+    c11_sv 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_stringview sv = c11_string__view(prev()->value._str);
+    c11_sv sv = c11_string__view(prev()->value._str);
     Ctx__s_push(ctx(), (Expr*)FStringExpr__new(prev()->line, sv));
     return NULL;
 }

src/compiler/compiler.cpp

@@ -28,7 +28,7 @@ CodeObject* Compiler::push_global_context() noexcept{
     return co;
 }
 
-FuncDecl_ Compiler::push_f_context(c11_stringview name, int* out_index) noexcept{
+FuncDecl_ Compiler::push_f_context(c11_sv 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,7 +28,7 @@ typedef struct TokenDeserializer {
 
 void TokenDeserializer__ctor(TokenDeserializer* self, const char* source);
 bool TokenDeserializer__match_char(TokenDeserializer* self, char c);
-c11_stringview TokenDeserializer__read_string(TokenDeserializer* self, char c);
+c11_sv 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);
@@ -243,14 +243,14 @@ static Error* eat_name(pk_Lexer* self){
 
     int length = (int)(self->curr_char - self->token_start);
     if(length == 0) return SyntaxError("@id contains invalid char");
-    c11_stringview name = {self->token_start, length};
+    c11_sv name = {self->token_start, length};
 
     if(self->src->mode == JSON_MODE) {
-        if(c11_string__cmp3(name, "true") == 0) {
+        if(c11_sv__cmp3(name, "true") == 0) {
             add_token(self, TK_TRUE);
-        } else if(c11_string__cmp3(name, "false") == 0) {
+        } else if(c11_sv__cmp3(name, "false") == 0) {
             add_token(self, TK_FALSE);
-        } else if(c11_string__cmp3(name, "null") == 0) {
+        } else if(c11_sv__cmp3(name, "null") == 0) {
             add_token(self, TK_NONE);
         } else {
             return SyntaxError("invalid JSON token");
@@ -260,12 +260,12 @@ static Error* eat_name(pk_Lexer* self){
 
     const char** KW_BEGIN = pk_TokenSymbols + TK_FALSE;
     int KW_COUNT = TK__COUNT__ - TK_FALSE;
-    #define less(a, b) (c11_string__cmp3(b, a) > 0)
+    #define less(a, b) (c11_sv__cmp3(b, a) > 0)
     int out;
     c11__lower_bound(const char*, KW_BEGIN, KW_COUNT, name, less, &out);
     #undef less
 
-    if(out != KW_COUNT && c11_string__cmp3(name, KW_BEGIN[out]) == 0) {
+    if(out != KW_COUNT && c11_sv__cmp3(name, KW_BEGIN[out]) == 0) {
         add_token(self, (TokenIndex)(out + TK_FALSE));
     } else {
         add_token(self, TK_ID);
@@ -361,7 +361,7 @@ static Error* eat_number(pk_Lexer* self){
         is_scientific_notation = true;
     }
 
-    c11_stringview text = {self->token_start, i - self->token_start};
+    c11_sv text = {self->token_start, i - self->token_start};
     self->curr_char = i;
 
     if(text.data[0] != '.' && !is_scientific_notation) {
@@ -552,9 +552,9 @@ static Error* from_precompiled(pk_Lexer* self) {
     TokenDeserializer__ctor(&deserializer, self->src->source);
 
     deserializer.curr += 5;  // skip "pkpy:"
-    c11_stringview version = TokenDeserializer__read_string(&deserializer, '\n');
+    c11_sv version = TokenDeserializer__read_string(&deserializer, '\n');
 
-    if(c11_string__cmp3(version, PK_VERSION) != 0) {
+    if(c11_sv__cmp3(version, PK_VERSION) != 0) {
         return SyntaxError("precompiled version mismatch");
     }
     if(TokenDeserializer__read_uint(&deserializer, '\n') != (int64_t)self->src->mode){
@@ -564,7 +564,7 @@ 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_stringview item = TokenDeserializer__read_string(&deserializer, '\n');
+        c11_sv 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);
     }
@@ -618,16 +618,16 @@ static Error* from_precompiled(pk_Lexer* self) {
     return NULL;
 }
 
-IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base) {
+IntParsingResult parse_uint(c11_sv text, int64_t* out, int base) {
     *out = 0;
 
-    c11_stringview prefix = {.data = text.data, .size = PK_MIN(2, text.size)};
+    c11_sv prefix = {.data = text.data, .size = PK_MIN(2, text.size)};
     if(base == -1) {
-        if(c11_string__cmp3(prefix, "0b") == 0)
+        if(c11_sv__cmp3(prefix, "0b") == 0)
             base = 2;
-        else if(c11_string__cmp3(prefix, "0o") == 0)
+        else if(c11_sv__cmp3(prefix, "0o") == 0)
             base = 8;
-        else if(c11_string__cmp3(prefix, "0x") == 0)
+        else if(c11_sv__cmp3(prefix, "0x") == 0)
             base = 16;
         else
             base = 10;
@@ -649,9 +649,9 @@ IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base) {
         return IntParsing_SUCCESS;
     } else if(base == 2) {
         // 2-base   0b101010
-        if(c11_string__cmp3(prefix, "0b") == 0) {
+        if(c11_sv__cmp3(prefix, "0b") == 0) {
             // text.remove_prefix(2);
-            text = (c11_stringview){text.data + 2, text.size - 2};
+            text = (c11_sv){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -667,9 +667,9 @@ IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base) {
         return IntParsing_SUCCESS;
     } else if(base == 8) {
         // 8-base   0o123
-        if(c11_string__cmp3(prefix, "0o") == 0) {
+        if(c11_sv__cmp3(prefix, "0o") == 0) {
             // text.remove_prefix(2);
-            text = (c11_stringview){text.data + 2, text.size - 2};
+            text = (c11_sv){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -685,9 +685,9 @@ IntParsingResult parse_uint(c11_stringview text, int64_t* out, int base) {
         return IntParsing_SUCCESS;
     } else if(base == 16) {
         // 16-base  0x123
-        if(c11_string__cmp3(prefix, "0x") == 0) {
+        if(c11_sv__cmp3(prefix, "0x") == 0) {
             // text.remove_prefix(2);
-            text = (c11_stringview){text.data + 2, text.size - 2};
+            text = (c11_sv){text.data + 2, text.size - 2};
         }
         if(text.size == 0) return IntParsing_FAILURE;
         for(int i = 0; i < text.size; i++) {
@@ -759,7 +759,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
 
     c11__foreach(Token, &nexts, token) {
         if(is_raw_string_used(token->type)) {
-            c11_stringview token_sv = {token->start, token->length};
+            c11_sv token_sv = {token->start, token->length};
             if(!c11_smallmap_s2n__contains(&token_indices, token_sv)) {
                 c11_smallmap_s2n__set(&token_indices, token_sv, 0);
             }
@@ -790,7 +790,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
 
         if(is_raw_string_used(token->type)) {
             uint16_t *p = c11_smallmap_s2n__try_get(
-                &token_indices, (c11_stringview){token->start, token->length});
+                &token_indices, (c11_sv){token->start, token->length});
             assert(p != NULL);
             pk_SStream__write_int(&ss, (int)*p);
             pk_SStream__write_char(&ss, ',');
@@ -821,7 +821,7 @@ Error* pk_Lexer__process_and_dump(pk_SourceData_ src, c11_string** out) {
                 break;
             case TokenValue_STR: {
                 pk_SStream__write_char(&ss, 'S');
-                c11_stringview sv = c11_string__view(token->value._str);
+                c11_sv sv = c11_string__view(token->value._str);
                 for(int i=0; i<sv.size; i++){
                     pk_SStream__write_hex(&ss, sv.data[i], false);
                 }
@@ -882,17 +882,17 @@ bool TokenDeserializer__match_char(TokenDeserializer* self, char c){
     return false;
 }
 
-c11_stringview TokenDeserializer__read_string(TokenDeserializer* self, char c){
+c11_sv TokenDeserializer__read_string(TokenDeserializer* self, char c){
     const char* start = self->curr;
     while(*self->curr != c)
         self->curr++;
-    c11_stringview retval = {start, (int)(self->curr-start)};
+    c11_sv retval = {start, (int)(self->curr-start)};
     self->curr++;  // skip the delimiter
     return retval;
 }
 
 c11_string* TokenDeserializer__read_string_from_hex(TokenDeserializer* self, char c){
-    c11_stringview sv = TokenDeserializer__read_string(self, c);
+    c11_sv sv = TokenDeserializer__read_string(self, c);
     const char* s = sv.data;
     pk_SStream ss;
     pk_SStream__ctor(&ss);
@@ -933,7 +933,7 @@ int64_t TokenDeserializer__read_uint(TokenDeserializer* self, char c){
 }
 
 double TokenDeserializer__read_float(TokenDeserializer* self, char c){
-    c11_stringview sv = TokenDeserializer__read_string(self, c);
+    c11_sv sv = TokenDeserializer__read_string(self, c);
     // TODO: optimize this
     c11_string* nullterm = c11_string__new2(sv.data, sv.size);
     char* end;

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_stringview name) {
+FuncDecl_ FuncDecl__rcnew(pk_SourceData_ src, c11_sv name) {
     FuncDecl* self = malloc(sizeof(FuncDecl));
     self->rc.count = 1;
     self->rc.dtor = (void (*)(void*))FuncDecl__dtor;
@@ -46,7 +46,7 @@ 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_stringview name) {
+void CodeObject__ctor(CodeObject* self, pk_SourceData_ src, c11_sv name) {
     self->src = src;
     PK_INCREF(src);
     self->name = c11_string__new2(name.data, name.size);