roodletoof/cig
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

some progress on scanner. begin clusterfuck map

Browse Source
This commit is contained in:
Ivar Fatland
2026-03-29 21:50:59 +02:00
parent e41ef17d6b
commit 253e095e4d
3 changed files with 62 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cig.h
+3 -1
View File
@@ -263,7 +263,9 @@ typedef struct map_create_func_args {
void *map_create_func(map_create_func_args_t args); void *map_create_func(map_create_func_args_t args);
// key should be the first item in the key-value struct.
#define init_map(PTR, ...) do { \ #define init_map(PTR, ...) do { \
STATIC_ASSERT(((size_t)PTR) == ((size_t)(&PTR->key))); \
PTR = map_create_func((map_create_func_args_t) { \ PTR = map_create_func((map_create_func_args_t) { \
.itemsize=sizeof(*PTR), \ .itemsize=sizeof(*PTR), \
.keysize=sizeof(PTR->key), \ .keysize=sizeof(PTR->key), \
@@ -350,7 +352,7 @@ typedef struct scan_error {
const char *filename; const char *filename;
int line; int line;
int column; int column;
const char *error_message; const char *message;
} scan_error_t; } scan_error_t;
typedef struct scan_result { typedef struct scan_result {
map.c
+27 -14
View File
@@ -1,6 +1,9 @@
#include "cig.h" #include "cig.h"
#include <assert.h> #include <assert.h>
#define FREE (-1)
#define GRAVESTONE (-2)
static inline int mapping_cap(int capacity) { static inline int mapping_cap(int capacity) {
return capacity * 2; return capacity * 2;
} }
@@ -58,21 +61,27 @@ void *map_create_func(
void *map_grow_func(void *this, const char *file, int line) { void *map_grow_func(void *this, const char *file, int line) {
map_header_t *header = PTR_FROM_FIELD_PTR(map_header_t, bytes, this); map_header_t *header = PTR_FROM_FIELD_PTR(map_header_t, bytes, this);
allocator_t allocator = header->allocator; int new_size = header->n_items + 1;
int new_capacity = 1;
if (header->capacity > 0) {
new_capacity = header->capacity * 2;
}
internal_map_sizes_t new_size = internal_map_sizes(
new_capacity,
header->itemsize
);
header = allocator_resize_func(allocator, header, new_size.bytes, file, line);
// TODO!!! Overwrite the mapping arr with -1, then iterate through the
// items arr and find the hashes of the values to populate the mappings
// arr.
assert(false && "TODO");
if (header->capacity < new_size) {
allocator_t allocator = header->allocator;
int new_capacity = 1;
if (header->capacity > 0) {
new_capacity = header->capacity * 2;
}
internal_map_sizes_t new_size = internal_map_sizes(
new_capacity,
header->itemsize
);
header = allocator_resize_func(allocator, header, new_size.bytes, file, line);
// TODO!!! Overwrite the mapping arr with -1, then iterate through the
// items arr and find the hashes of the values to populate the mappings
// arr.
assert(false && "TODO");
TODO
}
header->n_items = new_size;
return header->bytes; return header->bytes;
} }
@@ -91,3 +100,7 @@ int map_cap(void *this) {
map_header_t *header = PTR_FROM_FIELD_PTR(map_header_t, bytes, this); map_header_t *header = PTR_FROM_FIELD_PTR(map_header_t, bytes, this);
return header->capacity; return header->capacity;
} }
#undef FREE
#undef GRAVESTONE
scanner.c
+32 -87
View File
@@ -37,7 +37,7 @@ scan_error_t scan_error(const scan_t *s, const char *message) {
.filename = s->name, .filename = s->name,
.line = line, .line = line,
.column = col, .column = col,
.error_message = message .message = message
}; };
} }
@@ -65,7 +65,7 @@ scan_result_t scan_literal(scan_t *s, const char *lit) {
s->cur++; s->cur++;
} }
if (*lit == '\0') { if (*lit == '\0') {
return scan_value_result(); return scan_value_result(0);
} }
s->cur = save; s->cur = save;
return scan_error_result(s, "invalid literal"); return scan_error_result(s, "invalid literal");
@@ -117,12 +117,7 @@ scan_result_t scan_i64(scan_t *s) {
return scan_error_result(s, "integer does not fit in i64 value"); return scan_error_result(s, "integer does not fit in i64 value");
} }
s->cur = end; s->cur = end;
return (scan_result_t){ return scan_value_result(.i64=val);
.ok=true,
.value=(scan_value_t){
.i64=val,
},
};
} }
scan_result_t scan_i32(scan_t *s) { scan_result_t scan_i32(scan_t *s) {
@@ -135,12 +130,7 @@ scan_result_t scan_i32(scan_t *s) {
if (back != result_i64.value.i64) { if (back != result_i64.value.i64) {
return scan_error_result(s, "integer does not fit in i32 value"); return scan_error_result(s, "integer does not fit in i32 value");
} }
return (scan_result_t) { return scan_value_result(.i32=val);
.ok=true,
.value=(scan_value_t){
.i32=val,
},
};
} }
scan_result_t scan_i16(scan_t *s) { scan_result_t scan_i16(scan_t *s) {
@@ -153,12 +143,7 @@ scan_result_t scan_i16(scan_t *s) {
if (back != result_i64.value.i64) { if (back != result_i64.value.i64) {
return scan_error_result(s, "integer does not fit in i16 value"); return scan_error_result(s, "integer does not fit in i16 value");
} }
return (scan_result_t) { return scan_value_result(.i16=val);
.ok=true,
.value=(scan_value_t){
.i16=val,
},
};
} }
scan_result_t scan_i8(scan_t *s) { scan_result_t scan_i8(scan_t *s) {
@@ -171,12 +156,7 @@ scan_result_t scan_i8(scan_t *s) {
if (back != result_i64.value.i64) { if (back != result_i64.value.i64) {
return scan_error_result(s, "integer does not fit in i8 value"); return scan_error_result(s, "integer does not fit in i8 value");
} }
return (scan_result_t) { return scan_value_result(.i8=val);
.ok=true,
.value=(scan_value_t){
.i8=val,
},
};
} }
scan_result_t scan_u64(scan_t *s) { scan_result_t scan_u64(scan_t *s) {
@@ -201,12 +181,7 @@ scan_result_t scan_u64(scan_t *s) {
return scan_error_result(s, "integer does not fit in i64 value"); return scan_error_result(s, "integer does not fit in i64 value");
} }
s->cur = end; s->cur = end;
return (scan_result_t){ return scan_value_result(.u64=val);
.ok=true,
.value=(scan_value_t){
.u64=val,
},
};
} }
scan_result_t scan_u32(scan_t *s) { scan_result_t scan_u32(scan_t *s) {
@@ -219,12 +194,7 @@ scan_result_t scan_u32(scan_t *s) {
if (back != result_u64.value.u64) { if (back != result_u64.value.u64) {
return scan_error_result(s, "integer does not fit in u32 values"); return scan_error_result(s, "integer does not fit in u32 values");
} }
return (scan_result_t) { return scan_value_result(.u32=val);
.ok=true,
.value=(scan_value_t){
.u32=val,
},
};
} }
scan_result_t scan_u16(scan_t *s) { scan_result_t scan_u16(scan_t *s) {
@@ -237,12 +207,7 @@ scan_result_t scan_u16(scan_t *s) {
if (back != result_u64.value.u64) { if (back != result_u64.value.u64) {
return scan_error_result(s, "integer does not fit in u16 value"); return scan_error_result(s, "integer does not fit in u16 value");
} }
return (scan_result_t) { return scan_value_result(.u16=val);
.ok=true,
.value=(scan_value_t){
.u16=val,
},
};
} }
scan_result_t scan_u8(scan_t *s) { scan_result_t scan_u8(scan_t *s) {
@@ -255,12 +220,7 @@ scan_result_t scan_u8(scan_t *s) {
if (back != result_u64.value.u64) { if (back != result_u64.value.u64) {
return scan_error_result(s, "integer does not fit in u8 value"); return scan_error_result(s, "integer does not fit in u8 value");
} }
return (scan_result_t) { return scan_value_result(.u8=val);
.ok=true,
.value=(scan_value_t){
.u8=val,
},
};
} }
scan_result_t scan_f64(scan_t *s) { scan_result_t scan_f64(scan_t *s) {
@@ -276,49 +236,45 @@ scan_result_t scan_f64(scan_t *s) {
return scan_error_result(s, "float does not fit in f64 value"); return scan_error_result(s, "float does not fit in f64 value");
} }
s->cur = end; s->cur = end;
return (scan_result_t) { return scan_value_result(.f64=val);
.ok=true,
.value=(scan_value_t){
.f64=val,
},
};
} }
bool scan_f32(scan_t *s) { scan_result_t scan_f32(scan_t *s) {
if (!scan_f64(s)) { scan_result_t result_f64 = scan_f64(s);
return false; if (!result_f64.ok) {
return result_f64;
} }
float val = (float)s->value.f64; float val = (float)result_f64.value.f64;
double back = (double)val; double back = (double)val;
if (back != s->value.f64) { if (back != result_f64.value.f64) {
scan_error(s, "float does not fit in f32 value"); return scan_error_result(s, "float does not fit in f32 value");
return false;
} }
s->value.f32 = val; return scan_value_result(.f32=val);
return true;
} }
bool scan_identifier(scan_t *s) { scan_result_t scan_identifier(scan_t *s) {
if (!isalpha((unsigned char)*s->cur) && *s->cur != '_') { if (!isalpha((unsigned char)*s->cur) && *s->cur != '_') {
return false; return scan_error_result(s, "not an identifier");
} }
const char *start = s->cur++; const char *start = s->cur++;
while (isalnum((unsigned char)*s->cur) || *s->cur == '_') { while (isalnum((unsigned char)*s->cur) || *s->cur == '_') {
s->cur++; s->cur++;
} }
// TODO: use arraylists just to standardize?
size_t len = s->cur - start; size_t len = s->cur - start;
char *buf = allocator_alloc(s->allocator, len + 1); char *buf = allocator_alloc(s->allocator, len + 1);
memcpy(buf, start, len); memcpy(buf, start, len);
buf[len] = '\0'; buf[len] = '\0';
s->value.identifier = buf; return scan_value_result(.identifier=buf);
return true;
} }
bool scan_string_literal(scan_t *s) { scan_result_t scan_string_literal(scan_t *s) {
// TODO: use arraylists just to standardize?
const char *save = s->cur; const char *save = s->cur;
if (*s->cur != '"') if (*s->cur != '"') {
return false; return scan_error_result(s, "missing opening quote");
}
s->cur++; // skip opening quote s->cur++; // skip opening quote
char *buf = allocator_alloc(s->allocator, 256); char *buf = allocator_alloc(s->allocator, 256);
size_t cap = 256; size_t cap = 256;
@@ -335,9 +291,8 @@ bool scan_string_literal(scan_t *s) {
case '"': c = '"'; break; case '"': c = '"'; break;
case '0': c = '\0'; break; case '0': c = '\0'; break;
default: default:
scan_error(s, "invalid escape sequence");
s->cur = save; s->cur = save;
return false; return scan_error_result(s, "invalid excape sequence");
} }
} }
if (len + 2 >= cap) { if (len + 2 >= cap) {
@@ -347,28 +302,18 @@ bool scan_string_literal(scan_t *s) {
buf[len++] = c; buf[len++] = c;
} }
if (*s->cur != '"') { if (*s->cur != '"') {
scan_error(s, "unterminated string literal");
s->cur = save; s->cur = save;
return false; return scan_error_result(s, "unterminated string literal");
} }
s->cur++; // skip closing quote s->cur++; // skip closing quote
buf[len] = '\0'; buf[len] = '\0';
s->value.string_literal = buf; return scan_value_result(.string_literal=buf);
return true;
} }
scan_value_t required(scan_result_t res) { scan_value_t required(scan_result_t res) {
if (!res.ok) { if (!res.ok) {
fprintf(stderr, "%s:%d:%d: %s", res.filename, res.line, res.column, res.error_message); fprintf(stderr, "%s:%d:%d: %s", res.error.filename, res.error.line, res.error.column, res.error.message);
exit(1); exit(1);
} }
return res.value; return res.value;
// TODO
} }
typedef struct scan_error {
const char *filename;
int line;
int column;
const char *error_message;
} scan_error_t;