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

Squash merge feature/scanner_v2 into main
C Tests / Build and Test (push) Successful in 10m52s
Details

Browse Source
This commit is contained in:
roodletoof
2026-10-01 22:19:09 +02:00
parent 27c5c4a55b
commit af356a0d71
10 changed files with 260 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scanner.c
+136 -147
View File
@@ -4,13 +4,11 @@
#include <string.h>
#include <errno.h>
scanner_t make_scanner(const char *name, const char *buffer, allocator_t allocator) {
scanner_t make_scanner(char const *name, char const *buffer, allocator_t allocator) {
scanner_t s = {
.name = name,
.start = buffer,
.cur = buffer,
.value = {0},
.errors = NULL,
.allocator = allocator
};
return s;
@@ -24,47 +22,46 @@ void scanner_recover(scanner_t *s) {
s->cur++; // move *past* the newline
}
void scanner_error(scanner_t *s, const char *message) {
const char *error_pos = s->cur; // use current scanner position
scan_result_t scan_error(scanner_t *s, char const * message) {
char const *error_pos = s->cur; // use current scanner position
// Compute line + column (1-based)
int line = 1, col = 1;
for (const char *p = s->start; p < error_pos; p++) {
if (*p == '\n') { line++; col = 1; }
else col++;
}
// need 40 bytes for pair of largest possible 64 bit values, then some for
// ':' and ' ' characters. Just rounded up to 64 because reasons.
size_t length = strlen(s->name) + 1 + strlen(message) + 1 + 64;
char *buf = allocator_alloc(s->allocator, length);
snprintf(
buf,
length,
"%s:%d:%d: %s",
s->name, line, col, message
);
error_node_t *node = allocator_alloc(s->allocator, sizeof(error_node_t));
node->msg = buf;
node->next = NULL;
if (!s->errors) {
s->errors = node;
} else {
error_node_t *p = s->errors;
while (p->next) p = p->next;
p->next = node;
int line = 1, column = 1;
for (char const *p = s->start; p < error_pos; p++) {
if (*p == '\n') { line++; column = 1; }
else column++;
}
return (scan_result_t) {
.ok=false,
.error=(scan_error_t) {
.message=message,
.buffer_name=s->name,
.line=line,
.column=column
}
};
}
void scanner_error_and_recover(scanner_t *s, const char *message) {
scanner_error(s, message);
scan_result_t scan_value_func(scan_value_t value) {
return (scan_result_t) {
.ok=true,
.value=value,
};
}
scan_result_t scan_error_and_recover(scanner_t *s, char const *message) {
scan_result_t result = scan_error(s, message);
scanner_recover(s);
return result;
}
bool scan_eof(scanner_t *s) {
return *s->cur == '\0';
}
bool scan_literal(scanner_t *s, const char *lit) {
const char *save = s->cur;
bool scan_literal(scanner_t *s, char const *lit) {
char const *save = s->cur;
while (*lit && *lit == *s->cur) {
lit++;
s->cur++;
@@ -76,7 +73,7 @@ bool scan_literal(scanner_t *s, const char *lit) {
return false;
}
int scan_repeat_literal(scanner_t *s, const char *lit) {
int scan_repeat_literal(scanner_t *s, char const *lit) {
int n_repeats = 0;
while (scan_literal(s, lit)) {
n_repeats++;
@@ -85,26 +82,26 @@ int scan_repeat_literal(scanner_t *s, const char *lit) {
}
bool scan_whitespace(scanner_t *s) {
const char *save = s->cur;
char const *save = s->cur;
while (isspace((unsigned char)*s->cur)) s->cur++;
return save != s->cur;
}
bool scan_digit(scanner_t *s) {
scan_result_t scan_digit(scanner_t *s) {
if (!isdigit((unsigned char)*s->cur)) {
return false;
return scan_error(s, "not a digit");
}
s->value.digit = (*s->cur) - '0';
scan_result_t ret = scan_value(.digit=(*s->cur) - '0');
s->cur++;
return true;
return ret;
}
bool scan_i64(scanner_t *s) {
const char *save = s->cur;
scan_result_t scan_i64(scanner_t *s) {
char const *save = s->cur;
if (*s->cur == '-' || *s->cur == '+') s->cur++;
if (!isdigit((unsigned char)*s->cur)) {
s->cur = save;
return false;
return scan_error(s, "not an i64");
}
s->cur = save;
char *end;
@@ -112,69 +109,63 @@ bool scan_i64(scanner_t *s) {
int64_t val = strtoll(s->cur, &end, 10);
if (end == s->cur) {
s->cur = save;
return false;
return scan_error(s, "not an i64");
}
if (errno == ERANGE) {
scanner_error(s, "integer does not fit in i64 value");
return false;
return scan_error(s, "integer does not fit in i64 value");
}
s->cur = end;
s->value.i64 = val;
return true;
return scan_value(.i64=val);
}
bool scan_i32(scanner_t *s) {
if (!scan_i64(s)) {
return false;
scan_result_t scan_i32(scanner_t *s) {
scan_result_t result = scan_i64(s);
if (!result.ok) {
return result;
}
int32_t val = (int32_t)s->value.i64;
int32_t val = (int32_t)result.value.i64;
int64_t back = (int64_t)val;
if (back != s->value.i64) {
scanner_error(s, "int does not fit in i32 value");
return false;
if (back != result.value.i64) {
return scan_error(s, "int does not fit in i32 value");
}
s->value.i32 = val;
return true;
return scan_value(val);
}
bool scan_i16(scanner_t *s) {
if (!scan_i64(s)) {
return false;
scan_result_t scan_i16(scanner_t *s) {
scan_result_t result = scan_i64(s);
if (!result.ok) {
return result;
}
int16_t val = (int16_t)s->value.i64;
int16_t val = (int16_t)result.value.i64;
int64_t back = (int64_t)val;
if (back != s->value.i64) {
scanner_error(s, "int does not fit in i16 value");
return false;
if (back != result.value.i64) {
return scan_error(s, "int does not fit in i16 value");
}
s->value.i16 = val;
return true;
return scan_value(val);
}
bool scan_i8(scanner_t *s) {
if (!scan_i64(s)) {
return false;
scan_result_t scan_i8(scanner_t *s) {
scan_result_t result = scan_i64(s);
if (!result.ok) {
return result;
}
int8_t val = (int8_t)s->value.i64;
int8_t val = (int8_t)result.value.i64;
int64_t back = (int64_t)val;
if (back != s->value.i64) {
scanner_error(s, "int does not fit in i8 value");
return false;
if (back != result.value.i64) {
return scan_error(s, "int does not fit in i8 value");
}
s->value.i8 = val;
return true;
return scan_value(val);
}
bool scan_u64(scanner_t *s) {
const char *save = s->cur;
scan_result_t scan_u64(scanner_t *s) {
char const *save = s->cur;
if (*s->cur == '-') {
scanner_error(s, "- is not allowed for unsigned integers");
return false;
return scan_error(s, "- is not allowed for unsigned integers");
}
if (*s->cur == '+') s->cur++;
if (!isdigit((unsigned char)*s->cur)) {
s->cur = save;
return false;
return scan_error(s, "is not number");
}
s->cur = save;
char *end;
@@ -182,96 +173,89 @@ bool scan_u64(scanner_t *s) {
uint64_t val = strtoull(s->cur, &end, 10);
if (end == s->cur) {
s->cur = save;
return false;
return scan_error(s, "is not number");
// TODO: standardize error messages
}
if (errno == ERANGE) {
scanner_error(s, "integer does not fit in u64 value");
return false;
return scan_error(s, "integer does not fit in u64 value");
}
s->cur = end;
s->value.u64 = val;
return true;
return scan_value(.u64=val);
}
bool scan_u32(scanner_t *s) {
if (!scan_u64(s)) {
return false;
scan_result_t scan_u32(scanner_t *s) {
scan_result_t result = scan_u64(s);
if (!result.ok) {
return result;
}
uint32_t val = (uint32_t)s->value.u64;
uint32_t val = (uint32_t)result.value.u64;
uint64_t back = (uint64_t)val;
if (back != s->value.u64) {
scanner_error(s, "int does not fit in u32 value");
return false;
if (back != result.value.u64) {
return scan_error(s, "int does not fit in u32 value");
}
s->value.u32 = val;
return true;
return scan_value(val);
}
bool scan_u16(scanner_t *s) {
if (!scan_u64(s)) {
return false;
scan_result_t scan_u16(scanner_t *s) {
scan_result_t result = scan_u64(s);
if (!result.ok) {
return result;
}
uint16_t val = (uint16_t)s->value.u64;
uint16_t val = (uint16_t)result.value.u64;
uint64_t back = (uint64_t)val;
if (back != s->value.u64) {
scanner_error(s, "int does not fit in u16 value");
return false;
if (back != result.value.u64) {
return scan_error(s, "int does not fit in u16 value");
}
s->value.u16 = val;
return true;
return scan_value(val);
}
bool scan_u8(scanner_t *s) {
if (!scan_u64(s)) {
return false;
scan_result_t scan_u8(scanner_t *s) {
scan_result_t result = scan_u64(s);
if (!result.ok) {
return result;
}
uint8_t val = (uint8_t)s->value.u64;
uint8_t val = (uint8_t)result.value.u64;
uint64_t back = (uint64_t)val;
if (back != s->value.u64) {
scanner_error(s, "int does not fit in u8 value");
return false;
if (back != result.value.u64) {
return scan_error(s, "int does not fit in u8 value");
}
s->value.u8 = val;
return true;
return scan_value(val);
}
bool scan_f64(scanner_t *s) {
const char *save = s->cur;
scan_result_t scan_f64(scanner_t *s) {
char const *save = s->cur;
char *end;
errno = 0;
double val = strtod(s->cur, &end);
if (end == s->cur) {
s->cur = save;
return false;
return scan_error(s, "not a f64");
}
if (errno == ERANGE) {
scanner_error(s, "float does not fit in f64 value");
return false;
return scan_error(s, "float does not fit in f64 value");
}
s->cur = end;
s->value.f64 = val;
return true;
return scan_value(.f64=val);
}
bool scan_f32(scanner_t *s) {
if (!scan_f64(s)) {
return false;
scan_result_t scan_f32(scanner_t *s) {
scan_result_t result = scan_f64(s);
if (!result.ok) {
return result;
}
float val = (float)s->value.f64;
float val = (float)result.value.f64;
double back = (double)val;
if (back != s->value.f64) {
scanner_error(s, "float does not fit in f32 value");
return false;
if (back != result.value.f64) {
return scan_error(s, "float does not fit in f32 value");
}
s->value.f32 = val;
return true;
return scan_value(.f32=val);
}
bool scan_identifier(scanner_t *s) {
scan_result_t scan_identifier(scanner_t *s) {
if (!isalpha((unsigned char)*s->cur) && *s->cur != '_') {
return false;
return scan_error(s, "not an identifier");
}
const char *start = s->cur++;
char const *start = s->cur++;
while (isalnum((unsigned char)*s->cur) || *s->cur == '_') {
s->cur++;
}
@@ -279,21 +263,21 @@ bool scan_identifier(scanner_t *s) {
char *buf = allocator_alloc(s->allocator, len + 1);
memcpy(buf, start, len);
buf[len] = '\0';
s->value.identifier = buf;
return true;
return scan_value(.identifier=buf);
}
bool scan_string_literal(scanner_t *s) {
const char *save = s->cur;
scan_result_t scan_string_literal(scanner_t *s) {
char const *save = s->cur;
if (*s->cur != '"')
return false;
return scan_error(s, "not a string");
s->cur++; // skip opening quote
char *buf = allocator_alloc(s->allocator, 256);
size_t cap = 256;
size_t len = 0;
while (*s->cur && *s->cur != '"') {
char c = *s->cur++;
scan_result_t ret;
if (c == '\\') {
char esc = *s->cur++;
switch (esc) {
@@ -304,9 +288,9 @@ bool scan_string_literal(scanner_t *s) {
case '"': c = '"'; break;
case '0': c = '\0'; break;
default:
scanner_error(s, "invalid escape sequence");
ret = scan_error(s, "invalid escape sequence");
s->cur = save;
return false;
return ret;
}
}
if (len + 2 >= cap) {
@@ -316,25 +300,30 @@ bool scan_string_literal(scanner_t *s) {
buf[len++] = c;
}
if (*s->cur != '"') {
scanner_error(s, "unterminated string literal");
scan_result_t ret = scan_error(s, "unterminated string literal");
s->cur = save;
return false;
return ret;
}
s->cur++; // skip closing quote
buf[len] = '\0';
s->value.string_literal = buf;
return true;
return scan_value(.string_literal=buf);
}
bool scanner_print_errors(scanner_t *s, FILE *fp) {
for (error_node_t *node = s->errors; node != NULL; node = node->next) {
fprintf(fp, "%s\n", node->msg);
bool scanner_print_errors_func(FILE *fp, scan_result_t const *results, int results_len) {
bool did_print_errors = false;
for (int i = 0; i < results_len; i++) {
scan_result_t res = results[i];
if (!res.ok) {
scan_error_t err = res.error;
fprintf(fp, "%s:%d:%d: %s", err.buffer_name, err.line, err.column, err.message);
did_print_errors = true;
}
}
return s->errors != NULL;
return did_print_errors;
}
bool looks_like_float(scanner_t *s) {
const char *cur = s->cur;
char const *cur = s->cur;
if (
((*cur) == '+') ||
((*cur) == '-')
@@ -358,7 +347,7 @@ bool looks_like_float(scanner_t *s) {
}
bool looks_like_int(scanner_t *s) {
const char *cur = s->cur;
char const *cur = s->cur;
if (*cur == '+' || *cur == '-') {
cur++;
}