3262 lines
72 KiB
C
3262 lines
72 KiB
C
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
#include <limits.h>
|
|
|
|
#include <gmp.h>
|
|
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
|
|
#include "avl.h"
|
|
|
|
#define TODO assert(!"TODO");
|
|
#define CHECK assert(!"CHECK");
|
|
|
|
#define argv0 program_invocation_name
|
|
|
|
#ifdef ZDEBUG
|
|
#define zprintf(fmt, ...) \
|
|
printf(fmt, ## __VA_ARGS__);
|
|
#else
|
|
#define zprintf(...);
|
|
#endif
|
|
|
|
const char* command = NULL;
|
|
|
|
static void parse_args(int argc, char* const* argv)
|
|
{
|
|
for (int opt; (opt = getopt(argc, argv, "c:")) != -1; ) switch (opt)
|
|
{
|
|
case 'c':
|
|
command = optarg;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
printf("Unknown option '%c'!" "\n", opt);
|
|
exit(1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct string
|
|
{
|
|
char* data;
|
|
unsigned refcount;
|
|
};
|
|
|
|
struct string* new_string(const char* data_ro)
|
|
{
|
|
struct string* this = malloc(sizeof(*this));
|
|
|
|
this->data = strdup(data_ro);
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct string* new_string_from_fmt_va(const char* fmt, va_list va)
|
|
{
|
|
struct string* this = malloc(sizeof(*this));
|
|
|
|
int x = vasprintf(&this->data, fmt, va);
|
|
|
|
if (x < 0)
|
|
{
|
|
abort();
|
|
}
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct string* new_string_from_fmt(const char* fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
struct string* this = new_string_from_fmt_va(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return this;
|
|
}
|
|
|
|
struct string* inc_string(struct string* this)
|
|
{
|
|
if (this)
|
|
this->refcount++;
|
|
|
|
return this;
|
|
}
|
|
|
|
int compare_strings(const struct string* a, const struct string* b)
|
|
{
|
|
return strcmp(a->data, b->data);
|
|
}
|
|
|
|
int compare_strings_vv(const void* a, const void* b)
|
|
{
|
|
return compare_strings(
|
|
(const struct string*) a,
|
|
(const struct string*) b);
|
|
}
|
|
|
|
void free_string(struct string* this)
|
|
{
|
|
if (this && !--this->refcount)
|
|
{
|
|
free(this->data);
|
|
free(this);
|
|
}
|
|
}
|
|
|
|
void free_string_v(void* ptr)
|
|
{
|
|
free_string((struct string*) ptr);
|
|
}
|
|
|
|
struct stringset
|
|
{
|
|
struct avl_tree_t* tree;
|
|
unsigned refcount;
|
|
};
|
|
|
|
struct stringset* new_stringset(void)
|
|
{
|
|
struct stringset* this = malloc(sizeof(*this));
|
|
|
|
this->tree = avl_alloc_tree(compare_strings_vv, free_string_v);
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
bool stringset_add(struct stringset* this, struct string* new)
|
|
{
|
|
bool is_new;
|
|
|
|
struct avl_node_t* node = avl_insert(this->tree, new);
|
|
|
|
if (node)
|
|
{
|
|
inc_string(new);
|
|
|
|
is_new = true;
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
return is_new;
|
|
}
|
|
|
|
bool stringset_update(struct stringset* this, const struct stringset* updateme)
|
|
{
|
|
bool is_new = false;
|
|
|
|
for (struct avl_node_t* i = updateme->tree->head; i; i = i->next)
|
|
{
|
|
struct avl_node_t* node = avl_insert(this->tree, i->item);
|
|
|
|
if (node)
|
|
{
|
|
inc_string(i->item);
|
|
|
|
is_new = true;
|
|
}
|
|
else if (errno == EEXIST)
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
}
|
|
}
|
|
|
|
return is_new;
|
|
}
|
|
|
|
struct stringset* inc_stringset(struct stringset* this)
|
|
{
|
|
if (this)
|
|
this->refcount++;
|
|
|
|
return this;
|
|
}
|
|
|
|
void stringset_println(const struct stringset* this)
|
|
{
|
|
for (struct avl_node_t* i = this->tree->head; i; i = i->next)
|
|
{
|
|
const struct string* str = i->item;
|
|
|
|
printf("%s\n", str->data);
|
|
}
|
|
}
|
|
|
|
void free_stringset(struct stringset* this)
|
|
{
|
|
if (this && !--this->refcount)
|
|
{
|
|
avl_free_tree(this->tree);
|
|
|
|
free(this);
|
|
}
|
|
}
|
|
|
|
struct value;
|
|
|
|
struct value* inc_value(struct value* this);
|
|
|
|
void free_value(struct value* this);
|
|
|
|
struct expression
|
|
{
|
|
enum expression_kind {
|
|
ek_syntax_error,
|
|
|
|
// primary:
|
|
ek_literal,
|
|
ek_variable,
|
|
|
|
// arithmetic operators:
|
|
ek_positive,
|
|
ek_negative,
|
|
ek_add,
|
|
ek_subtract,
|
|
ek_multiply,
|
|
ek_divide,
|
|
ek_integer_divide,
|
|
ek_remainder,
|
|
ek_exponent,
|
|
|
|
// bitwise operator:
|
|
ek_leftbitshift,
|
|
ek_rightbitshift,
|
|
|
|
// comparision operators:
|
|
ek_greater_than,
|
|
ek_less_than,
|
|
ek_greater_than_equal_to,
|
|
ek_less_than_equal_to,
|
|
|
|
// equality operators:
|
|
ek_equal_to,
|
|
ek_not_equal_to,
|
|
|
|
// logical operators:
|
|
ek_logical_not,
|
|
ek_logical_and,
|
|
ek_logical_or,
|
|
|
|
ek_ternary,
|
|
|
|
ek_assign,
|
|
|
|
ek_comma,
|
|
} kind;
|
|
|
|
unsigned column;
|
|
|
|
struct string* string;
|
|
|
|
struct expression* center;
|
|
struct expression* left;
|
|
struct expression* right;
|
|
|
|
struct value* value;
|
|
|
|
unsigned refcount;
|
|
};
|
|
|
|
struct expression* inc_expression(struct expression* this);
|
|
|
|
struct expression* new_syntax_error_expression(
|
|
unsigned column,
|
|
struct string* error_message)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_syntax_error;
|
|
|
|
this->column = column;
|
|
this->string = inc_string(error_message);
|
|
this->center = NULL;
|
|
this->left = NULL;
|
|
this->right = NULL;
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_literal_expression(
|
|
struct value* value)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_literal;
|
|
this->string = NULL;;
|
|
this->center = NULL;
|
|
this->left = this->right = NULL;
|
|
this->value = inc_value(value);
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_variable_expression(
|
|
struct string* variable)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_variable;
|
|
this->string = inc_string(variable);
|
|
this->center = NULL;
|
|
this->left = this->right = NULL;
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_logical_not_expression(
|
|
struct expression* sub)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_logical_not;
|
|
this->string = NULL;
|
|
this->center = inc_expression(sub);
|
|
this->left = NULL;
|
|
this->right = NULL;
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_positive_expression(
|
|
struct expression* sub)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_positive;
|
|
this->string = NULL;
|
|
this->center = inc_expression(sub);
|
|
this->left = NULL;
|
|
this->right = NULL;
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_negative_expression(
|
|
struct expression* sub)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_negative;
|
|
this->string = NULL;
|
|
this->center = inc_expression(sub);
|
|
this->left = NULL;
|
|
this->right = NULL;
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_binary_expression(
|
|
enum expression_kind kind,
|
|
struct expression* left,
|
|
struct expression* right)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = kind;
|
|
this->string = NULL;
|
|
this->center = NULL;
|
|
this->left = inc_expression(left);
|
|
this->right = inc_expression(right);
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* new_ternary_expression(
|
|
struct expression* center,
|
|
struct expression* left,
|
|
struct expression* right)
|
|
{
|
|
struct expression* this = malloc(sizeof(*this));
|
|
|
|
this->kind = ek_ternary;
|
|
this->string = NULL;
|
|
this->center = inc_expression(center);
|
|
this->left = inc_expression(left);
|
|
this->right = inc_expression(right);
|
|
this->value = NULL;
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct expression* inc_expression(struct expression* this)
|
|
{
|
|
if (this)
|
|
this->refcount++;
|
|
|
|
return this;
|
|
}
|
|
|
|
void free_expression(struct expression* this)
|
|
{
|
|
if (this && !--this->refcount)
|
|
{
|
|
free_string(this->string);
|
|
|
|
free_expression(this->center);
|
|
free_expression(this->left);
|
|
free_expression(this->right);
|
|
|
|
free_value(this->value);
|
|
|
|
free(this);
|
|
}
|
|
}
|
|
|
|
enum value_kind
|
|
{
|
|
vk_number,
|
|
vk_error,
|
|
};
|
|
|
|
struct value
|
|
{
|
|
enum value_kind kind;
|
|
|
|
struct stringset* errors;
|
|
|
|
mpq_t mpq;
|
|
|
|
unsigned refcount;
|
|
};
|
|
|
|
struct value* new_error_value(struct stringset* errors)
|
|
{
|
|
struct value* this = malloc(sizeof(*this));
|
|
|
|
this->kind = vk_error;
|
|
|
|
this->errors = inc_stringset(errors);
|
|
|
|
mpq_init(this->mpq);
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct value* new_error_value_from_fmt(const char* fmt, ...)
|
|
{
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
|
|
struct string* message = new_string_from_fmt_va(fmt, va);
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_add(set, message);
|
|
|
|
struct value* this = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
|
|
free_string(message);
|
|
|
|
va_end(va);
|
|
|
|
return this;
|
|
}
|
|
|
|
struct value* new_error_value_from_union(
|
|
const struct value* left,
|
|
const struct value* right)
|
|
{
|
|
assert(left->kind == vk_error);
|
|
assert(right->kind == vk_error);
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
struct value* retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
|
|
return retval;
|
|
}
|
|
|
|
struct value* new_value_from_int(int x)
|
|
{
|
|
struct value* this = malloc(sizeof(*this));
|
|
|
|
this->kind = vk_number;
|
|
|
|
this->errors = NULL;
|
|
|
|
mpq_init(this->mpq);
|
|
|
|
mpq_set_si(this->mpq, x, 1);
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct value* new_value(mpq_t mpq)
|
|
{
|
|
struct value* this = malloc(sizeof(*this));
|
|
|
|
this->kind = vk_number;
|
|
|
|
this->errors = NULL;
|
|
|
|
mpq_init(this->mpq);
|
|
|
|
mpq_set(this->mpq, mpq);
|
|
|
|
this->refcount = 1;
|
|
|
|
return this;
|
|
}
|
|
|
|
struct value* inc_value(struct value* this)
|
|
{
|
|
if (this)
|
|
this->refcount++;
|
|
|
|
return this;
|
|
}
|
|
|
|
void free_value(struct value* this)
|
|
{
|
|
if (this && !--this->refcount)
|
|
{
|
|
mpq_clear(this->mpq);
|
|
|
|
free_stringset(this->errors);
|
|
|
|
free(this);
|
|
}
|
|
}
|
|
|
|
struct value* scan(const char* text)
|
|
{
|
|
const char* moving = text;
|
|
|
|
const char* digits = "0123456789";
|
|
|
|
unsigned ibase = 10;
|
|
|
|
if (text[0] == '0' && text[1] == 'b')
|
|
{
|
|
digits = "01";
|
|
ibase = 2;
|
|
moving += 2;
|
|
}
|
|
else if (text[0] == '0' && text[1] == 'x')
|
|
{
|
|
digits = "0123456789ABCDEF";
|
|
ibase = 16;
|
|
moving += 2;
|
|
}
|
|
|
|
mpq_t base; mpq_init(base);
|
|
mpq_t tmp; mpq_init(tmp);
|
|
mpq_t value; mpq_init(value);
|
|
|
|
mpq_set_si(value, 0, 1);
|
|
mpq_set_si(base, ibase, 1);
|
|
|
|
while ('_' == *moving || (*moving && index(digits, toupper(*moving))))
|
|
{
|
|
if ('_' == *moving)
|
|
{
|
|
moving++;
|
|
}
|
|
else
|
|
{
|
|
mpq_set_si(tmp, index(digits, toupper(*moving++)) - digits, 1);
|
|
|
|
mpq_mul(value, value, base);
|
|
mpq_add(value, value, tmp);
|
|
}
|
|
}
|
|
|
|
while ('_' == *moving)
|
|
{
|
|
moving++;
|
|
}
|
|
|
|
if (*moving == '.')
|
|
{
|
|
mpq_t factor; mpq_init(factor);
|
|
|
|
moving++;
|
|
|
|
mpq_set_si(factor, 1, ibase);
|
|
|
|
while ('_' == *moving || (*moving && index(digits, toupper(*moving))))
|
|
{
|
|
if ('_' == *moving)
|
|
{
|
|
moving++;
|
|
}
|
|
else
|
|
{
|
|
mpq_set_si(tmp, index(digits, toupper(*moving++)) - digits, 1);
|
|
|
|
mpq_mul(tmp, factor, tmp);
|
|
|
|
mpq_add(value, value, tmp);
|
|
|
|
mpq_div(factor, factor, base);
|
|
}
|
|
}
|
|
|
|
mpq_clear(factor);
|
|
}
|
|
|
|
while ('_' == *moving)
|
|
{
|
|
moving++;
|
|
}
|
|
|
|
assert(*moving == '\0');
|
|
|
|
struct value* retval = new_value(value);
|
|
|
|
mpq_clear(base);
|
|
mpq_clear(tmp);
|
|
mpq_clear(value);
|
|
|
|
return retval;
|
|
}
|
|
|
|
struct scope
|
|
{
|
|
avl_tree_t* tree;
|
|
};
|
|
|
|
struct variable
|
|
{
|
|
struct string* name;
|
|
struct value* value;
|
|
};
|
|
|
|
struct variable* new_variable(struct string* name)
|
|
{
|
|
struct variable* this = malloc(sizeof(*this));
|
|
|
|
this->name = inc_string(name);
|
|
|
|
this->value = NULL;
|
|
|
|
return this;
|
|
}
|
|
|
|
int compare_variable(const void* a, const void* b)
|
|
{
|
|
const struct variable* A = a, *B = b;
|
|
|
|
return strcmp(A->name->data, B->name->data);
|
|
}
|
|
|
|
void free_variable(void* ptr)
|
|
{
|
|
struct variable* this = ptr;
|
|
|
|
free_string(this->name);
|
|
|
|
free_value(this->value);
|
|
|
|
free(this);
|
|
}
|
|
|
|
struct scope* new_scope(void)
|
|
{
|
|
struct scope* this = malloc(sizeof(*this));
|
|
|
|
this->tree = avl_alloc_tree(compare_variable, free_variable);
|
|
|
|
return this;
|
|
}
|
|
|
|
struct value** scope_lookup(
|
|
struct scope* this,
|
|
struct string* name)
|
|
{
|
|
struct avl_node_t* node = avl_search(this->tree, &name);
|
|
|
|
if (!node)
|
|
{
|
|
struct variable* var = new_variable(name);
|
|
|
|
node = avl_insert(this->tree, var);
|
|
}
|
|
|
|
return &((struct variable*) node->item)->value;
|
|
}
|
|
|
|
void free_scope(struct scope* this)
|
|
{
|
|
avl_free_tree(this->tree);
|
|
|
|
free(this);
|
|
}
|
|
|
|
enum token
|
|
{
|
|
t_uninitialized,
|
|
|
|
t_error,
|
|
|
|
// primary:
|
|
t_identifier,
|
|
t_literal,
|
|
t_binary,
|
|
t_hexadecimal,
|
|
|
|
// brakets:
|
|
t_oparen,
|
|
t_cparen,
|
|
|
|
// arithmetic operators:
|
|
t_plus,
|
|
t_minus,
|
|
t_asterisk,
|
|
t_slash,
|
|
t_percent,
|
|
t_slash_slash,
|
|
t_asterisk_asterisk,
|
|
|
|
// comparision operators:
|
|
t_lessthan,
|
|
t_lessthan_equals,
|
|
t_lessthan_lessthan,
|
|
|
|
t_greaterthan,
|
|
t_greaterthan_equals,
|
|
t_greaterthan_greaterthan,
|
|
|
|
t_emark_equals,
|
|
t_equals_equals,
|
|
|
|
// logical operators:
|
|
t_vbar_vbar,
|
|
t_ampersand_ampersand,
|
|
|
|
// misc:
|
|
t_emark,
|
|
t_qmark,
|
|
t_colon,
|
|
t_equals,
|
|
t_comma,
|
|
|
|
t_EOF,
|
|
|
|
number_of_tokens,
|
|
};
|
|
|
|
static const char* const tokennames[number_of_tokens] = {
|
|
[t_EOF] = "EOF",
|
|
|
|
[t_identifier] = "identifier",
|
|
[t_literal] = "literal",
|
|
[t_binary] = "binary-literal",
|
|
[t_hexadecimal] = "hexadecimal-literal",
|
|
[t_oparen] = "open parentheses",
|
|
[t_cparen] = "close parentheses",
|
|
[t_plus] = "plus",
|
|
[t_minus] = "minus",
|
|
[t_asterisk] = "asterisk",
|
|
[t_asterisk_asterisk] = "double-asterisk",
|
|
[t_percent] = "percent",
|
|
[t_slash] = "slash",
|
|
[t_slash_slash] = "double-slash",
|
|
[t_lessthan] = "less-than",
|
|
[t_lessthan_equals] = "less-than-or-equal-to",
|
|
[t_greaterthan] = "greater-than",
|
|
[t_greaterthan_equals] = "greater-than-or-equal-to",
|
|
[t_emark_equals] = "not-equal-to",
|
|
[t_equals_equals] = "equal-to",
|
|
[t_vbar_vbar] = "logical-or",
|
|
[t_ampersand_ampersand] = "logical-and",
|
|
[t_emark] = "exclamation mark",
|
|
[t_qmark] = "question mark",
|
|
[t_colon] = "colon",
|
|
[t_equals] = "assignment",
|
|
[t_comma] = "comma",
|
|
};
|
|
|
|
struct tokenizer
|
|
{
|
|
const char* text;
|
|
|
|
unsigned start_index;
|
|
unsigned index;
|
|
|
|
enum token token;
|
|
|
|
struct buffer {
|
|
char* data;
|
|
size_t n, cap;
|
|
} buffer;
|
|
};
|
|
|
|
struct tokenizer* new_tokenizer(const char* text)
|
|
{
|
|
struct tokenizer* this = malloc(sizeof(*this));
|
|
|
|
this->text = text;
|
|
|
|
this->start_index = 0;
|
|
this->index = 0;
|
|
|
|
this->token = t_uninitialized;
|
|
|
|
this->buffer.data = NULL;
|
|
this->buffer.n = 0;
|
|
this->buffer.cap = 0;
|
|
|
|
return this;
|
|
}
|
|
|
|
void tokenizer_append_char(
|
|
struct tokenizer* this,
|
|
char code)
|
|
{
|
|
if (this->buffer.n == this->buffer.cap)
|
|
{
|
|
this->buffer.cap = this->buffer.cap << 1 ?: 1;
|
|
|
|
this->buffer.data = realloc(
|
|
this->buffer.data,
|
|
sizeof(*this->buffer.data) * this->buffer.cap);
|
|
}
|
|
|
|
this->buffer.data[this->buffer.n++] = code;
|
|
}
|
|
|
|
enum tokenizer_state {
|
|
ts_error,
|
|
|
|
ts_EOF,
|
|
|
|
ts_literal,
|
|
|
|
ts_identifier,
|
|
|
|
ts_equals,
|
|
ts_comma,
|
|
ts_slash,
|
|
ts_plus,
|
|
ts_minus,
|
|
ts_qmark,
|
|
ts_emark,
|
|
ts_colon,
|
|
ts_percent,
|
|
ts_asterisk,
|
|
ts_asterisk_asterisk,
|
|
ts_lessthan,
|
|
ts_lessthan_equals,
|
|
ts_lessthan_lessthan,
|
|
ts_greaterthan,
|
|
ts_greaterthan_equals,
|
|
ts_greaterthan_greaterthan,
|
|
ts_equals_equals,
|
|
ts_slash_slash,
|
|
|
|
ts_oparen,
|
|
ts_cparen,
|
|
|
|
ts_vbar_vbar,
|
|
|
|
ts_start,
|
|
|
|
ts_reading_literal_prefix,
|
|
ts_reading_literal,
|
|
ts_reading_literal2,
|
|
ts_reading_literal_binary,
|
|
ts_reading_literal_binary2,
|
|
ts_reading_literal_hexadecimal,
|
|
ts_reading_literal_hexadecimal2,
|
|
|
|
ts_reading_identifier,
|
|
|
|
ts_reading_equals,
|
|
ts_reading_equals_equals,
|
|
ts_reading_slash,
|
|
ts_reading_slash_slash,
|
|
ts_reading_comma,
|
|
ts_reading_plus,
|
|
ts_reading_minus,
|
|
ts_reading_qmark,
|
|
ts_reading_emark,
|
|
ts_reading_colon,
|
|
ts_reading_asterisk,
|
|
ts_reading_asterisk_asterisk,
|
|
ts_reading_percent,
|
|
ts_reading_lessthan,
|
|
ts_reading_lessthan_equals,
|
|
ts_reading_lessthan_lessthan,
|
|
ts_reading_greaterthan,
|
|
ts_reading_greaterthan_equals,
|
|
ts_reading_greaterthan_greaterthan,
|
|
|
|
ts_reading_oparen,
|
|
ts_reading_cparen,
|
|
|
|
ts_reading_vbar,
|
|
ts_reading_vbar_vbar,
|
|
|
|
number_of_tokenizer_states,
|
|
} tokenizer_lookup[number_of_tokenizer_states][128] = {
|
|
#define ANY 0 ... 127
|
|
|
|
// skip whitespace:
|
|
[ts_start][' '] = ts_start,
|
|
|
|
// EOF token:
|
|
[ts_start][0] = ts_EOF,
|
|
|
|
// binary: "0b" ['_', '0', '1']+ ('.' ['_', '0', '1']*)?
|
|
// hexadecimal: "0x" [_0-9a-fA-F]+ (.[_0-9a-fA-F]*)?
|
|
// literal: [0-9]+ [_0-9]* (. [_0-9]*)?
|
|
[ts_start]['0'] = ts_reading_literal_prefix,
|
|
[ts_reading_literal_prefix][ANY] = ts_literal,
|
|
[ts_reading_literal_prefix]['b'] = ts_reading_literal_binary,
|
|
[ts_reading_literal_binary][ ANY ] = ts_literal,
|
|
[ts_reading_literal_binary]['0' ... '1'] = ts_reading_literal_binary,
|
|
[ts_reading_literal_binary][ '_' ] = ts_reading_literal_binary,
|
|
[ts_reading_literal_binary][ '.' ] = ts_reading_literal_binary2,
|
|
[ts_reading_literal_binary2][ ANY ] = ts_literal,
|
|
[ts_reading_literal_binary2][ '_' ] = ts_reading_literal_binary2,
|
|
[ts_reading_literal_binary2]['0' ... '1'] = ts_reading_literal_binary2,
|
|
[ts_reading_literal_prefix]['x'] = ts_reading_literal_hexadecimal,
|
|
[ts_reading_literal_hexadecimal][ ANY ] = ts_literal,
|
|
[ts_reading_literal_hexadecimal]['0' ... '9'] = ts_reading_literal_hexadecimal,
|
|
[ts_reading_literal_hexadecimal]['a' ... 'f'] = ts_reading_literal_hexadecimal,
|
|
[ts_reading_literal_hexadecimal]['A' ... 'F'] = ts_reading_literal_hexadecimal,
|
|
[ts_reading_literal_hexadecimal][ '_' ] = ts_reading_literal_hexadecimal,
|
|
[ts_reading_literal_hexadecimal][ '.' ] = ts_reading_literal_hexadecimal2,
|
|
[ts_reading_literal_hexadecimal2][ ANY ] = ts_literal,
|
|
[ts_reading_literal_hexadecimal2][ '_' ] = ts_reading_literal_hexadecimal2,
|
|
[ts_reading_literal_hexadecimal2]['0' ... '9'] = ts_reading_literal_hexadecimal2,
|
|
[ts_reading_literal_hexadecimal2]['a' ... 'f'] = ts_reading_literal_hexadecimal2,
|
|
[ts_reading_literal_hexadecimal2]['A' ... 'F'] = ts_reading_literal_hexadecimal2,
|
|
[ts_reading_literal_prefix]['_'] = ts_reading_literal,
|
|
[ts_reading_literal_prefix]['.'] = ts_reading_literal2,
|
|
[ts_reading_literal_prefix]['0' ... '9'] = ts_reading_literal,
|
|
[ts_start]['1' ... '9'] = ts_reading_literal,
|
|
[ts_reading_literal][ ANY ] = ts_literal,
|
|
[ts_reading_literal][ '_' ] = ts_reading_literal,
|
|
[ts_reading_literal]['0' ... '9'] = ts_reading_literal,
|
|
[ts_reading_literal]['a' ... 'z'] = ts_error,
|
|
[ts_reading_literal][ '.' ] = ts_reading_literal2,
|
|
[ts_reading_literal2][ ANY ] = ts_literal,
|
|
[ts_reading_literal2][ '_' ] = ts_reading_literal2,
|
|
[ts_reading_literal2]['0' ... '9'] = ts_reading_literal2,
|
|
|
|
// identifiers:
|
|
[ts_start][ '_' ] = ts_reading_identifier,
|
|
[ts_start]['a' ... 'z'] = ts_reading_identifier,
|
|
[ts_reading_identifier][ ANY ] = ts_identifier,
|
|
[ts_reading_identifier][ '_' ] = ts_reading_identifier,
|
|
[ts_reading_identifier]['0' ... '9'] = ts_reading_identifier,
|
|
[ts_reading_identifier]['a' ... 'z'] = ts_reading_identifier,
|
|
|
|
// symbols:
|
|
|
|
[ts_start]['+'] = ts_reading_plus, [ts_reading_plus][ANY] = ts_plus,
|
|
|
|
[ts_start]['-'] = ts_reading_minus, [ts_reading_minus][ANY] = ts_minus,
|
|
|
|
[ts_start]['%'] = ts_reading_percent, [ts_reading_percent][ANY] = ts_percent,
|
|
|
|
[ts_start]['?'] = ts_reading_qmark, [ts_reading_qmark][ANY] = ts_qmark,
|
|
|
|
[ts_start]['!'] = ts_reading_emark, [ts_reading_emark][ANY] = ts_emark,
|
|
|
|
[ts_start][':'] = ts_reading_colon, [ts_reading_colon][ANY] = ts_colon,
|
|
|
|
[ts_start][','] = ts_reading_comma, [ts_reading_comma][ANY] = ts_comma,
|
|
|
|
[ts_start]['('] = ts_reading_oparen, [ts_reading_oparen][ANY] = ts_oparen,
|
|
[ts_start][')'] = ts_reading_cparen, [ts_reading_cparen][ANY] = ts_cparen,
|
|
|
|
// '*' or '**'
|
|
[ts_start]['*'] = ts_reading_asterisk,
|
|
[ts_reading_asterisk][ANY] = ts_asterisk,
|
|
[ts_reading_asterisk]['*'] = ts_reading_asterisk_asterisk,
|
|
[ts_reading_asterisk_asterisk][ANY] = ts_asterisk_asterisk,
|
|
|
|
// '/' or '//':
|
|
[ts_start]['/'] = ts_reading_slash,
|
|
[ts_reading_slash][ANY] = ts_slash,
|
|
[ts_reading_slash]['/'] = ts_reading_slash_slash,
|
|
[ts_reading_slash_slash][ANY] = ts_slash_slash,
|
|
|
|
// '=' or '==':
|
|
[ts_start]['='] = ts_reading_equals,
|
|
[ts_reading_equals][ANY] = ts_equals,
|
|
[ts_reading_equals]['='] = ts_reading_equals_equals,
|
|
[ts_reading_equals_equals][ANY] = ts_equals_equals,
|
|
|
|
// '<' or '<=' or '<<':
|
|
[ts_start]['<'] = ts_reading_lessthan,
|
|
[ts_reading_lessthan][ANY] = ts_lessthan,
|
|
[ts_reading_lessthan]['='] = ts_reading_lessthan_equals,
|
|
[ts_reading_lessthan_equals][ANY] = ts_lessthan_equals,
|
|
[ts_reading_lessthan]['<'] = ts_reading_lessthan_lessthan,
|
|
[ts_reading_lessthan_lessthan][ANY] = ts_lessthan_lessthan,
|
|
|
|
// '>' or '>=' or '>>':
|
|
[ts_start]['>'] = ts_reading_greaterthan,
|
|
[ts_reading_greaterthan][ANY] = ts_greaterthan,
|
|
[ts_reading_greaterthan]['='] = ts_reading_greaterthan_equals,
|
|
[ts_reading_greaterthan_equals][ANY] = ts_greaterthan_equals,
|
|
[ts_reading_greaterthan]['>'] = ts_reading_greaterthan_greaterthan,
|
|
[ts_reading_greaterthan_greaterthan][ANY] = ts_greaterthan_greaterthan,
|
|
|
|
// '||':
|
|
[ts_start]['|'] = ts_reading_vbar,
|
|
[ts_reading_vbar]['|'] = ts_reading_vbar_vbar,
|
|
[ts_reading_vbar_vbar][ANY] = ts_vbar_vbar,
|
|
};
|
|
|
|
void tokenizer_next(
|
|
struct tokenizer* this)
|
|
{
|
|
this->buffer.n = 0;
|
|
|
|
this->start_index = this->index;
|
|
|
|
enum tokenizer_state state = ts_start;
|
|
|
|
while (state >= ts_start)
|
|
{
|
|
assert(this->text[this->index] >= 0);
|
|
|
|
state = tokenizer_lookup[state][(uint8_t) this->text[this->index]];
|
|
|
|
if (state > ts_start)
|
|
{
|
|
tokenizer_append_char(this, this->text[this->index]);
|
|
|
|
this->index++;
|
|
}
|
|
|
|
if (state == ts_start)
|
|
{
|
|
this->buffer.n = 0;
|
|
|
|
this->index++;
|
|
|
|
this->start_index = this->index;
|
|
}
|
|
}
|
|
|
|
// for sake of the error message:
|
|
if (state == ts_error)
|
|
{
|
|
tokenizer_append_char(this, this->text[this->index]);
|
|
}
|
|
|
|
tokenizer_append_char(this, '\0');
|
|
|
|
switch (state)
|
|
{
|
|
case ts_error:
|
|
{
|
|
this->token = t_error;
|
|
break;
|
|
}
|
|
|
|
case ts_EOF:
|
|
{
|
|
this->token = t_EOF;
|
|
break;
|
|
}
|
|
|
|
case ts_literal:
|
|
{
|
|
this->token = t_literal;
|
|
break;
|
|
}
|
|
|
|
case ts_identifier:
|
|
{
|
|
this->token = t_identifier;
|
|
break;
|
|
}
|
|
|
|
case ts_equals:
|
|
{
|
|
this->token = t_equals;
|
|
break;
|
|
}
|
|
|
|
case ts_comma:
|
|
{
|
|
this->token = t_comma;
|
|
break;
|
|
}
|
|
|
|
case ts_plus:
|
|
{
|
|
this->token = t_plus;
|
|
break;
|
|
}
|
|
|
|
case ts_qmark:
|
|
{
|
|
this->token = t_qmark;
|
|
break;
|
|
}
|
|
|
|
case ts_minus:
|
|
{
|
|
this->token = t_minus;
|
|
break;
|
|
}
|
|
|
|
case ts_slash:
|
|
{
|
|
this->token = t_slash;
|
|
break;
|
|
}
|
|
|
|
case ts_equals_equals:
|
|
{
|
|
this->token = t_equals_equals;
|
|
break;
|
|
}
|
|
|
|
case ts_emark:
|
|
{
|
|
this->token = t_emark;
|
|
break;
|
|
}
|
|
|
|
case ts_oparen:
|
|
{
|
|
this->token = t_oparen;
|
|
break;
|
|
}
|
|
|
|
case ts_cparen:
|
|
{
|
|
this->token = t_cparen;
|
|
break;
|
|
}
|
|
|
|
case ts_percent:
|
|
{
|
|
this->token = t_percent;
|
|
break;
|
|
}
|
|
|
|
case ts_lessthan:
|
|
{
|
|
this->token = t_lessthan;
|
|
break;
|
|
}
|
|
|
|
case ts_lessthan_equals:
|
|
{
|
|
this->token = t_lessthan_equals;
|
|
break;
|
|
}
|
|
|
|
case ts_colon:
|
|
{
|
|
this->token = t_colon;
|
|
break;
|
|
}
|
|
|
|
case ts_asterisk:
|
|
{
|
|
this->token = t_asterisk;
|
|
break;
|
|
}
|
|
|
|
case ts_vbar_vbar:
|
|
{
|
|
this->token = t_vbar_vbar;
|
|
break;
|
|
}
|
|
|
|
case ts_slash_slash:
|
|
{
|
|
this->token = t_slash_slash;
|
|
break;
|
|
}
|
|
|
|
case ts_lessthan_lessthan:
|
|
{
|
|
this->token = t_lessthan_lessthan;
|
|
break;
|
|
}
|
|
|
|
case ts_greaterthan_greaterthan:
|
|
{
|
|
this->token = t_greaterthan_greaterthan;
|
|
break;
|
|
}
|
|
|
|
case ts_asterisk_asterisk:
|
|
{
|
|
this->token = t_asterisk_asterisk;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
TODO;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void free_tokenizer(
|
|
struct tokenizer* this)
|
|
{
|
|
free(this->buffer.data);
|
|
free(this);
|
|
}
|
|
|
|
struct string* make_unexpected_token_message(
|
|
struct tokenizer* tokenizer)
|
|
{
|
|
if (tokenizer->token == t_error)
|
|
{
|
|
return new_string_from_fmt(
|
|
"unexpected unknown token '%s'",
|
|
tokenizer->buffer.data);
|
|
}
|
|
else
|
|
{
|
|
assert(tokennames[tokenizer->token]);
|
|
|
|
return new_string_from_fmt(
|
|
"unexpected %s token",
|
|
tokennames[tokenizer->token]);
|
|
}
|
|
}
|
|
|
|
struct expression* parse_root(struct tokenizer* tokenizer);
|
|
|
|
struct expression* parse_primary(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* retval = NULL;
|
|
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_error:
|
|
{
|
|
struct string* message = new_string_from_fmt(
|
|
"unknown token '%s'", tokenizer->buffer.data);
|
|
|
|
retval = new_syntax_error_expression(
|
|
/* column: */ tokenizer->start_index + 1,
|
|
/* message: */ message);
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
free_string(message);
|
|
break;
|
|
}
|
|
|
|
case t_literal:
|
|
{
|
|
struct value* value = scan(tokenizer->buffer.data);
|
|
|
|
retval = new_literal_expression(value);
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
free_value(value);
|
|
break;
|
|
}
|
|
|
|
case t_hexadecimal:
|
|
{
|
|
TODO;
|
|
break;
|
|
}
|
|
|
|
case t_identifier:
|
|
{
|
|
struct string* name = new_string(tokenizer->buffer.data);
|
|
|
|
retval = new_variable_expression(name);
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
free_string(name);
|
|
break;
|
|
}
|
|
|
|
case t_oparen:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* sub = parse_root(tokenizer);
|
|
|
|
if (sub->kind == ek_syntax_error)
|
|
{
|
|
retval = inc_expression(sub);
|
|
}
|
|
else if (tokenizer->token == t_cparen)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
retval = inc_expression(sub);
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
free_expression(sub);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
struct string* message = make_unexpected_token_message(tokenizer);
|
|
|
|
retval = new_syntax_error_expression(
|
|
/* column: */ tokenizer->start_index + 1,
|
|
/* message: */ message);
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
free_string(message);
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(retval);
|
|
|
|
return retval;
|
|
}
|
|
|
|
struct expression* parse_prefix(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* retval = NULL;
|
|
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_emark:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* sub = parse_prefix(tokenizer);
|
|
|
|
if (sub->kind == ek_syntax_error)
|
|
{
|
|
retval = sub;
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct expression* retval =
|
|
new_logical_not_expression(sub);
|
|
|
|
free_expression(sub);
|
|
|
|
return retval;
|
|
#endif
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case t_plus:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* sub = parse_prefix(tokenizer);
|
|
|
|
if (sub->kind == ek_syntax_error)
|
|
{
|
|
retval = sub;
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
retval = new_positive_expression(sub);
|
|
|
|
free_expression(sub);
|
|
#endif
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case t_minus:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* sub = parse_prefix(tokenizer);
|
|
|
|
if (sub->kind == ek_syntax_error)
|
|
{
|
|
retval = inc_expression(sub);
|
|
}
|
|
else
|
|
{
|
|
retval = new_negative_expression(sub);
|
|
}
|
|
|
|
free_expression(sub);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
retval = parse_primary(tokenizer);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(retval);
|
|
|
|
return retval;
|
|
}
|
|
|
|
struct expression* parse_exponent(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_prefix(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (tokenizer->token == t_asterisk_asterisk))
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_prefix(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_exponent, left, right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_multiplicative(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_exponent(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (false
|
|
|| tokenizer->token == t_asterisk
|
|
|| tokenizer->token == t_slash
|
|
|| tokenizer->token == t_slash_slash
|
|
|| tokenizer->token == t_percent))
|
|
{
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_asterisk:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_exponent(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_multiply, left, right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_slash:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_exponent(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_divide, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_slash_slash:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_exponent(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_integer_divide, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_percent:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_exponent(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_remainder, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_additive(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_multiplicative(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (false
|
|
|| tokenizer->token == t_plus
|
|
|| tokenizer->token == t_minus))
|
|
{
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_plus:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_multiplicative(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = right;
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_add, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case t_minus:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_multiplicative(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_subtract, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
TODO;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_shift(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_additive(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (false
|
|
|| tokenizer->token == t_lessthan_lessthan
|
|
|| tokenizer->token == t_greaterthan_greaterthan))
|
|
{
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_lessthan_lessthan:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_additive(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = right;
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_leftbitshift, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case t_greaterthan_greaterthan:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_additive(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_rightbitshift, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
TODO;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_comparision(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_shift(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (false
|
|
|| tokenizer->token == t_lessthan
|
|
|| tokenizer->token == t_lessthan_equals
|
|
|| tokenizer->token == t_greaterthan
|
|
|| tokenizer->token == t_greaterthan_equals))
|
|
{
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_lessthan:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_shift(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_less_than, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_lessthan_equals:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_additive(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_less_than_equal_to, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_greaterthan:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
next_token();
|
|
|
|
struct expression* right =
|
|
parse_additive();
|
|
|
|
struct expression* retval =
|
|
new_binary_expression(ek_greater_than, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
|
|
goto again;
|
|
#endif
|
|
}
|
|
|
|
case t_greaterthan_equals:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
next_token();
|
|
|
|
struct expression* right =
|
|
parse_additive();
|
|
|
|
struct expression* retval =
|
|
new_binary_expression(ek_greater_than_equal_to, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
|
|
goto again;
|
|
#endif
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_equality(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_comparision(tokenizer);
|
|
|
|
while (true
|
|
&& left->kind != ek_syntax_error
|
|
&& (false
|
|
|| tokenizer->token == t_equals_equals
|
|
|| tokenizer->token == t_emark_equals))
|
|
{
|
|
switch (tokenizer->token)
|
|
{
|
|
case t_equals_equals:
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_comparision(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(left);
|
|
|
|
left = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* retval =
|
|
new_binary_expression(ek_equal_to, left, right);
|
|
|
|
free_expression(left);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
free_expression(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case t_emark_equals:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
next_token();
|
|
|
|
struct expression* right =
|
|
parse_comparision();
|
|
|
|
struct expression* retval =
|
|
new_binary_expression(ek_not_equal_to, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
|
|
goto again;
|
|
#endif
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_logical_and(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_equality(tokenizer);
|
|
|
|
while (tokenizer->token == t_ampersand_ampersand)
|
|
{
|
|
TODO;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_logical_or(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_logical_and(tokenizer);
|
|
|
|
while (tokenizer->token == t_vbar_vbar)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_comparision(tokenizer);
|
|
|
|
struct expression* retval =
|
|
new_binary_expression(ek_logical_or, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_ternary(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* center = parse_logical_or(tokenizer);
|
|
|
|
while (true
|
|
&& center->kind != ek_syntax_error
|
|
&& tokenizer->token == t_qmark)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* left = parse_root(tokenizer);
|
|
|
|
if (left->kind == ek_syntax_error)
|
|
{
|
|
free_expression(center);
|
|
|
|
center = inc_expression(left);
|
|
}
|
|
else if (tokenizer->token == t_colon)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_logical_or(tokenizer);
|
|
|
|
if (right->kind == ek_syntax_error)
|
|
{
|
|
free_expression(center);
|
|
|
|
center = inc_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct expression* new = new_ternary_expression(center, left, right);
|
|
|
|
free_expression(center);
|
|
|
|
center = new;
|
|
}
|
|
|
|
free_expression(right);
|
|
}
|
|
else
|
|
{
|
|
struct string* message = make_unexpected_token_message(tokenizer);
|
|
|
|
struct expression* error = new_syntax_error_expression(
|
|
tokenizer->start_index + 1, message);
|
|
|
|
free_expression(center);
|
|
|
|
center = error;
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
free_string(message);
|
|
}
|
|
|
|
free_expression(left);
|
|
}
|
|
|
|
return center;
|
|
}
|
|
|
|
struct expression* parse_assign(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_ternary(tokenizer);
|
|
|
|
if (tokenizer->token == t_equals)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_assign(tokenizer);
|
|
|
|
struct expression* retval = new_binary_expression(ek_assign, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
return retval;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_comma(struct tokenizer* tokenizer)
|
|
{
|
|
struct expression* left = parse_assign(tokenizer);
|
|
|
|
while (tokenizer->token == t_comma)
|
|
{
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* right = parse_assign(tokenizer);
|
|
|
|
struct expression* retval = new_binary_expression(ek_comma, left, right);
|
|
|
|
free_expression(left);
|
|
free_expression(right);
|
|
|
|
left = retval;
|
|
}
|
|
|
|
return left;
|
|
}
|
|
|
|
struct expression* parse_root(struct tokenizer* tokenizer)
|
|
{
|
|
return parse_comma(tokenizer);
|
|
}
|
|
|
|
struct expression* parse(const char* text)
|
|
{
|
|
struct tokenizer* tokenizer = new_tokenizer(text);
|
|
|
|
tokenizer_next(tokenizer);
|
|
|
|
struct expression* root = parse_root(tokenizer);
|
|
|
|
if (root->kind != ek_syntax_error && tokenizer->token != t_EOF)
|
|
{
|
|
struct string* message = make_unexpected_token_message(tokenizer);
|
|
|
|
struct expression* error = new_syntax_error_expression(
|
|
tokenizer->start_index + 1, message);
|
|
|
|
free_expression(root);
|
|
|
|
root = error;
|
|
|
|
free_string(message);
|
|
}
|
|
|
|
free_tokenizer(tokenizer);
|
|
|
|
return root;
|
|
}
|
|
|
|
#if 0
|
|
struct value** evaluate_lvalue(
|
|
struct expression* expression,
|
|
struct scope* scope)
|
|
{
|
|
switch (expression->kind)
|
|
{
|
|
case ek_syntax_error: assert(0); break;
|
|
|
|
case ek_variable:
|
|
{
|
|
return scope_lookup(scope, expression->string);
|
|
}
|
|
|
|
case ek_literal: TODO; break;
|
|
|
|
case ek_add: TODO; break;
|
|
case ek_subtract: TODO; break;
|
|
case ek_multiply: TODO; break;
|
|
case ek_divide: TODO; break;
|
|
|
|
case ek_positive: TODO; break;
|
|
case ek_negative: TODO; break;
|
|
|
|
case ek_greater_than: TODO; break;
|
|
case ek_greater_than_equal_to: TODO; break;
|
|
case ek_less_than: TODO; break;
|
|
case ek_less_than_equal_to: TODO; break;
|
|
|
|
case ek_equal_to: TODO; break;
|
|
case ek_not_equal_to: TODO; break;
|
|
|
|
case ek_logical_not: TODO; break;
|
|
case ek_logical_and: TODO; break;
|
|
case ek_logical_or: TODO; break;
|
|
|
|
case ek_ternary: TODO; break;
|
|
|
|
case ek_remainder: TODO; break;
|
|
|
|
case ek_assign:
|
|
{
|
|
TODO;
|
|
break;
|
|
};
|
|
|
|
case ek_comma:
|
|
{
|
|
TODO;
|
|
break;
|
|
};
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
struct value* evaluate(
|
|
struct expression* expression,
|
|
struct scope* scope)
|
|
{
|
|
struct value* retval = NULL;
|
|
|
|
switch (expression->kind)
|
|
{
|
|
case ek_syntax_error: assert(0); break;
|
|
|
|
case ek_variable:
|
|
{
|
|
struct value* val = *scope_lookup(scope, expression->string);
|
|
|
|
if (val)
|
|
{
|
|
retval = inc_value(val);
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: use of undefined variable '%s'!",
|
|
expression->string->data);
|
|
}
|
|
|
|
break;
|
|
};
|
|
|
|
case ek_literal:
|
|
{
|
|
retval = inc_value(expression->value);
|
|
break;
|
|
}
|
|
|
|
case ek_add:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_unionnew_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_add(q, left->mpq, right->mpq);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
}
|
|
|
|
case ek_subtract:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO
|
|
// new_error_value_from_union
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_sub(q, left->mpq, right->mpq);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
#endif
|
|
}
|
|
|
|
free_value(left);
|
|
|
|
free_value(right);
|
|
break;
|
|
}
|
|
|
|
case ek_multiply:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_mul(q, left->mpq, right->mpq);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
#endif
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_integer_divide:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else
|
|
{
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_div(q, left->mpq, right->mpq);
|
|
|
|
mpz_tdiv_q(mpq_numref(q), mpq_numref(q), mpq_denref(q));
|
|
|
|
mpz_set_si(mpq_denref(q), 1);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_rightbitshift:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
retval = new_error_value_from_union(left, right);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else if (mpz_cmp_si(mpq_denref(right->mpq), 1) == 0)
|
|
{
|
|
if (mpq_sgn(right->mpq) > 0)
|
|
{
|
|
if (mpz_fits_ulong_p(mpq_numref(right->mpq)))
|
|
{
|
|
unsigned long r = mpz_get_ui(mpq_numref(right->mpq));
|
|
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_div_2exp(q, left->mpq, r);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot right bitshift beyond ULONG_MAX");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot right bitshift by a negative value");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot right bitshift by a fractional value");
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_leftbitshift:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
retval = new_error_value_from_union(left, right);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else if (mpz_cmp_si(mpq_denref(right->mpq), 1) == 0)
|
|
{
|
|
if (mpq_sgn(right->mpq) > 0)
|
|
{
|
|
if (mpz_fits_ulong_p(mpq_numref(right->mpq)))
|
|
{
|
|
unsigned long rshift = mpz_get_ui(mpq_numref(right->mpq));
|
|
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_mul_2exp(q, left->mpq, rshift);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot left bitshift beyond ULONG_MAX");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot left bitshift by a negative value");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot left bitshift by fractional value");
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_exponent:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
retval = new_error_value_from_union(left, right);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else if (mpz_cmp_si(mpq_denref(right->mpq), 1) == 0)
|
|
{
|
|
if (mpq_sgn(right->mpq) > 0)
|
|
{
|
|
if (mpz_fits_ulong_p(mpq_numref(right->mpq)))
|
|
{
|
|
unsigned long rpow = mpz_get_ui(mpq_numref(right->mpq));
|
|
|
|
mpz_t n, d;
|
|
|
|
mpz_init(n), mpz_init(d);
|
|
|
|
mpz_pow_ui(n, mpq_numref(left->mpq), rpow);
|
|
mpz_pow_ui(d, mpq_denref(left->mpq), rpow);
|
|
|
|
mpq_t q, t;
|
|
|
|
mpq_init(q), mpq_init(t);
|
|
|
|
mpq_set_z(q, n);
|
|
mpq_set_z(t, d);
|
|
|
|
mpq_div(q, q, t);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q), mpq_clear(t);
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot exponentiate beyond ULONG_MAX");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: negative exponents not supported");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval = new_error_value_from_fmt(
|
|
"error: cannot exponentiate by a fraction");
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_divide:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_div(q, left->mpq, right->mpq);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
#endif
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_remainder:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
retval = inc_value(right);
|
|
}
|
|
else
|
|
{
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
// (x % y) => x - (x // y) * y
|
|
|
|
mpq_div(q, left->mpq, right->mpq);
|
|
|
|
mpz_tdiv_q(mpq_numref(q), mpq_numref(q), mpq_denref(q));
|
|
|
|
mpz_set_si(mpq_denref(q), 1);
|
|
|
|
mpq_mul(q, q, right->mpq);
|
|
|
|
mpq_sub(q, left->mpq, q);
|
|
|
|
retval = new_value(q);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_positive:
|
|
{
|
|
retval = evaluate(expression->center, scope);
|
|
break;
|
|
}
|
|
|
|
case ek_negative:
|
|
{
|
|
struct value* sub = evaluate(expression->center, scope);
|
|
|
|
if (sub->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
mpq_t q;
|
|
|
|
mpq_init(q);
|
|
|
|
mpq_neg(q, sub->mpq);
|
|
|
|
retval = new_value(q);
|
|
|
|
free_value(sub);
|
|
|
|
mpq_clear(q);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_greater_than:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) > 0);
|
|
|
|
free_value(left), free_value(right);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
case ek_greater_than_equal_to:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) >= 0);
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
case ek_less_than:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) < 0);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
}
|
|
|
|
case ek_less_than_equal_to:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) <= 0);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_equal_to:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (left->kind == vk_error && right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else if (left->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
}
|
|
else
|
|
{
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) == 0);
|
|
}
|
|
|
|
free_value(left), free_value(right);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_not_equal_to:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
retval = new_value_from_int(mpq_cmp(left->mpq, right->mpq) != 0);
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
case ek_logical_not:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* sub = evaluate(expression->center, scope);
|
|
|
|
retval = new_value_from_int(mpq_sgn(sub->mpq) == 0);
|
|
|
|
free_value(sub);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
case ek_logical_and:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* left = evaluate(expression->left, scope);
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
retval = new_value_from_int(
|
|
mpq_sgn(left->mpq) != 0 && mpq_sgn(right->mpq) != 0);
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
case ek_logical_or:
|
|
{
|
|
struct value* left = evaluate(expression->left, scope);
|
|
|
|
if (left->kind == vk_error)
|
|
{
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
if (right->kind == vk_error)
|
|
{
|
|
TODO;
|
|
// new_error_value_from_union
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_update(set, left->errors);
|
|
stringset_update(set, right->errors);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
}
|
|
else
|
|
{
|
|
retval = inc_value(left);
|
|
}
|
|
|
|
free_value(right);
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
#if 0
|
|
struct value* right = evaluate(expression->right, scope);
|
|
|
|
retval = new_value_from_int(
|
|
mpq_sgn(left->mpq) != 0 || mpq_sgn(right->mpq) != 0);
|
|
|
|
free_value(left), free_value(right);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
free_value(left);
|
|
|
|
break;
|
|
}
|
|
|
|
case ek_ternary:
|
|
{
|
|
struct value* conditional = evaluate(expression->center, scope);
|
|
|
|
if (conditional->kind == vk_error)
|
|
{
|
|
retval = inc_value(conditional);
|
|
}
|
|
else if (mpq_sgn(conditional->mpq) != 0)
|
|
{
|
|
retval = evaluate(expression->left, scope);
|
|
}
|
|
else
|
|
{
|
|
retval = evaluate(expression->right, scope);
|
|
}
|
|
|
|
free_value(conditional);
|
|
break;
|
|
}
|
|
|
|
case ek_assign:
|
|
{
|
|
if (expression->left->kind == ek_variable)
|
|
{
|
|
struct value** lvalue = scope_lookup(
|
|
scope, expression->left->string);
|
|
|
|
retval = evaluate(expression->right, scope);
|
|
|
|
free_value(*lvalue), *lvalue = inc_value(retval);
|
|
}
|
|
else
|
|
{
|
|
TODO;
|
|
|
|
struct string* message = new_string_from_fmt(
|
|
"error: cannot assign to rvalue-expressions");
|
|
|
|
struct stringset* set = new_stringset();
|
|
|
|
stringset_add(set, message);
|
|
|
|
retval = new_error_value(set);
|
|
|
|
free_stringset(set);
|
|
|
|
free_string(message);
|
|
}
|
|
|
|
break;
|
|
};
|
|
|
|
case ek_comma:
|
|
{
|
|
TODO;
|
|
#if 0
|
|
free_value(evaluate(expression->left, scope));
|
|
|
|
retval = evaluate(expression->right, scope);
|
|
|
|
break;
|
|
#endif
|
|
};
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
void print_mpz(const mpz_t x_ro, const char* digits[10])
|
|
{
|
|
assert(mpz_sgn(x_ro) > 0);
|
|
|
|
mpz_t x, d, b;
|
|
|
|
mpz_init(x), mpz_init(d), mpz_init(b);
|
|
|
|
mpz_set(x, x_ro);
|
|
|
|
mpz_set_ui(b, 10);
|
|
|
|
size_t n = mpz_sizeinbase(x, 10);
|
|
|
|
unsigned *buffer = malloc(sizeof(*buffer) * n);
|
|
unsigned *moving = buffer;
|
|
|
|
while (mpz_sgn(x))
|
|
{
|
|
mpz_fdiv_qr(x, d, x, b);
|
|
|
|
assert(mpz_fits_uint_p(d));
|
|
|
|
unsigned int diu = (unsigned int) mpz_get_ui(d);
|
|
|
|
assert(diu < 10);
|
|
|
|
*moving++ = diu;
|
|
}
|
|
|
|
while (moving > buffer)
|
|
{
|
|
printf("%s", digits[*--moving]);
|
|
}
|
|
|
|
free(buffer);
|
|
|
|
mpz_clear(x), mpz_clear(d), mpz_clear(b);
|
|
}
|
|
|
|
void print(struct value* this)
|
|
{
|
|
switch (this->kind)
|
|
{
|
|
case vk_error:
|
|
{
|
|
stringset_println(this->errors);
|
|
|
|
break;
|
|
}
|
|
|
|
case vk_number:
|
|
{
|
|
mpq_t v;
|
|
|
|
mpq_init(v);
|
|
|
|
mpq_set(v, this->mpq);
|
|
|
|
if (mpq_sgn(v) == 0)
|
|
{
|
|
putchar('0');
|
|
}
|
|
else
|
|
{
|
|
if (mpq_sgn(v) < 0)
|
|
{
|
|
putchar('-');
|
|
|
|
mpq_abs(v, v);
|
|
}
|
|
|
|
mpz_t q;
|
|
|
|
mpz_init(q);
|
|
|
|
mpz_fdiv_q(q, mpq_numref(v), mpq_denref(v));
|
|
|
|
if (mpz_sgn(q) > 0)
|
|
{
|
|
print_mpz(q,
|
|
(const char*[10]){"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"});
|
|
|
|
putchar(' ');
|
|
}
|
|
|
|
mpq_t qq;
|
|
|
|
mpq_init(qq);
|
|
|
|
mpq_set_z(qq, q);
|
|
|
|
mpq_sub(v, v, qq);
|
|
|
|
if (mpq_sgn(v) > 0)
|
|
{
|
|
print_mpz(mpq_numref(v),
|
|
(const char*[10]){"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"});
|
|
|
|
putchar('/');
|
|
|
|
print_mpz(mpq_denref(v),
|
|
(const char*[10]){"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"});
|
|
}
|
|
|
|
mpq_clear(qq);
|
|
|
|
mpz_clear(q);
|
|
}
|
|
|
|
mpq_clear(v);
|
|
|
|
puts("");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void syntax_error_print(
|
|
const struct expression* this)
|
|
{
|
|
assert(this->kind == ek_syntax_error);
|
|
|
|
printf("%*s↑\n", this->column - 1, "");
|
|
printf("%*s└ %s\n", this->column - 1, "", this->string->data);
|
|
}
|
|
|
|
int main(int argc, char* const* argv)
|
|
{
|
|
int retval = 0;
|
|
|
|
parse_args(argc, argv);
|
|
|
|
if (command)
|
|
{
|
|
struct scope* scope = new_scope();
|
|
|
|
struct expression* expression = parse(command);
|
|
|
|
if (expression->kind == ek_syntax_error)
|
|
{
|
|
printf("syntax error!\n");
|
|
|
|
printf("%s\n", command);
|
|
|
|
syntax_error_print(expression);
|
|
|
|
retval = 1;
|
|
}
|
|
else
|
|
{
|
|
struct value* value = evaluate(expression, scope);
|
|
|
|
print(value);
|
|
|
|
free_value(value);
|
|
}
|
|
|
|
free_expression(expression);
|
|
|
|
free_scope(scope);
|
|
}
|
|
else
|
|
{
|
|
struct scope* scope = new_scope();
|
|
|
|
for (char* line; (line = readline(">>> ")); free(line))
|
|
{
|
|
if (!*line) continue;
|
|
|
|
add_history(line);
|
|
|
|
struct expression* expression = parse(line);
|
|
|
|
if (expression->kind == ek_syntax_error)
|
|
{
|
|
printf("syntax error!\n");
|
|
|
|
printf("%s\n", line);
|
|
|
|
syntax_error_print(expression);
|
|
|
|
retval = 1;
|
|
}
|
|
else
|
|
{
|
|
struct value* value = evaluate(expression, scope);
|
|
|
|
print(value);
|
|
|
|
free_value(value);
|
|
}
|
|
|
|
free_expression(expression);
|
|
}
|
|
|
|
free_scope(scope);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|