cig/scanner.c

#include "cig.h"

#include <ctype.h>
#include <string.h>
#include <errno.h>

scanner_t make_scanner(char const *name, char const *buffer, allocator_t allocator) {
	scanner_t s = {
		.name = name,
		.start = buffer,
		.cur = buffer,
		.allocator = allocator
	};
	return s;
}

void scanner_recover(scanner_t *s) {
	while (*s->cur && *s->cur != '\n') {
		s->cur++;
	}
	if (*s->cur == '\n')
		s->cur++;  // move *past* the newline
}

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, 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
		}
	};

}

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, char const *lit) {
	char const *save = s->cur;
	while (*lit && *lit == *s->cur) {
		lit++;
		s->cur++;
	}
	if (*lit == '\0') {
		return true;
	}
	s->cur = save;
	return false;
}

int scan_repeat_literal(scanner_t *s, char const *lit) {
	int n_repeats = 0;
	while (scan_literal(s, lit)) {
		n_repeats++;
	}
	return n_repeats;
}

bool scan_whitespace(scanner_t *s) {
	char const *save = s->cur;
	while (isspace((unsigned char)*s->cur)) s->cur++;
	return save != s->cur;
}

scan_result_t scan_digit(scanner_t *s) {
	if (!isdigit((unsigned char)*s->cur)) {
		return scan_error(s, "not a digit");
	}
	scan_result_t ret = scan_value(.digit=(*s->cur) - '0');
	s->cur++;
	return ret;
}

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 scan_error(s, "not an i64");
	}
	s->cur = save;
	char *end;
	errno = 0;
	int64_t val = strtoll(s->cur, &end, 10);
	if (end == s->cur) {
		s->cur = save;
		return scan_error(s, "not an i64");
	}
	if (errno == ERANGE) {
		return scan_error(s, "integer does not fit in i64 value");
	}
	s->cur = end;
	return scan_value(.i64=val);
}

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)result.value.i64;
	int64_t back = (int64_t)val;
	if (back != result.value.i64) {
		return scan_error(s, "int does not fit in i32 value");
	}
	return scan_value(val);
}

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)result.value.i64;
	int64_t back = (int64_t)val;
	if (back != result.value.i64) {
		return scan_error(s, "int does not fit in i16 value");
	}
	return scan_value(val);
}

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)result.value.i64;
	int64_t back = (int64_t)val;
	if (back != result.value.i64) {
		return scan_error(s, "int does not fit in i8 value");
	}
	return scan_value(val);
}

scan_result_t scan_u64(scanner_t *s) {
	char const *save = s->cur;
	if (*s->cur == '-') {
		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 scan_error(s, "is not number");
	}
	s->cur = save;
	char *end;
	errno = 0;
	uint64_t val = strtoull(s->cur, &end, 10);
	if (end == s->cur) {
		s->cur = save;
		return scan_error(s, "is not number");
		// TODO: standardize error messages
	}
	if (errno == ERANGE) {
		return scan_error(s, "integer does not fit in u64 value");
	}
	s->cur = end;
	return scan_value(.u64=val);
}

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)result.value.u64;
	uint64_t back = (uint64_t)val;
	if (back != result.value.u64) {
		return scan_error(s, "int does not fit in u32 value");
	}
	return scan_value(val);
}

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)result.value.u64;
	uint64_t back = (uint64_t)val;
	if (back != result.value.u64) {
		return scan_error(s, "int does not fit in u16 value");
	}
	return scan_value(val);
}

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)result.value.u64;
	uint64_t back = (uint64_t)val;
	if (back != result.value.u64) {
		return scan_error(s, "int does not fit in u8 value");
	}
	return scan_value(val);
}

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 scan_error(s, "not a f64");
	}
	if (errno == ERANGE) {
		return scan_error(s, "float does not fit in f64 value");
	}
	s->cur = end;
	return scan_value(.f64=val);
}

scan_result_t scan_f32(scanner_t *s) {
	scan_result_t result = scan_f64(s);
	if (!result.ok) {
		return result;
	}
	float val = (float)result.value.f64;
	double back = (double)val;
	if (back != result.value.f64) {
		return scan_error(s, "float does not fit in f32 value");
	}
	return scan_value(.f32=val);
}

scan_result_t scan_identifier(scanner_t *s) {
	if (!isalpha((unsigned char)*s->cur) && *s->cur != '_') {
		return scan_error(s, "not an identifier");
	}
	char const *start = s->cur++;
	while (isalnum((unsigned char)*s->cur) || *s->cur == '_') {
		s->cur++;
	}
	size_t len = s->cur - start;
	char *buf = allocator_alloc(s->allocator, len + 1);
	memcpy(buf, start, len);
	buf[len] = '\0';
	return scan_value(.identifier=buf);
}


scan_result_t scan_string_literal(scanner_t *s) {
	char const *save = s->cur;
	if (*s->cur != '"')
		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) {
				case 'n': c = '\n'; break;
				case 't': c = '\t'; break;
				case 'r': c = '\r'; break;
				case '\\': c = '\\'; break;
				case '"': c = '"'; break;
				case '0': c = '\0'; break;
				default:
					ret = scan_error(s, "invalid escape sequence");
					s->cur = save;
					return ret;
			}
		}
		if (len + 2 >= cap) {
			cap *= 2;
			buf = allocator_resize(s->allocator, buf, cap);
		}
		buf[len++] = c;
	}
	if (*s->cur != '"') {
		scan_result_t ret = scan_error(s, "unterminated string literal");
		s->cur = save;
		return ret;
	}
	s->cur++; // skip closing quote
	buf[len] = '\0';
	return scan_value(.string_literal=buf);
}

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 did_print_errors;
}

bool looks_like_float(scanner_t *s) {
	char const *cur = s->cur;
	if (
		((*cur) == '+') ||
		((*cur) == '-')
	) {
		cur++;
	}
	if (!isdigit(((unsigned char)*cur))) {
		return false;
	} else {
		cur++;
	}
	while (isdigit(((unsigned char)*cur))) {
		cur++;
	}
	if ((*cur) != '.') {
		return false;
	} else {
		cur++;
	}
	return isdigit(((unsigned char)*cur));
}

bool looks_like_int(scanner_t *s) {
	char const *cur = s->cur;
	if (*cur == '+' || *cur == '-') {
		cur++;
	}
	return isdigit(*cur);
}