mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-20 11:30:18 +00:00
some rename
This commit is contained in:
blueloveTH
parent
c6185c3d9c
commit
4542f23143
@ -10,27 +10,28 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct pk_SStream {
|
||||
typedef struct c11_sbuf {
|
||||
c11_vector data;
|
||||
} pk_SStream;
|
||||
} c11_sbuf;
|
||||
|
||||
void pk_SStream__ctor(pk_SStream* self);
|
||||
void pk_SStream__dtor(pk_SStream* self);
|
||||
void c11_sbuf__ctor(c11_sbuf* self);
|
||||
void c11_sbuf__dtor(c11_sbuf* self);
|
||||
|
||||
void pk_SStream__write_int(pk_SStream* self, int);
|
||||
void pk_SStream__write_i64(pk_SStream* self, int64_t);
|
||||
void pk_SStream__write_f64(pk_SStream* self, double, int precision);
|
||||
void pk_SStream__write_char(pk_SStream* self, char);
|
||||
void pk_SStream__write_sv(pk_SStream* self, c11_sv);
|
||||
void pk_SStream__write_cstr(pk_SStream* self, const char*);
|
||||
void pk_SStream__write_cstrn(pk_SStream* self, const char*, int);
|
||||
void pk_SStream__write_hex(pk_SStream* self, unsigned char, bool non_zero);
|
||||
void pk_SStream__write_ptr(pk_SStream* self, void*);
|
||||
void c11_sbuf__write_int(c11_sbuf* self, int);
|
||||
void c11_sbuf__write_i64(c11_sbuf* self, int64_t);
|
||||
void c11_sbuf__write_f64(c11_sbuf* self, double, int precision);
|
||||
void c11_sbuf__write_char(c11_sbuf* self, char);
|
||||
void c11_sbuf__write_sv(c11_sbuf* self, c11_sv);
|
||||
void c11_sbuf__write_cstr(c11_sbuf* self, const char*);
|
||||
void c11_sbuf__write_cstrn(c11_sbuf* self, const char*, int);
|
||||
void c11_sbuf__write_quoted(c11_sbuf* self, c11_sv, char quote);
|
||||
void c11_sbuf__write_hex(c11_sbuf* self, unsigned char, bool non_zero);
|
||||
void c11_sbuf__write_ptr(c11_sbuf* self, void*);
|
||||
// Submit the stream and return the final string. The stream becomes invalid after this call
|
||||
c11_string* pk_SStream__submit(pk_SStream* self);
|
||||
c11_string* c11_sbuf__submit(c11_sbuf* self);
|
||||
|
||||
void pk_vsprintf(pk_SStream* ss, const char* fmt, va_list args);
|
||||
void pk_sprintf(pk_SStream* ss, const char* fmt, ...);
|
||||
void pk_vsprintf(c11_sbuf* ss, const char* fmt, va_list args);
|
||||
void pk_sprintf(c11_sbuf* ss, const char* fmt, ...);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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];
|
||||
|
||||
@ -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){
|
||||
|
||||
18
src/error.c
18
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);
|
||||
// }
|
||||
@ -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();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user